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
1205pub mod wlan_fullmac_impl__ordinals {
1206 pub const INIT: u64 = 0x593dfb6cb3f0f1aa;
1207 pub const QUERY: u64 = 0x28ac65f9da3941d4;
1208 pub const QUERY_SECURITY_SUPPORT: u64 = 0x11cf3fa6eeb93f84;
1209 pub const QUERY_SPECTRUM_MANAGEMENT_SUPPORT: u64 = 0x22ae7551d855b83a;
1210 pub const QUERY_TELEMETRY_SUPPORT: u64 = 0x4561479ca560827f;
1211 pub const START_SCAN: u64 = 0x26c17bf595aa161c;
1212 pub const CONNECT: u64 = 0x19eb0322efb07a76;
1213 pub const RECONNECT: u64 = 0x474084c4ef19ee71;
1214 pub const ROAM: u64 = 0x1e35dcc98b124b64;
1215 pub const AUTH_RESP: u64 = 0x5f7ea24b44a4aaeb;
1216 pub const DEAUTH: u64 = 0x112786eccbf12f37;
1217 pub const ASSOC_RESP: u64 = 0x5022ce6b8eefec2f;
1218 pub const DISASSOC: u64 = 0x9c0fc4e8de53e01;
1219 pub const START_BSS: u64 = 0x6922644d6b1d341d;
1220 pub const STOP_BSS: u64 = 0x5aeb9b72e7575268;
1221 pub const SET_KEYS: u64 = 0x20f46b1e039f0985;
1222 pub const EAPOL_TX: u64 = 0x529a2d90fd4c8177;
1223 pub const GET_IFACE_STATS: u64 = 0x505563776ef0392f;
1224 pub const GET_IFACE_HISTOGRAM_STATS: u64 = 0x503d586f30ccf2cd;
1225 pub const SAE_HANDSHAKE_RESP: u64 = 0x72cd3a31ae5a54f6;
1226 pub const SAE_FRAME_TX: u64 = 0x4715ad5dc5a6340f;
1227 pub const WMM_STATUS_REQ: u64 = 0x635ecef3beb7a059;
1228 pub const ON_LINK_STATE_CHANGED: u64 = 0x4d896e5b68e488d7;
1229}
1230
1231pub mod wlan_fullmac_impl_ifc_ordinals {
1232 pub const ON_SCAN_RESULT: u64 = 0x29aa81dc570f7a3e;
1233 pub const ON_SCAN_END: u64 = 0x7cd8aff80d27073c;
1234 pub const CONNECT_CONF: u64 = 0x3c22c6d80b2a2759;
1235 pub const ROAM_CONF: u64 = 0x368b2a5b903b3f7b;
1236 pub const ROAM_START_IND: u64 = 0x23e1d9368935e7e4;
1237 pub const ROAM_RESULT_IND: u64 = 0x7081c1b1ceea4914;
1238 pub const AUTH_IND: u64 = 0x270e1f8889650d0b;
1239 pub const DEAUTH_CONF: u64 = 0x2c94b0d7258111b7;
1240 pub const DEAUTH_IND: u64 = 0x26cd27cdadd8dbaf;
1241 pub const ASSOC_IND: u64 = 0x3e44529e3dc179ce;
1242 pub const DISASSOC_CONF: u64 = 0x7c713bcd58a76cb3;
1243 pub const DISASSOC_IND: u64 = 0x6667b381b7f3990f;
1244 pub const START_CONF: u64 = 0x3e9b9641f3ddc7fc;
1245 pub const STOP_CONF: u64 = 0x320a5ff227a4e9df;
1246 pub const EAPOL_CONF: u64 = 0x77364db9cc3970ec;
1247 pub const ON_CHANNEL_SWITCH: u64 = 0x21db0b8f71cae647;
1248 pub const SIGNAL_REPORT: u64 = 0x79679fa8789c3d9f;
1249 pub const EAPOL_IND: u64 = 0x3de8ec1eda10d1d0;
1250 pub const ON_PMK_AVAILABLE: u64 = 0x5cedd8d9be28a17e;
1251 pub const SAE_HANDSHAKE_IND: u64 = 0x4f3d53885503a1d8;
1252 pub const SAE_FRAME_RX: u64 = 0x51650906857ed4d4;
1253 pub const ON_WMM_STATUS_RESP: u64 = 0x6823a88bf3ba8b2a;
1254}
1255
1256mod internal {
1257 use super::*;
1258 unsafe impl fidl::encoding::TypeMarker for EapolTxResult {
1259 type Owned = Self;
1260
1261 #[inline(always)]
1262 fn inline_align(_context: fidl::encoding::Context) -> usize {
1263 std::mem::align_of::<u8>()
1264 }
1265
1266 #[inline(always)]
1267 fn inline_size(_context: fidl::encoding::Context) -> usize {
1268 std::mem::size_of::<u8>()
1269 }
1270
1271 #[inline(always)]
1272 fn encode_is_copy() -> bool {
1273 false
1274 }
1275
1276 #[inline(always)]
1277 fn decode_is_copy() -> bool {
1278 false
1279 }
1280 }
1281
1282 impl fidl::encoding::ValueTypeMarker for EapolTxResult {
1283 type Borrowed<'a> = Self;
1284 #[inline(always)]
1285 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286 *value
1287 }
1288 }
1289
1290 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EapolTxResult {
1291 #[inline]
1292 unsafe fn encode(
1293 self,
1294 encoder: &mut fidl::encoding::Encoder<'_, D>,
1295 offset: usize,
1296 _depth: fidl::encoding::Depth,
1297 ) -> fidl::Result<()> {
1298 encoder.debug_check_bounds::<Self>(offset);
1299 encoder.write_num(self.into_primitive(), offset);
1300 Ok(())
1301 }
1302 }
1303
1304 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolTxResult {
1305 #[inline(always)]
1306 fn new_empty() -> Self {
1307 Self::unknown()
1308 }
1309
1310 #[inline]
1311 unsafe fn decode(
1312 &mut self,
1313 decoder: &mut fidl::encoding::Decoder<'_, D>,
1314 offset: usize,
1315 _depth: fidl::encoding::Depth,
1316 ) -> fidl::Result<()> {
1317 decoder.debug_check_bounds::<Self>(offset);
1318 let prim = decoder.read_num::<u8>(offset);
1319
1320 *self = Self::from_primitive_allow_unknown(prim);
1321 Ok(())
1322 }
1323 }
1324 unsafe impl fidl::encoding::TypeMarker for StartResult {
1325 type Owned = Self;
1326
1327 #[inline(always)]
1328 fn inline_align(_context: fidl::encoding::Context) -> usize {
1329 std::mem::align_of::<u8>()
1330 }
1331
1332 #[inline(always)]
1333 fn inline_size(_context: fidl::encoding::Context) -> usize {
1334 std::mem::size_of::<u8>()
1335 }
1336
1337 #[inline(always)]
1338 fn encode_is_copy() -> bool {
1339 false
1340 }
1341
1342 #[inline(always)]
1343 fn decode_is_copy() -> bool {
1344 false
1345 }
1346 }
1347
1348 impl fidl::encoding::ValueTypeMarker for StartResult {
1349 type Borrowed<'a> = Self;
1350 #[inline(always)]
1351 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1352 *value
1353 }
1354 }
1355
1356 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartResult {
1357 #[inline]
1358 unsafe fn encode(
1359 self,
1360 encoder: &mut fidl::encoding::Encoder<'_, D>,
1361 offset: usize,
1362 _depth: fidl::encoding::Depth,
1363 ) -> fidl::Result<()> {
1364 encoder.debug_check_bounds::<Self>(offset);
1365 encoder.write_num(self.into_primitive(), offset);
1366 Ok(())
1367 }
1368 }
1369
1370 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartResult {
1371 #[inline(always)]
1372 fn new_empty() -> Self {
1373 Self::unknown()
1374 }
1375
1376 #[inline]
1377 unsafe fn decode(
1378 &mut self,
1379 decoder: &mut fidl::encoding::Decoder<'_, D>,
1380 offset: usize,
1381 _depth: fidl::encoding::Depth,
1382 ) -> fidl::Result<()> {
1383 decoder.debug_check_bounds::<Self>(offset);
1384 let prim = decoder.read_num::<u8>(offset);
1385
1386 *self = Self::from_primitive_allow_unknown(prim);
1387 Ok(())
1388 }
1389 }
1390 unsafe impl fidl::encoding::TypeMarker for StopResult {
1391 type Owned = Self;
1392
1393 #[inline(always)]
1394 fn inline_align(_context: fidl::encoding::Context) -> usize {
1395 std::mem::align_of::<u8>()
1396 }
1397
1398 #[inline(always)]
1399 fn inline_size(_context: fidl::encoding::Context) -> usize {
1400 std::mem::size_of::<u8>()
1401 }
1402
1403 #[inline(always)]
1404 fn encode_is_copy() -> bool {
1405 false
1406 }
1407
1408 #[inline(always)]
1409 fn decode_is_copy() -> bool {
1410 false
1411 }
1412 }
1413
1414 impl fidl::encoding::ValueTypeMarker for StopResult {
1415 type Borrowed<'a> = Self;
1416 #[inline(always)]
1417 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1418 *value
1419 }
1420 }
1421
1422 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopResult {
1423 #[inline]
1424 unsafe fn encode(
1425 self,
1426 encoder: &mut fidl::encoding::Encoder<'_, D>,
1427 offset: usize,
1428 _depth: fidl::encoding::Depth,
1429 ) -> fidl::Result<()> {
1430 encoder.debug_check_bounds::<Self>(offset);
1431 encoder.write_num(self.into_primitive(), offset);
1432 Ok(())
1433 }
1434 }
1435
1436 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
1437 #[inline(always)]
1438 fn new_empty() -> Self {
1439 Self::unknown()
1440 }
1441
1442 #[inline]
1443 unsafe fn decode(
1444 &mut self,
1445 decoder: &mut fidl::encoding::Decoder<'_, D>,
1446 offset: usize,
1447 _depth: fidl::encoding::Depth,
1448 ) -> fidl::Result<()> {
1449 decoder.debug_check_bounds::<Self>(offset);
1450 let prim = decoder.read_num::<u8>(offset);
1451
1452 *self = Self::from_primitive_allow_unknown(prim);
1453 Ok(())
1454 }
1455 }
1456 unsafe impl fidl::encoding::TypeMarker for WlanAssocResult {
1457 type Owned = Self;
1458
1459 #[inline(always)]
1460 fn inline_align(_context: fidl::encoding::Context) -> usize {
1461 std::mem::align_of::<u8>()
1462 }
1463
1464 #[inline(always)]
1465 fn inline_size(_context: fidl::encoding::Context) -> usize {
1466 std::mem::size_of::<u8>()
1467 }
1468
1469 #[inline(always)]
1470 fn encode_is_copy() -> bool {
1471 false
1472 }
1473
1474 #[inline(always)]
1475 fn decode_is_copy() -> bool {
1476 false
1477 }
1478 }
1479
1480 impl fidl::encoding::ValueTypeMarker for WlanAssocResult {
1481 type Borrowed<'a> = Self;
1482 #[inline(always)]
1483 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1484 *value
1485 }
1486 }
1487
1488 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1489 for WlanAssocResult
1490 {
1491 #[inline]
1492 unsafe fn encode(
1493 self,
1494 encoder: &mut fidl::encoding::Encoder<'_, D>,
1495 offset: usize,
1496 _depth: fidl::encoding::Depth,
1497 ) -> fidl::Result<()> {
1498 encoder.debug_check_bounds::<Self>(offset);
1499 encoder.write_num(self.into_primitive(), offset);
1500 Ok(())
1501 }
1502 }
1503
1504 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAssocResult {
1505 #[inline(always)]
1506 fn new_empty() -> Self {
1507 Self::unknown()
1508 }
1509
1510 #[inline]
1511 unsafe fn decode(
1512 &mut self,
1513 decoder: &mut fidl::encoding::Decoder<'_, D>,
1514 offset: usize,
1515 _depth: fidl::encoding::Depth,
1516 ) -> fidl::Result<()> {
1517 decoder.debug_check_bounds::<Self>(offset);
1518 let prim = decoder.read_num::<u8>(offset);
1519
1520 *self = Self::from_primitive_allow_unknown(prim);
1521 Ok(())
1522 }
1523 }
1524 unsafe impl fidl::encoding::TypeMarker for WlanAuthResult {
1525 type Owned = Self;
1526
1527 #[inline(always)]
1528 fn inline_align(_context: fidl::encoding::Context) -> usize {
1529 std::mem::align_of::<u8>()
1530 }
1531
1532 #[inline(always)]
1533 fn inline_size(_context: fidl::encoding::Context) -> usize {
1534 std::mem::size_of::<u8>()
1535 }
1536
1537 #[inline(always)]
1538 fn encode_is_copy() -> bool {
1539 false
1540 }
1541
1542 #[inline(always)]
1543 fn decode_is_copy() -> bool {
1544 false
1545 }
1546 }
1547
1548 impl fidl::encoding::ValueTypeMarker for WlanAuthResult {
1549 type Borrowed<'a> = Self;
1550 #[inline(always)]
1551 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1552 *value
1553 }
1554 }
1555
1556 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthResult {
1557 #[inline]
1558 unsafe fn encode(
1559 self,
1560 encoder: &mut fidl::encoding::Encoder<'_, D>,
1561 offset: usize,
1562 _depth: fidl::encoding::Depth,
1563 ) -> fidl::Result<()> {
1564 encoder.debug_check_bounds::<Self>(offset);
1565 encoder.write_num(self.into_primitive(), offset);
1566 Ok(())
1567 }
1568 }
1569
1570 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthResult {
1571 #[inline(always)]
1572 fn new_empty() -> Self {
1573 Self::unknown()
1574 }
1575
1576 #[inline]
1577 unsafe fn decode(
1578 &mut self,
1579 decoder: &mut fidl::encoding::Decoder<'_, D>,
1580 offset: usize,
1581 _depth: fidl::encoding::Depth,
1582 ) -> fidl::Result<()> {
1583 decoder.debug_check_bounds::<Self>(offset);
1584 let prim = decoder.read_num::<u8>(offset);
1585
1586 *self = Self::from_primitive_allow_unknown(prim);
1587 Ok(())
1588 }
1589 }
1590 unsafe impl fidl::encoding::TypeMarker for WlanAuthType {
1591 type Owned = Self;
1592
1593 #[inline(always)]
1594 fn inline_align(_context: fidl::encoding::Context) -> usize {
1595 std::mem::align_of::<u8>()
1596 }
1597
1598 #[inline(always)]
1599 fn inline_size(_context: fidl::encoding::Context) -> usize {
1600 std::mem::size_of::<u8>()
1601 }
1602
1603 #[inline(always)]
1604 fn encode_is_copy() -> bool {
1605 false
1606 }
1607
1608 #[inline(always)]
1609 fn decode_is_copy() -> bool {
1610 false
1611 }
1612 }
1613
1614 impl fidl::encoding::ValueTypeMarker for WlanAuthType {
1615 type Borrowed<'a> = Self;
1616 #[inline(always)]
1617 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1618 *value
1619 }
1620 }
1621
1622 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthType {
1623 #[inline]
1624 unsafe fn encode(
1625 self,
1626 encoder: &mut fidl::encoding::Encoder<'_, D>,
1627 offset: usize,
1628 _depth: fidl::encoding::Depth,
1629 ) -> fidl::Result<()> {
1630 encoder.debug_check_bounds::<Self>(offset);
1631 encoder.write_num(self.into_primitive(), offset);
1632 Ok(())
1633 }
1634 }
1635
1636 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthType {
1637 #[inline(always)]
1638 fn new_empty() -> Self {
1639 Self::unknown()
1640 }
1641
1642 #[inline]
1643 unsafe fn decode(
1644 &mut self,
1645 decoder: &mut fidl::encoding::Decoder<'_, D>,
1646 offset: usize,
1647 _depth: fidl::encoding::Depth,
1648 ) -> fidl::Result<()> {
1649 decoder.debug_check_bounds::<Self>(offset);
1650 let prim = decoder.read_num::<u8>(offset);
1651
1652 *self = Self::from_primitive_allow_unknown(prim);
1653 Ok(())
1654 }
1655 }
1656 unsafe impl fidl::encoding::TypeMarker for WlanScanResult {
1657 type Owned = Self;
1658
1659 #[inline(always)]
1660 fn inline_align(_context: fidl::encoding::Context) -> usize {
1661 std::mem::align_of::<u8>()
1662 }
1663
1664 #[inline(always)]
1665 fn inline_size(_context: fidl::encoding::Context) -> usize {
1666 std::mem::size_of::<u8>()
1667 }
1668
1669 #[inline(always)]
1670 fn encode_is_copy() -> bool {
1671 false
1672 }
1673
1674 #[inline(always)]
1675 fn decode_is_copy() -> bool {
1676 false
1677 }
1678 }
1679
1680 impl fidl::encoding::ValueTypeMarker for WlanScanResult {
1681 type Borrowed<'a> = Self;
1682 #[inline(always)]
1683 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1684 *value
1685 }
1686 }
1687
1688 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanResult {
1689 #[inline]
1690 unsafe fn encode(
1691 self,
1692 encoder: &mut fidl::encoding::Encoder<'_, D>,
1693 offset: usize,
1694 _depth: fidl::encoding::Depth,
1695 ) -> fidl::Result<()> {
1696 encoder.debug_check_bounds::<Self>(offset);
1697 encoder.write_num(self.into_primitive(), offset);
1698 Ok(())
1699 }
1700 }
1701
1702 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanResult {
1703 #[inline(always)]
1704 fn new_empty() -> Self {
1705 Self::unknown()
1706 }
1707
1708 #[inline]
1709 unsafe fn decode(
1710 &mut self,
1711 decoder: &mut fidl::encoding::Decoder<'_, D>,
1712 offset: usize,
1713 _depth: fidl::encoding::Depth,
1714 ) -> fidl::Result<()> {
1715 decoder.debug_check_bounds::<Self>(offset);
1716 let prim = decoder.read_num::<u8>(offset);
1717
1718 *self = Self::from_primitive_allow_unknown(prim);
1719 Ok(())
1720 }
1721 }
1722 unsafe impl fidl::encoding::TypeMarker for WlanScanType {
1723 type Owned = Self;
1724
1725 #[inline(always)]
1726 fn inline_align(_context: fidl::encoding::Context) -> usize {
1727 std::mem::align_of::<u8>()
1728 }
1729
1730 #[inline(always)]
1731 fn inline_size(_context: fidl::encoding::Context) -> usize {
1732 std::mem::size_of::<u8>()
1733 }
1734
1735 #[inline(always)]
1736 fn encode_is_copy() -> bool {
1737 false
1738 }
1739
1740 #[inline(always)]
1741 fn decode_is_copy() -> bool {
1742 false
1743 }
1744 }
1745
1746 impl fidl::encoding::ValueTypeMarker for WlanScanType {
1747 type Borrowed<'a> = Self;
1748 #[inline(always)]
1749 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1750 *value
1751 }
1752 }
1753
1754 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanType {
1755 #[inline]
1756 unsafe fn encode(
1757 self,
1758 encoder: &mut fidl::encoding::Encoder<'_, D>,
1759 offset: usize,
1760 _depth: fidl::encoding::Depth,
1761 ) -> fidl::Result<()> {
1762 encoder.debug_check_bounds::<Self>(offset);
1763 encoder.write_num(self.into_primitive(), offset);
1764 Ok(())
1765 }
1766 }
1767
1768 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanType {
1769 #[inline(always)]
1770 fn new_empty() -> Self {
1771 Self::unknown()
1772 }
1773
1774 #[inline]
1775 unsafe fn decode(
1776 &mut self,
1777 decoder: &mut fidl::encoding::Decoder<'_, D>,
1778 offset: usize,
1779 _depth: fidl::encoding::Depth,
1780 ) -> fidl::Result<()> {
1781 decoder.debug_check_bounds::<Self>(offset);
1782 let prim = decoder.read_num::<u8>(offset);
1783
1784 *self = Self::from_primitive_allow_unknown(prim);
1785 Ok(())
1786 }
1787 }
1788
1789 impl fidl::encoding::ValueTypeMarker for WlanFullmacChannelSwitchInfo {
1790 type Borrowed<'a> = &'a Self;
1791 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1792 value
1793 }
1794 }
1795
1796 unsafe impl fidl::encoding::TypeMarker for WlanFullmacChannelSwitchInfo {
1797 type Owned = Self;
1798
1799 #[inline(always)]
1800 fn inline_align(_context: fidl::encoding::Context) -> usize {
1801 1
1802 }
1803
1804 #[inline(always)]
1805 fn inline_size(_context: fidl::encoding::Context) -> usize {
1806 1
1807 }
1808 #[inline(always)]
1809 fn encode_is_copy() -> bool {
1810 true
1811 }
1812
1813 #[inline(always)]
1814 fn decode_is_copy() -> bool {
1815 true
1816 }
1817 }
1818
1819 unsafe impl<D: fidl::encoding::ResourceDialect>
1820 fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for &WlanFullmacChannelSwitchInfo
1821 {
1822 #[inline]
1823 unsafe fn encode(
1824 self,
1825 encoder: &mut fidl::encoding::Encoder<'_, D>,
1826 offset: usize,
1827 _depth: fidl::encoding::Depth,
1828 ) -> fidl::Result<()> {
1829 encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1830 unsafe {
1831 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1833 (buf_ptr as *mut WlanFullmacChannelSwitchInfo)
1834 .write_unaligned((self as *const WlanFullmacChannelSwitchInfo).read());
1835 }
1838 Ok(())
1839 }
1840 }
1841 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1842 fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for (T0,)
1843 {
1844 #[inline]
1845 unsafe fn encode(
1846 self,
1847 encoder: &mut fidl::encoding::Encoder<'_, D>,
1848 offset: usize,
1849 depth: fidl::encoding::Depth,
1850 ) -> fidl::Result<()> {
1851 encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1852 self.0.encode(encoder, offset + 0, depth)?;
1856 Ok(())
1857 }
1858 }
1859
1860 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1861 for WlanFullmacChannelSwitchInfo
1862 {
1863 #[inline(always)]
1864 fn new_empty() -> Self {
1865 Self { new_channel: fidl::new_empty!(u8, D) }
1866 }
1867
1868 #[inline]
1869 unsafe fn decode(
1870 &mut self,
1871 decoder: &mut fidl::encoding::Decoder<'_, D>,
1872 offset: usize,
1873 _depth: fidl::encoding::Depth,
1874 ) -> fidl::Result<()> {
1875 decoder.debug_check_bounds::<Self>(offset);
1876 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1877 unsafe {
1880 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1881 }
1882 Ok(())
1883 }
1884 }
1885
1886 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1887 type Borrowed<'a> = &'a Self;
1888 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1889 value
1890 }
1891 }
1892
1893 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1894 type Owned = Self;
1895
1896 #[inline(always)]
1897 fn inline_align(_context: fidl::encoding::Context) -> usize {
1898 1
1899 }
1900
1901 #[inline(always)]
1902 fn inline_size(_context: fidl::encoding::Context) -> usize {
1903 1
1904 }
1905 #[inline(always)]
1906 fn encode_is_copy() -> bool {
1907 true
1908 }
1909
1910 #[inline(always)]
1911 fn decode_is_copy() -> bool {
1912 true
1913 }
1914 }
1915
1916 unsafe impl<D: fidl::encoding::ResourceDialect>
1917 fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D>
1918 for &WlanFullmacImplIfcOnChannelSwitchRequest
1919 {
1920 #[inline]
1921 unsafe fn encode(
1922 self,
1923 encoder: &mut fidl::encoding::Encoder<'_, D>,
1924 offset: usize,
1925 _depth: fidl::encoding::Depth,
1926 ) -> fidl::Result<()> {
1927 encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1928 unsafe {
1929 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1931 (buf_ptr as *mut WlanFullmacImplIfcOnChannelSwitchRequest).write_unaligned(
1932 (self as *const WlanFullmacImplIfcOnChannelSwitchRequest).read(),
1933 );
1934 }
1937 Ok(())
1938 }
1939 }
1940 unsafe impl<
1941 D: fidl::encoding::ResourceDialect,
1942 T0: fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D>,
1943 > fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D> for (T0,)
1944 {
1945 #[inline]
1946 unsafe fn encode(
1947 self,
1948 encoder: &mut fidl::encoding::Encoder<'_, D>,
1949 offset: usize,
1950 depth: fidl::encoding::Depth,
1951 ) -> fidl::Result<()> {
1952 encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1953 self.0.encode(encoder, offset + 0, depth)?;
1957 Ok(())
1958 }
1959 }
1960
1961 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1962 for WlanFullmacImplIfcOnChannelSwitchRequest
1963 {
1964 #[inline(always)]
1965 fn new_empty() -> Self {
1966 Self { ind: fidl::new_empty!(WlanFullmacChannelSwitchInfo, D) }
1967 }
1968
1969 #[inline]
1970 unsafe fn decode(
1971 &mut self,
1972 decoder: &mut fidl::encoding::Decoder<'_, D>,
1973 offset: usize,
1974 _depth: fidl::encoding::Depth,
1975 ) -> fidl::Result<()> {
1976 decoder.debug_check_bounds::<Self>(offset);
1977 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1978 unsafe {
1981 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1982 }
1983 Ok(())
1984 }
1985 }
1986
1987 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1988 type Borrowed<'a> = &'a Self;
1989 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1990 value
1991 }
1992 }
1993
1994 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1995 type Owned = Self;
1996
1997 #[inline(always)]
1998 fn inline_align(_context: fidl::encoding::Context) -> usize {
1999 4
2000 }
2001
2002 #[inline(always)]
2003 fn inline_size(_context: fidl::encoding::Context) -> usize {
2004 40
2005 }
2006 }
2007
2008 unsafe impl<D: fidl::encoding::ResourceDialect>
2009 fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D>
2010 for &WlanFullmacImplIfcOnWmmStatusRespRequest
2011 {
2012 #[inline]
2013 unsafe fn encode(
2014 self,
2015 encoder: &mut fidl::encoding::Encoder<'_, D>,
2016 offset: usize,
2017 _depth: fidl::encoding::Depth,
2018 ) -> fidl::Result<()> {
2019 encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
2020 fidl::encoding::Encode::<WlanFullmacImplIfcOnWmmStatusRespRequest, D>::encode(
2022 (
2023 <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2024 <fidl_fuchsia_wlan_common__common::WlanWmmParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_params),
2025 ),
2026 encoder, offset, _depth
2027 )
2028 }
2029 }
2030 unsafe impl<
2031 D: fidl::encoding::ResourceDialect,
2032 T0: fidl::encoding::Encode<i32, D>,
2033 T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanWmmParameters, D>,
2034 > fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D> for (T0, T1)
2035 {
2036 #[inline]
2037 unsafe fn encode(
2038 self,
2039 encoder: &mut fidl::encoding::Encoder<'_, D>,
2040 offset: usize,
2041 depth: fidl::encoding::Depth,
2042 ) -> fidl::Result<()> {
2043 encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
2044 unsafe {
2047 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
2048 (ptr as *mut u32).write_unaligned(0);
2049 }
2050 self.0.encode(encoder, offset + 0, depth)?;
2052 self.1.encode(encoder, offset + 4, depth)?;
2053 Ok(())
2054 }
2055 }
2056
2057 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2058 for WlanFullmacImplIfcOnWmmStatusRespRequest
2059 {
2060 #[inline(always)]
2061 fn new_empty() -> Self {
2062 Self {
2063 status: fidl::new_empty!(i32, D),
2064 wmm_params: fidl::new_empty!(
2065 fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2066 D
2067 ),
2068 }
2069 }
2070
2071 #[inline]
2072 unsafe fn decode(
2073 &mut self,
2074 decoder: &mut fidl::encoding::Decoder<'_, D>,
2075 offset: usize,
2076 _depth: fidl::encoding::Depth,
2077 ) -> fidl::Result<()> {
2078 decoder.debug_check_bounds::<Self>(offset);
2079 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
2081 let padval = unsafe { (ptr as *const u32).read_unaligned() };
2082 let mask = 0xffff0000u32;
2083 let maskedval = padval & mask;
2084 if maskedval != 0 {
2085 return Err(fidl::Error::NonZeroPadding {
2086 padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
2087 });
2088 }
2089 fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
2090 fidl::decode!(
2091 fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2092 D,
2093 &mut self.wmm_params,
2094 decoder,
2095 offset + 4,
2096 _depth
2097 )?;
2098 Ok(())
2099 }
2100 }
2101
2102 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2103 type Borrowed<'a> = &'a Self;
2104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2105 value
2106 }
2107 }
2108
2109 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2110 type Owned = Self;
2111
2112 #[inline(always)]
2113 fn inline_align(_context: fidl::encoding::Context) -> usize {
2114 8
2115 }
2116
2117 #[inline(always)]
2118 fn inline_size(_context: fidl::encoding::Context) -> usize {
2119 16
2120 }
2121 }
2122
2123 unsafe impl<D: fidl::encoding::ResourceDialect>
2124 fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D>
2125 for &WlanFullmacImplIfcSaeFrameRxRequest
2126 {
2127 #[inline]
2128 unsafe fn encode(
2129 self,
2130 encoder: &mut fidl::encoding::Encoder<'_, D>,
2131 offset: usize,
2132 _depth: fidl::encoding::Depth,
2133 ) -> fidl::Result<()> {
2134 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2135 fidl::encoding::Encode::<WlanFullmacImplIfcSaeFrameRxRequest, D>::encode(
2137 (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2138 encoder,
2139 offset,
2140 _depth,
2141 )
2142 }
2143 }
2144 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2145 fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D> for (T0,)
2146 {
2147 #[inline]
2148 unsafe fn encode(
2149 self,
2150 encoder: &mut fidl::encoding::Encoder<'_, D>,
2151 offset: usize,
2152 depth: fidl::encoding::Depth,
2153 ) -> fidl::Result<()> {
2154 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2155 self.0.encode(encoder, offset + 0, depth)?;
2159 Ok(())
2160 }
2161 }
2162
2163 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2164 for WlanFullmacImplIfcSaeFrameRxRequest
2165 {
2166 #[inline(always)]
2167 fn new_empty() -> Self {
2168 Self { frame: fidl::new_empty!(SaeFrame, D) }
2169 }
2170
2171 #[inline]
2172 unsafe fn decode(
2173 &mut self,
2174 decoder: &mut fidl::encoding::Decoder<'_, D>,
2175 offset: usize,
2176 _depth: fidl::encoding::Depth,
2177 ) -> fidl::Result<()> {
2178 decoder.debug_check_bounds::<Self>(offset);
2179 fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2181 Ok(())
2182 }
2183 }
2184
2185 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSignalReportRequest {
2186 type Borrowed<'a> = &'a Self;
2187 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2188 value
2189 }
2190 }
2191
2192 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSignalReportRequest {
2193 type Owned = Self;
2194
2195 #[inline(always)]
2196 fn inline_align(_context: fidl::encoding::Context) -> usize {
2197 1
2198 }
2199
2200 #[inline(always)]
2201 fn inline_size(_context: fidl::encoding::Context) -> usize {
2202 2
2203 }
2204 #[inline(always)]
2205 fn encode_is_copy() -> bool {
2206 true
2207 }
2208
2209 #[inline(always)]
2210 fn decode_is_copy() -> bool {
2211 true
2212 }
2213 }
2214
2215 unsafe impl<D: fidl::encoding::ResourceDialect>
2216 fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D>
2217 for &WlanFullmacImplIfcSignalReportRequest
2218 {
2219 #[inline]
2220 unsafe fn encode(
2221 self,
2222 encoder: &mut fidl::encoding::Encoder<'_, D>,
2223 offset: usize,
2224 _depth: fidl::encoding::Depth,
2225 ) -> fidl::Result<()> {
2226 encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2227 unsafe {
2228 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2230 (buf_ptr as *mut WlanFullmacImplIfcSignalReportRequest)
2231 .write_unaligned((self as *const WlanFullmacImplIfcSignalReportRequest).read());
2232 }
2235 Ok(())
2236 }
2237 }
2238 unsafe impl<
2239 D: fidl::encoding::ResourceDialect,
2240 T0: fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>,
2241 > fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D> for (T0,)
2242 {
2243 #[inline]
2244 unsafe fn encode(
2245 self,
2246 encoder: &mut fidl::encoding::Encoder<'_, D>,
2247 offset: usize,
2248 depth: fidl::encoding::Depth,
2249 ) -> fidl::Result<()> {
2250 encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2251 self.0.encode(encoder, offset + 0, depth)?;
2255 Ok(())
2256 }
2257 }
2258
2259 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2260 for WlanFullmacImplIfcSignalReportRequest
2261 {
2262 #[inline(always)]
2263 fn new_empty() -> Self {
2264 Self { ind: fidl::new_empty!(WlanFullmacSignalReportIndication, D) }
2265 }
2266
2267 #[inline]
2268 unsafe fn decode(
2269 &mut self,
2270 decoder: &mut fidl::encoding::Decoder<'_, D>,
2271 offset: usize,
2272 _depth: fidl::encoding::Depth,
2273 ) -> fidl::Result<()> {
2274 decoder.debug_check_bounds::<Self>(offset);
2275 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2276 unsafe {
2279 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2280 }
2281 Ok(())
2282 }
2283 }
2284
2285 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeFrameTxRequest {
2286 type Borrowed<'a> = &'a Self;
2287 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2288 value
2289 }
2290 }
2291
2292 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeFrameTxRequest {
2293 type Owned = Self;
2294
2295 #[inline(always)]
2296 fn inline_align(_context: fidl::encoding::Context) -> usize {
2297 8
2298 }
2299
2300 #[inline(always)]
2301 fn inline_size(_context: fidl::encoding::Context) -> usize {
2302 16
2303 }
2304 }
2305
2306 unsafe impl<D: fidl::encoding::ResourceDialect>
2307 fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D>
2308 for &WlanFullmacImplSaeFrameTxRequest
2309 {
2310 #[inline]
2311 unsafe fn encode(
2312 self,
2313 encoder: &mut fidl::encoding::Encoder<'_, D>,
2314 offset: usize,
2315 _depth: fidl::encoding::Depth,
2316 ) -> fidl::Result<()> {
2317 encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2318 fidl::encoding::Encode::<WlanFullmacImplSaeFrameTxRequest, D>::encode(
2320 (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2321 encoder,
2322 offset,
2323 _depth,
2324 )
2325 }
2326 }
2327 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2328 fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D> for (T0,)
2329 {
2330 #[inline]
2331 unsafe fn encode(
2332 self,
2333 encoder: &mut fidl::encoding::Encoder<'_, D>,
2334 offset: usize,
2335 depth: fidl::encoding::Depth,
2336 ) -> fidl::Result<()> {
2337 encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2338 self.0.encode(encoder, offset + 0, depth)?;
2342 Ok(())
2343 }
2344 }
2345
2346 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2347 for WlanFullmacImplSaeFrameTxRequest
2348 {
2349 #[inline(always)]
2350 fn new_empty() -> Self {
2351 Self { frame: fidl::new_empty!(SaeFrame, D) }
2352 }
2353
2354 #[inline]
2355 unsafe fn decode(
2356 &mut self,
2357 decoder: &mut fidl::encoding::Decoder<'_, D>,
2358 offset: usize,
2359 _depth: fidl::encoding::Depth,
2360 ) -> fidl::Result<()> {
2361 decoder.debug_check_bounds::<Self>(offset);
2362 fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2364 Ok(())
2365 }
2366 }
2367
2368 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysResponse {
2369 type Borrowed<'a> = &'a Self;
2370 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2371 value
2372 }
2373 }
2374
2375 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysResponse {
2376 type Owned = Self;
2377
2378 #[inline(always)]
2379 fn inline_align(_context: fidl::encoding::Context) -> usize {
2380 8
2381 }
2382
2383 #[inline(always)]
2384 fn inline_size(_context: fidl::encoding::Context) -> usize {
2385 16
2386 }
2387 }
2388
2389 unsafe impl<D: fidl::encoding::ResourceDialect>
2390 fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D>
2391 for &WlanFullmacImplSetKeysResponse
2392 {
2393 #[inline]
2394 unsafe fn encode(
2395 self,
2396 encoder: &mut fidl::encoding::Encoder<'_, D>,
2397 offset: usize,
2398 _depth: fidl::encoding::Depth,
2399 ) -> fidl::Result<()> {
2400 encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2401 fidl::encoding::Encode::<WlanFullmacImplSetKeysResponse, D>::encode(
2403 (<WlanFullmacSetKeysResp as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2404 encoder,
2405 offset,
2406 _depth,
2407 )
2408 }
2409 }
2410 unsafe impl<
2411 D: fidl::encoding::ResourceDialect,
2412 T0: fidl::encoding::Encode<WlanFullmacSetKeysResp, D>,
2413 > fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D> for (T0,)
2414 {
2415 #[inline]
2416 unsafe fn encode(
2417 self,
2418 encoder: &mut fidl::encoding::Encoder<'_, D>,
2419 offset: usize,
2420 depth: fidl::encoding::Depth,
2421 ) -> fidl::Result<()> {
2422 encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2423 self.0.encode(encoder, offset + 0, depth)?;
2427 Ok(())
2428 }
2429 }
2430
2431 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2432 for WlanFullmacImplSetKeysResponse
2433 {
2434 #[inline(always)]
2435 fn new_empty() -> Self {
2436 Self { resp: fidl::new_empty!(WlanFullmacSetKeysResp, D) }
2437 }
2438
2439 #[inline]
2440 unsafe fn decode(
2441 &mut self,
2442 decoder: &mut fidl::encoding::Decoder<'_, D>,
2443 offset: usize,
2444 _depth: fidl::encoding::Depth,
2445 ) -> fidl::Result<()> {
2446 decoder.debug_check_bounds::<Self>(offset);
2447 fidl::decode!(WlanFullmacSetKeysResp, D, &mut self.resp, decoder, offset + 0, _depth)?;
2449 Ok(())
2450 }
2451 }
2452
2453 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2454 type Borrowed<'a> = &'a Self;
2455 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2456 value
2457 }
2458 }
2459
2460 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2461 type Owned = Self;
2462
2463 #[inline(always)]
2464 fn inline_align(_context: fidl::encoding::Context) -> usize {
2465 8
2466 }
2467
2468 #[inline(always)]
2469 fn inline_size(_context: fidl::encoding::Context) -> usize {
2470 16
2471 }
2472 }
2473
2474 unsafe impl<D: fidl::encoding::ResourceDialect>
2475 fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D>
2476 for &WlanFullmacImplGetIfaceHistogramStatsResponse
2477 {
2478 #[inline]
2479 unsafe fn encode(
2480 self,
2481 encoder: &mut fidl::encoding::Encoder<'_, D>,
2482 offset: usize,
2483 _depth: fidl::encoding::Depth,
2484 ) -> fidl::Result<()> {
2485 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2486 fidl::encoding::Encode::<WlanFullmacImplGetIfaceHistogramStatsResponse, D>::encode(
2488 (
2489 <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2490 ),
2491 encoder, offset, _depth
2492 )
2493 }
2494 }
2495 unsafe impl<
2496 D: fidl::encoding::ResourceDialect,
2497 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>,
2498 > fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D> for (T0,)
2499 {
2500 #[inline]
2501 unsafe fn encode(
2502 self,
2503 encoder: &mut fidl::encoding::Encoder<'_, D>,
2504 offset: usize,
2505 depth: fidl::encoding::Depth,
2506 ) -> fidl::Result<()> {
2507 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2508 self.0.encode(encoder, offset + 0, depth)?;
2512 Ok(())
2513 }
2514 }
2515
2516 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2517 for WlanFullmacImplGetIfaceHistogramStatsResponse
2518 {
2519 #[inline(always)]
2520 fn new_empty() -> Self {
2521 Self {
2522 stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D),
2523 }
2524 }
2525
2526 #[inline]
2527 unsafe fn decode(
2528 &mut self,
2529 decoder: &mut fidl::encoding::Decoder<'_, D>,
2530 offset: usize,
2531 _depth: fidl::encoding::Depth,
2532 ) -> fidl::Result<()> {
2533 decoder.debug_check_bounds::<Self>(offset);
2534 fidl::decode!(
2536 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
2537 D,
2538 &mut self.stats,
2539 decoder,
2540 offset + 0,
2541 _depth
2542 )?;
2543 Ok(())
2544 }
2545 }
2546
2547 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2548 type Borrowed<'a> = &'a Self;
2549 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2550 value
2551 }
2552 }
2553
2554 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2555 type Owned = Self;
2556
2557 #[inline(always)]
2558 fn inline_align(_context: fidl::encoding::Context) -> usize {
2559 8
2560 }
2561
2562 #[inline(always)]
2563 fn inline_size(_context: fidl::encoding::Context) -> usize {
2564 16
2565 }
2566 }
2567
2568 unsafe impl<D: fidl::encoding::ResourceDialect>
2569 fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D>
2570 for &WlanFullmacImplGetIfaceStatsResponse
2571 {
2572 #[inline]
2573 unsafe fn encode(
2574 self,
2575 encoder: &mut fidl::encoding::Encoder<'_, D>,
2576 offset: usize,
2577 _depth: fidl::encoding::Depth,
2578 ) -> fidl::Result<()> {
2579 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2580 fidl::encoding::Encode::<WlanFullmacImplGetIfaceStatsResponse, D>::encode(
2582 (
2583 <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2584 ),
2585 encoder, offset, _depth
2586 )
2587 }
2588 }
2589 unsafe impl<
2590 D: fidl::encoding::ResourceDialect,
2591 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceStats, D>,
2592 > fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D> for (T0,)
2593 {
2594 #[inline]
2595 unsafe fn encode(
2596 self,
2597 encoder: &mut fidl::encoding::Encoder<'_, D>,
2598 offset: usize,
2599 depth: fidl::encoding::Depth,
2600 ) -> fidl::Result<()> {
2601 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2602 self.0.encode(encoder, offset + 0, depth)?;
2606 Ok(())
2607 }
2608 }
2609
2610 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2611 for WlanFullmacImplGetIfaceStatsResponse
2612 {
2613 #[inline(always)]
2614 fn new_empty() -> Self {
2615 Self { stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D) }
2616 }
2617
2618 #[inline]
2619 unsafe fn decode(
2620 &mut self,
2621 decoder: &mut fidl::encoding::Decoder<'_, D>,
2622 offset: usize,
2623 _depth: fidl::encoding::Depth,
2624 ) -> fidl::Result<()> {
2625 decoder.debug_check_bounds::<Self>(offset);
2626 fidl::decode!(
2628 fidl_fuchsia_wlan_stats__common::IfaceStats,
2629 D,
2630 &mut self.stats,
2631 decoder,
2632 offset + 0,
2633 _depth
2634 )?;
2635 Ok(())
2636 }
2637 }
2638
2639 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2640 type Borrowed<'a> = &'a Self;
2641 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2642 value
2643 }
2644 }
2645
2646 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2647 type Owned = Self;
2648
2649 #[inline(always)]
2650 fn inline_align(_context: fidl::encoding::Context) -> usize {
2651 1
2652 }
2653
2654 #[inline(always)]
2655 fn inline_size(_context: fidl::encoding::Context) -> usize {
2656 3
2657 }
2658 }
2659
2660 unsafe impl<D: fidl::encoding::ResourceDialect>
2661 fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D>
2662 for &WlanFullmacImplQuerySecuritySupportResponse
2663 {
2664 #[inline]
2665 unsafe fn encode(
2666 self,
2667 encoder: &mut fidl::encoding::Encoder<'_, D>,
2668 offset: usize,
2669 _depth: fidl::encoding::Depth,
2670 ) -> fidl::Result<()> {
2671 encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2672 fidl::encoding::Encode::<WlanFullmacImplQuerySecuritySupportResponse, D>::encode(
2674 (
2675 <fidl_fuchsia_wlan_common__common::SecuritySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2676 ),
2677 encoder, offset, _depth
2678 )
2679 }
2680 }
2681 unsafe impl<
2682 D: fidl::encoding::ResourceDialect,
2683 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SecuritySupport, D>,
2684 > fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D> for (T0,)
2685 {
2686 #[inline]
2687 unsafe fn encode(
2688 self,
2689 encoder: &mut fidl::encoding::Encoder<'_, D>,
2690 offset: usize,
2691 depth: fidl::encoding::Depth,
2692 ) -> fidl::Result<()> {
2693 encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2694 self.0.encode(encoder, offset + 0, depth)?;
2698 Ok(())
2699 }
2700 }
2701
2702 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2703 for WlanFullmacImplQuerySecuritySupportResponse
2704 {
2705 #[inline(always)]
2706 fn new_empty() -> Self {
2707 Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common__common::SecuritySupport, D) }
2708 }
2709
2710 #[inline]
2711 unsafe fn decode(
2712 &mut self,
2713 decoder: &mut fidl::encoding::Decoder<'_, D>,
2714 offset: usize,
2715 _depth: fidl::encoding::Depth,
2716 ) -> fidl::Result<()> {
2717 decoder.debug_check_bounds::<Self>(offset);
2718 fidl::decode!(
2720 fidl_fuchsia_wlan_common__common::SecuritySupport,
2721 D,
2722 &mut self.resp,
2723 decoder,
2724 offset + 0,
2725 _depth
2726 )?;
2727 Ok(())
2728 }
2729 }
2730
2731 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2732 type Borrowed<'a> = &'a Self;
2733 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2734 value
2735 }
2736 }
2737
2738 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2739 type Owned = Self;
2740
2741 #[inline(always)]
2742 fn inline_align(_context: fidl::encoding::Context) -> usize {
2743 1
2744 }
2745
2746 #[inline(always)]
2747 fn inline_size(_context: fidl::encoding::Context) -> usize {
2748 1
2749 }
2750 }
2751
2752 unsafe impl<D: fidl::encoding::ResourceDialect>
2753 fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2754 for &WlanFullmacImplQuerySpectrumManagementSupportResponse
2755 {
2756 #[inline]
2757 unsafe fn encode(
2758 self,
2759 encoder: &mut fidl::encoding::Encoder<'_, D>,
2760 offset: usize,
2761 _depth: fidl::encoding::Depth,
2762 ) -> fidl::Result<()> {
2763 encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2764 offset,
2765 );
2766 fidl::encoding::Encode::<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>::encode(
2768 (
2769 <fidl_fuchsia_wlan_common__common::SpectrumManagementSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2770 ),
2771 encoder, offset, _depth
2772 )
2773 }
2774 }
2775 unsafe impl<
2776 D: fidl::encoding::ResourceDialect,
2777 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SpectrumManagementSupport, D>,
2778 > fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2779 for (T0,)
2780 {
2781 #[inline]
2782 unsafe fn encode(
2783 self,
2784 encoder: &mut fidl::encoding::Encoder<'_, D>,
2785 offset: usize,
2786 depth: fidl::encoding::Depth,
2787 ) -> fidl::Result<()> {
2788 encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2789 offset,
2790 );
2791 self.0.encode(encoder, offset + 0, depth)?;
2795 Ok(())
2796 }
2797 }
2798
2799 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2800 for WlanFullmacImplQuerySpectrumManagementSupportResponse
2801 {
2802 #[inline(always)]
2803 fn new_empty() -> Self {
2804 Self {
2805 resp: fidl::new_empty!(
2806 fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2807 D
2808 ),
2809 }
2810 }
2811
2812 #[inline]
2813 unsafe fn decode(
2814 &mut self,
2815 decoder: &mut fidl::encoding::Decoder<'_, D>,
2816 offset: usize,
2817 _depth: fidl::encoding::Depth,
2818 ) -> fidl::Result<()> {
2819 decoder.debug_check_bounds::<Self>(offset);
2820 fidl::decode!(
2822 fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2823 D,
2824 &mut self.resp,
2825 decoder,
2826 offset + 0,
2827 _depth
2828 )?;
2829 Ok(())
2830 }
2831 }
2832
2833 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2834 type Borrowed<'a> = &'a Self;
2835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2836 value
2837 }
2838 }
2839
2840 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2841 type Owned = Self;
2842
2843 #[inline(always)]
2844 fn inline_align(_context: fidl::encoding::Context) -> usize {
2845 8
2846 }
2847
2848 #[inline(always)]
2849 fn inline_size(_context: fidl::encoding::Context) -> usize {
2850 16
2851 }
2852 }
2853
2854 unsafe impl<D: fidl::encoding::ResourceDialect>
2855 fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D>
2856 for &WlanFullmacImplQueryTelemetrySupportResponse
2857 {
2858 #[inline]
2859 unsafe fn encode(
2860 self,
2861 encoder: &mut fidl::encoding::Encoder<'_, D>,
2862 offset: usize,
2863 _depth: fidl::encoding::Depth,
2864 ) -> fidl::Result<()> {
2865 encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2866 fidl::encoding::Encode::<WlanFullmacImplQueryTelemetrySupportResponse, D>::encode(
2868 (
2869 <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2870 ),
2871 encoder, offset, _depth
2872 )
2873 }
2874 }
2875 unsafe impl<
2876 D: fidl::encoding::ResourceDialect,
2877 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
2878 > fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D> for (T0,)
2879 {
2880 #[inline]
2881 unsafe fn encode(
2882 self,
2883 encoder: &mut fidl::encoding::Encoder<'_, D>,
2884 offset: usize,
2885 depth: fidl::encoding::Depth,
2886 ) -> fidl::Result<()> {
2887 encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2888 self.0.encode(encoder, offset + 0, depth)?;
2892 Ok(())
2893 }
2894 }
2895
2896 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2897 for WlanFullmacImplQueryTelemetrySupportResponse
2898 {
2899 #[inline(always)]
2900 fn new_empty() -> Self {
2901 Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, D) }
2902 }
2903
2904 #[inline]
2905 unsafe fn decode(
2906 &mut self,
2907 decoder: &mut fidl::encoding::Decoder<'_, D>,
2908 offset: usize,
2909 _depth: fidl::encoding::Depth,
2910 ) -> fidl::Result<()> {
2911 decoder.debug_check_bounds::<Self>(offset);
2912 fidl::decode!(
2914 fidl_fuchsia_wlan_stats__common::TelemetrySupport,
2915 D,
2916 &mut self.resp,
2917 decoder,
2918 offset + 0,
2919 _depth
2920 )?;
2921 Ok(())
2922 }
2923 }
2924
2925 impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiStats {
2926 type Borrowed<'a> = &'a Self;
2927 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2928 value
2929 }
2930 }
2931
2932 unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiStats {
2933 type Owned = Self;
2934
2935 #[inline(always)]
2936 fn inline_align(_context: fidl::encoding::Context) -> usize {
2937 8
2938 }
2939
2940 #[inline(always)]
2941 fn inline_size(_context: fidl::encoding::Context) -> usize {
2942 16
2943 }
2944 }
2945
2946 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanFullmacRssiStats, D>
2947 for &WlanFullmacRssiStats
2948 {
2949 #[inline]
2950 unsafe fn encode(
2951 self,
2952 encoder: &mut fidl::encoding::Encoder<'_, D>,
2953 offset: usize,
2954 _depth: fidl::encoding::Depth,
2955 ) -> fidl::Result<()> {
2956 encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2957 fidl::encoding::Encode::<WlanFullmacRssiStats, D>::encode(
2959 (
2960 <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.hist),
2961 ),
2962 encoder, offset, _depth
2963 )
2964 }
2965 }
2966 unsafe impl<
2967 D: fidl::encoding::ResourceDialect,
2968 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
2969 > fidl::encoding::Encode<WlanFullmacRssiStats, D> for (T0,)
2970 {
2971 #[inline]
2972 unsafe fn encode(
2973 self,
2974 encoder: &mut fidl::encoding::Encoder<'_, D>,
2975 offset: usize,
2976 depth: fidl::encoding::Depth,
2977 ) -> fidl::Result<()> {
2978 encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2979 self.0.encode(encoder, offset + 0, depth)?;
2983 Ok(())
2984 }
2985 }
2986
2987 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanFullmacRssiStats {
2988 #[inline(always)]
2989 fn new_empty() -> Self {
2990 Self { hist: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
2991 }
2992
2993 #[inline]
2994 unsafe fn decode(
2995 &mut self,
2996 decoder: &mut fidl::encoding::Decoder<'_, D>,
2997 offset: usize,
2998 _depth: fidl::encoding::Depth,
2999 ) -> fidl::Result<()> {
3000 decoder.debug_check_bounds::<Self>(offset);
3001 fidl::decode!(
3003 fidl::encoding::UnboundedVector<u64>,
3004 D,
3005 &mut self.hist,
3006 decoder,
3007 offset + 0,
3008 _depth
3009 )?;
3010 Ok(())
3011 }
3012 }
3013
3014 impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysResp {
3015 type Borrowed<'a> = &'a Self;
3016 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3017 value
3018 }
3019 }
3020
3021 unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysResp {
3022 type Owned = Self;
3023
3024 #[inline(always)]
3025 fn inline_align(_context: fidl::encoding::Context) -> usize {
3026 8
3027 }
3028
3029 #[inline(always)]
3030 fn inline_size(_context: fidl::encoding::Context) -> usize {
3031 16
3032 }
3033 }
3034
3035 unsafe impl<D: fidl::encoding::ResourceDialect>
3036 fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for &WlanFullmacSetKeysResp
3037 {
3038 #[inline]
3039 unsafe fn encode(
3040 self,
3041 encoder: &mut fidl::encoding::Encoder<'_, D>,
3042 offset: usize,
3043 _depth: fidl::encoding::Depth,
3044 ) -> fidl::Result<()> {
3045 encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3046 fidl::encoding::Encode::<WlanFullmacSetKeysResp, D>::encode(
3048 (<fidl::encoding::Vector<i32, 4> as fidl::encoding::ValueTypeMarker>::borrow(
3049 &self.statuslist,
3050 ),),
3051 encoder,
3052 offset,
3053 _depth,
3054 )
3055 }
3056 }
3057 unsafe impl<
3058 D: fidl::encoding::ResourceDialect,
3059 T0: fidl::encoding::Encode<fidl::encoding::Vector<i32, 4>, D>,
3060 > fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for (T0,)
3061 {
3062 #[inline]
3063 unsafe fn encode(
3064 self,
3065 encoder: &mut fidl::encoding::Encoder<'_, D>,
3066 offset: usize,
3067 depth: fidl::encoding::Depth,
3068 ) -> fidl::Result<()> {
3069 encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3070 self.0.encode(encoder, offset + 0, depth)?;
3074 Ok(())
3075 }
3076 }
3077
3078 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3079 for WlanFullmacSetKeysResp
3080 {
3081 #[inline(always)]
3082 fn new_empty() -> Self {
3083 Self { statuslist: fidl::new_empty!(fidl::encoding::Vector<i32, 4>, D) }
3084 }
3085
3086 #[inline]
3087 unsafe fn decode(
3088 &mut self,
3089 decoder: &mut fidl::encoding::Decoder<'_, D>,
3090 offset: usize,
3091 _depth: fidl::encoding::Depth,
3092 ) -> fidl::Result<()> {
3093 decoder.debug_check_bounds::<Self>(offset);
3094 fidl::decode!(fidl::encoding::Vector<i32, 4>, D, &mut self.statuslist, decoder, offset + 0, _depth)?;
3096 Ok(())
3097 }
3098 }
3099
3100 impl fidl::encoding::ValueTypeMarker for WlanFullmacSignalReportIndication {
3101 type Borrowed<'a> = &'a Self;
3102 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3103 value
3104 }
3105 }
3106
3107 unsafe impl fidl::encoding::TypeMarker for WlanFullmacSignalReportIndication {
3108 type Owned = Self;
3109
3110 #[inline(always)]
3111 fn inline_align(_context: fidl::encoding::Context) -> usize {
3112 1
3113 }
3114
3115 #[inline(always)]
3116 fn inline_size(_context: fidl::encoding::Context) -> usize {
3117 2
3118 }
3119 #[inline(always)]
3120 fn encode_is_copy() -> bool {
3121 true
3122 }
3123
3124 #[inline(always)]
3125 fn decode_is_copy() -> bool {
3126 true
3127 }
3128 }
3129
3130 unsafe impl<D: fidl::encoding::ResourceDialect>
3131 fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>
3132 for &WlanFullmacSignalReportIndication
3133 {
3134 #[inline]
3135 unsafe fn encode(
3136 self,
3137 encoder: &mut fidl::encoding::Encoder<'_, D>,
3138 offset: usize,
3139 _depth: fidl::encoding::Depth,
3140 ) -> fidl::Result<()> {
3141 encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3142 unsafe {
3143 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3145 (buf_ptr as *mut WlanFullmacSignalReportIndication)
3146 .write_unaligned((self as *const WlanFullmacSignalReportIndication).read());
3147 }
3150 Ok(())
3151 }
3152 }
3153 unsafe impl<
3154 D: fidl::encoding::ResourceDialect,
3155 T0: fidl::encoding::Encode<i8, D>,
3156 T1: fidl::encoding::Encode<i8, D>,
3157 > fidl::encoding::Encode<WlanFullmacSignalReportIndication, D> for (T0, T1)
3158 {
3159 #[inline]
3160 unsafe fn encode(
3161 self,
3162 encoder: &mut fidl::encoding::Encoder<'_, D>,
3163 offset: usize,
3164 depth: fidl::encoding::Depth,
3165 ) -> fidl::Result<()> {
3166 encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3167 self.0.encode(encoder, offset + 0, depth)?;
3171 self.1.encode(encoder, offset + 1, depth)?;
3172 Ok(())
3173 }
3174 }
3175
3176 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3177 for WlanFullmacSignalReportIndication
3178 {
3179 #[inline(always)]
3180 fn new_empty() -> Self {
3181 Self { rssi_dbm: fidl::new_empty!(i8, D), snr_db: fidl::new_empty!(i8, D) }
3182 }
3183
3184 #[inline]
3185 unsafe fn decode(
3186 &mut self,
3187 decoder: &mut fidl::encoding::Decoder<'_, D>,
3188 offset: usize,
3189 _depth: fidl::encoding::Depth,
3190 ) -> fidl::Result<()> {
3191 decoder.debug_check_bounds::<Self>(offset);
3192 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3193 unsafe {
3196 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3197 }
3198 Ok(())
3199 }
3200 }
3201
3202 impl BandCapability {
3203 #[inline(always)]
3204 fn max_ordinal_present(&self) -> u64 {
3205 if let Some(_) = self.operating_channels {
3206 return 5;
3207 }
3208 if let Some(_) = self.vht_caps {
3209 return 4;
3210 }
3211 if let Some(_) = self.ht_caps {
3212 return 3;
3213 }
3214 if let Some(_) = self.basic_rates {
3215 return 2;
3216 }
3217 if let Some(_) = self.band {
3218 return 1;
3219 }
3220 0
3221 }
3222 }
3223
3224 impl fidl::encoding::ValueTypeMarker for BandCapability {
3225 type Borrowed<'a> = &'a Self;
3226 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3227 value
3228 }
3229 }
3230
3231 unsafe impl fidl::encoding::TypeMarker for BandCapability {
3232 type Owned = Self;
3233
3234 #[inline(always)]
3235 fn inline_align(_context: fidl::encoding::Context) -> usize {
3236 8
3237 }
3238
3239 #[inline(always)]
3240 fn inline_size(_context: fidl::encoding::Context) -> usize {
3241 16
3242 }
3243 }
3244
3245 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
3246 for &BandCapability
3247 {
3248 unsafe fn encode(
3249 self,
3250 encoder: &mut fidl::encoding::Encoder<'_, D>,
3251 offset: usize,
3252 mut depth: fidl::encoding::Depth,
3253 ) -> fidl::Result<()> {
3254 encoder.debug_check_bounds::<BandCapability>(offset);
3255 let max_ordinal: u64 = self.max_ordinal_present();
3257 encoder.write_num(max_ordinal, offset);
3258 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3259 if max_ordinal == 0 {
3261 return Ok(());
3262 }
3263 depth.increment()?;
3264 let envelope_size = 8;
3265 let bytes_len = max_ordinal as usize * envelope_size;
3266 #[allow(unused_variables)]
3267 let offset = encoder.out_of_line_offset(bytes_len);
3268 let mut _prev_end_offset: usize = 0;
3269 if 1 > max_ordinal {
3270 return Ok(());
3271 }
3272
3273 let cur_offset: usize = (1 - 1) * envelope_size;
3276
3277 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3279
3280 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>(
3285 self.band.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow),
3286 encoder, offset + cur_offset, depth
3287 )?;
3288
3289 _prev_end_offset = cur_offset + envelope_size;
3290 if 2 > max_ordinal {
3291 return Ok(());
3292 }
3293
3294 let cur_offset: usize = (2 - 1) * envelope_size;
3297
3298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3300
3301 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 12>, D>(
3306 self.basic_rates.as_ref().map(
3307 <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow,
3308 ),
3309 encoder,
3310 offset + cur_offset,
3311 depth,
3312 )?;
3313
3314 _prev_end_offset = cur_offset + envelope_size;
3315 if 3 > max_ordinal {
3316 return Ok(());
3317 }
3318
3319 let cur_offset: usize = (3 - 1) * envelope_size;
3322
3323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3325
3326 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D>(
3331 self.ht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3332 encoder, offset + cur_offset, depth
3333 )?;
3334
3335 _prev_end_offset = cur_offset + envelope_size;
3336 if 4 > max_ordinal {
3337 return Ok(());
3338 }
3339
3340 let cur_offset: usize = (4 - 1) * envelope_size;
3343
3344 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3346
3347 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D>(
3352 self.vht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3353 encoder, offset + cur_offset, depth
3354 )?;
3355
3356 _prev_end_offset = cur_offset + envelope_size;
3357 if 5 > max_ordinal {
3358 return Ok(());
3359 }
3360
3361 let cur_offset: usize = (5 - 1) * envelope_size;
3364
3365 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3367
3368 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
3373 self.operating_channels.as_ref().map(
3374 <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
3375 ),
3376 encoder,
3377 offset + cur_offset,
3378 depth,
3379 )?;
3380
3381 _prev_end_offset = cur_offset + envelope_size;
3382
3383 Ok(())
3384 }
3385 }
3386
3387 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
3388 #[inline(always)]
3389 fn new_empty() -> Self {
3390 Self::default()
3391 }
3392
3393 unsafe fn decode(
3394 &mut self,
3395 decoder: &mut fidl::encoding::Decoder<'_, D>,
3396 offset: usize,
3397 mut depth: fidl::encoding::Depth,
3398 ) -> fidl::Result<()> {
3399 decoder.debug_check_bounds::<Self>(offset);
3400 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3401 None => return Err(fidl::Error::NotNullable),
3402 Some(len) => len,
3403 };
3404 if len == 0 {
3406 return Ok(());
3407 };
3408 depth.increment()?;
3409 let envelope_size = 8;
3410 let bytes_len = len * envelope_size;
3411 let offset = decoder.out_of_line_offset(bytes_len)?;
3412 let mut _next_ordinal_to_read = 0;
3414 let mut next_offset = offset;
3415 let end_offset = offset + bytes_len;
3416 _next_ordinal_to_read += 1;
3417 if next_offset >= end_offset {
3418 return Ok(());
3419 }
3420
3421 while _next_ordinal_to_read < 1 {
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 = <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3434 if inlined != (member_inline_size <= 4) {
3435 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3436 }
3437 let inner_offset;
3438 let mut inner_depth = depth.clone();
3439 if inlined {
3440 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3441 inner_offset = next_offset;
3442 } else {
3443 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3444 inner_depth.increment()?;
3445 }
3446 let val_ref = self.band.get_or_insert_with(|| {
3447 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D)
3448 });
3449 fidl::decode!(
3450 fidl_fuchsia_wlan_ieee80211__common::WlanBand,
3451 D,
3452 val_ref,
3453 decoder,
3454 inner_offset,
3455 inner_depth
3456 )?;
3457 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3458 {
3459 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3460 }
3461 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3462 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3463 }
3464 }
3465
3466 next_offset += envelope_size;
3467 _next_ordinal_to_read += 1;
3468 if next_offset >= end_offset {
3469 return Ok(());
3470 }
3471
3472 while _next_ordinal_to_read < 2 {
3474 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3475 _next_ordinal_to_read += 1;
3476 next_offset += envelope_size;
3477 }
3478
3479 let next_out_of_line = decoder.next_out_of_line();
3480 let handles_before = decoder.remaining_handles();
3481 if let Some((inlined, num_bytes, num_handles)) =
3482 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3483 {
3484 let member_inline_size =
3485 <fidl::encoding::Vector<u8, 12> as fidl::encoding::TypeMarker>::inline_size(
3486 decoder.context,
3487 );
3488 if inlined != (member_inline_size <= 4) {
3489 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3490 }
3491 let inner_offset;
3492 let mut inner_depth = depth.clone();
3493 if inlined {
3494 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3495 inner_offset = next_offset;
3496 } else {
3497 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3498 inner_depth.increment()?;
3499 }
3500 let val_ref = self
3501 .basic_rates
3502 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D));
3503 fidl::decode!(fidl::encoding::Vector<u8, 12>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 3 {
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::HtCapabilities 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.ht_caps.get_or_insert_with(|| {
3545 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D)
3546 });
3547 fidl::decode!(
3548 fidl_fuchsia_wlan_ieee80211__common::HtCapabilities,
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 < 4 {
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 = <fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3583 if inlined != (member_inline_size <= 4) {
3584 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3585 }
3586 let inner_offset;
3587 let mut inner_depth = depth.clone();
3588 if inlined {
3589 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3590 inner_offset = next_offset;
3591 } else {
3592 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3593 inner_depth.increment()?;
3594 }
3595 let val_ref = self.vht_caps.get_or_insert_with(|| {
3596 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D)
3597 });
3598 fidl::decode!(
3599 fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities,
3600 D,
3601 val_ref,
3602 decoder,
3603 inner_offset,
3604 inner_depth
3605 )?;
3606 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3607 {
3608 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3609 }
3610 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3611 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3612 }
3613 }
3614
3615 next_offset += envelope_size;
3616 _next_ordinal_to_read += 1;
3617 if next_offset >= end_offset {
3618 return Ok(());
3619 }
3620
3621 while _next_ordinal_to_read < 5 {
3623 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3624 _next_ordinal_to_read += 1;
3625 next_offset += envelope_size;
3626 }
3627
3628 let next_out_of_line = decoder.next_out_of_line();
3629 let handles_before = decoder.remaining_handles();
3630 if let Some((inlined, num_bytes, num_handles)) =
3631 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3632 {
3633 let member_inline_size =
3634 <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
3635 decoder.context,
3636 );
3637 if inlined != (member_inline_size <= 4) {
3638 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3639 }
3640 let inner_offset;
3641 let mut inner_depth = depth.clone();
3642 if inlined {
3643 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3644 inner_offset = next_offset;
3645 } else {
3646 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3647 inner_depth.increment()?;
3648 }
3649 let val_ref = self
3650 .operating_channels
3651 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
3652 fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
3653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3654 {
3655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3656 }
3657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3659 }
3660 }
3661
3662 next_offset += envelope_size;
3663
3664 while next_offset < end_offset {
3666 _next_ordinal_to_read += 1;
3667 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3668 next_offset += envelope_size;
3669 }
3670
3671 Ok(())
3672 }
3673 }
3674
3675 impl SaeFrame {
3676 #[inline(always)]
3677 fn max_ordinal_present(&self) -> u64 {
3678 if let Some(_) = self.sae_fields {
3679 return 4;
3680 }
3681 if let Some(_) = self.seq_num {
3682 return 3;
3683 }
3684 if let Some(_) = self.status_code {
3685 return 2;
3686 }
3687 if let Some(_) = self.peer_sta_address {
3688 return 1;
3689 }
3690 0
3691 }
3692 }
3693
3694 impl fidl::encoding::ValueTypeMarker for SaeFrame {
3695 type Borrowed<'a> = &'a Self;
3696 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3697 value
3698 }
3699 }
3700
3701 unsafe impl fidl::encoding::TypeMarker for SaeFrame {
3702 type Owned = Self;
3703
3704 #[inline(always)]
3705 fn inline_align(_context: fidl::encoding::Context) -> usize {
3706 8
3707 }
3708
3709 #[inline(always)]
3710 fn inline_size(_context: fidl::encoding::Context) -> usize {
3711 16
3712 }
3713 }
3714
3715 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
3716 unsafe fn encode(
3717 self,
3718 encoder: &mut fidl::encoding::Encoder<'_, D>,
3719 offset: usize,
3720 mut depth: fidl::encoding::Depth,
3721 ) -> fidl::Result<()> {
3722 encoder.debug_check_bounds::<SaeFrame>(offset);
3723 let max_ordinal: u64 = self.max_ordinal_present();
3725 encoder.write_num(max_ordinal, offset);
3726 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3727 if max_ordinal == 0 {
3729 return Ok(());
3730 }
3731 depth.increment()?;
3732 let envelope_size = 8;
3733 let bytes_len = max_ordinal as usize * envelope_size;
3734 #[allow(unused_variables)]
3735 let offset = encoder.out_of_line_offset(bytes_len);
3736 let mut _prev_end_offset: usize = 0;
3737 if 1 > max_ordinal {
3738 return Ok(());
3739 }
3740
3741 let cur_offset: usize = (1 - 1) * envelope_size;
3744
3745 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3747
3748 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3753 self.peer_sta_address
3754 .as_ref()
3755 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3756 encoder,
3757 offset + cur_offset,
3758 depth,
3759 )?;
3760
3761 _prev_end_offset = cur_offset + envelope_size;
3762 if 2 > max_ordinal {
3763 return Ok(());
3764 }
3765
3766 let cur_offset: usize = (2 - 1) * envelope_size;
3769
3770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3772
3773 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
3778 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
3779 encoder, offset + cur_offset, depth
3780 )?;
3781
3782 _prev_end_offset = cur_offset + envelope_size;
3783 if 3 > max_ordinal {
3784 return Ok(());
3785 }
3786
3787 let cur_offset: usize = (3 - 1) * envelope_size;
3790
3791 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3793
3794 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3799 self.seq_num.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3800 encoder,
3801 offset + cur_offset,
3802 depth,
3803 )?;
3804
3805 _prev_end_offset = cur_offset + envelope_size;
3806 if 4 > max_ordinal {
3807 return Ok(());
3808 }
3809
3810 let cur_offset: usize = (4 - 1) * envelope_size;
3813
3814 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3816
3817 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3822 self.sae_fields.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3823 encoder, offset + cur_offset, depth
3824 )?;
3825
3826 _prev_end_offset = cur_offset + envelope_size;
3827
3828 Ok(())
3829 }
3830 }
3831
3832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
3833 #[inline(always)]
3834 fn new_empty() -> Self {
3835 Self::default()
3836 }
3837
3838 unsafe fn decode(
3839 &mut self,
3840 decoder: &mut fidl::encoding::Decoder<'_, D>,
3841 offset: usize,
3842 mut depth: fidl::encoding::Depth,
3843 ) -> fidl::Result<()> {
3844 decoder.debug_check_bounds::<Self>(offset);
3845 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3846 None => return Err(fidl::Error::NotNullable),
3847 Some(len) => len,
3848 };
3849 if len == 0 {
3851 return Ok(());
3852 };
3853 depth.increment()?;
3854 let envelope_size = 8;
3855 let bytes_len = len * envelope_size;
3856 let offset = decoder.out_of_line_offset(bytes_len)?;
3857 let mut _next_ordinal_to_read = 0;
3859 let mut next_offset = offset;
3860 let end_offset = offset + bytes_len;
3861 _next_ordinal_to_read += 1;
3862 if next_offset >= end_offset {
3863 return Ok(());
3864 }
3865
3866 while _next_ordinal_to_read < 1 {
3868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3869 _next_ordinal_to_read += 1;
3870 next_offset += envelope_size;
3871 }
3872
3873 let next_out_of_line = decoder.next_out_of_line();
3874 let handles_before = decoder.remaining_handles();
3875 if let Some((inlined, num_bytes, num_handles)) =
3876 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3877 {
3878 let member_inline_size =
3879 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3880 decoder.context,
3881 );
3882 if inlined != (member_inline_size <= 4) {
3883 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3884 }
3885 let inner_offset;
3886 let mut inner_depth = depth.clone();
3887 if inlined {
3888 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3889 inner_offset = next_offset;
3890 } else {
3891 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3892 inner_depth.increment()?;
3893 }
3894 let val_ref = self
3895 .peer_sta_address
3896 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3897 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3926 if inlined != (member_inline_size <= 4) {
3927 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3928 }
3929 let inner_offset;
3930 let mut inner_depth = depth.clone();
3931 if inlined {
3932 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3933 inner_offset = next_offset;
3934 } else {
3935 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3936 inner_depth.increment()?;
3937 }
3938 let val_ref = self.status_code.get_or_insert_with(|| {
3939 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
3940 });
3941 fidl::decode!(
3942 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
3943 D,
3944 val_ref,
3945 decoder,
3946 inner_offset,
3947 inner_depth
3948 )?;
3949 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3950 {
3951 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3952 }
3953 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3954 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3955 }
3956 }
3957
3958 next_offset += envelope_size;
3959 _next_ordinal_to_read += 1;
3960 if next_offset >= end_offset {
3961 return Ok(());
3962 }
3963
3964 while _next_ordinal_to_read < 3 {
3966 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3967 _next_ordinal_to_read += 1;
3968 next_offset += envelope_size;
3969 }
3970
3971 let next_out_of_line = decoder.next_out_of_line();
3972 let handles_before = decoder.remaining_handles();
3973 if let Some((inlined, num_bytes, num_handles)) =
3974 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3975 {
3976 let member_inline_size =
3977 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3978 if inlined != (member_inline_size <= 4) {
3979 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3980 }
3981 let inner_offset;
3982 let mut inner_depth = depth.clone();
3983 if inlined {
3984 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3985 inner_offset = next_offset;
3986 } else {
3987 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3988 inner_depth.increment()?;
3989 }
3990 let val_ref = self.seq_num.get_or_insert_with(|| fidl::new_empty!(u16, D));
3991 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
4003 if next_offset >= end_offset {
4004 return Ok(());
4005 }
4006
4007 while _next_ordinal_to_read < 4 {
4009 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4010 _next_ordinal_to_read += 1;
4011 next_offset += envelope_size;
4012 }
4013
4014 let next_out_of_line = decoder.next_out_of_line();
4015 let handles_before = decoder.remaining_handles();
4016 if let Some((inlined, num_bytes, num_handles)) =
4017 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4018 {
4019 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4020 if inlined != (member_inline_size <= 4) {
4021 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4022 }
4023 let inner_offset;
4024 let mut inner_depth = depth.clone();
4025 if inlined {
4026 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4027 inner_offset = next_offset;
4028 } else {
4029 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4030 inner_depth.increment()?;
4031 }
4032 let val_ref = self.sae_fields.get_or_insert_with(|| {
4033 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
4034 });
4035 fidl::decode!(
4036 fidl::encoding::UnboundedVector<u8>,
4037 D,
4038 val_ref,
4039 decoder,
4040 inner_offset,
4041 inner_depth
4042 )?;
4043 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4044 {
4045 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4046 }
4047 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4048 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4049 }
4050 }
4051
4052 next_offset += envelope_size;
4053
4054 while next_offset < end_offset {
4056 _next_ordinal_to_read += 1;
4057 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4058 next_offset += envelope_size;
4059 }
4060
4061 Ok(())
4062 }
4063 }
4064
4065 impl WlanFullmacImplAssocRespRequest {
4066 #[inline(always)]
4067 fn max_ordinal_present(&self) -> u64 {
4068 if let Some(_) = self.association_id {
4069 return 3;
4070 }
4071 if let Some(_) = self.result_code {
4072 return 2;
4073 }
4074 if let Some(_) = self.peer_sta_address {
4075 return 1;
4076 }
4077 0
4078 }
4079 }
4080
4081 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAssocRespRequest {
4082 type Borrowed<'a> = &'a Self;
4083 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4084 value
4085 }
4086 }
4087
4088 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAssocRespRequest {
4089 type Owned = Self;
4090
4091 #[inline(always)]
4092 fn inline_align(_context: fidl::encoding::Context) -> usize {
4093 8
4094 }
4095
4096 #[inline(always)]
4097 fn inline_size(_context: fidl::encoding::Context) -> usize {
4098 16
4099 }
4100 }
4101
4102 unsafe impl<D: fidl::encoding::ResourceDialect>
4103 fidl::encoding::Encode<WlanFullmacImplAssocRespRequest, D>
4104 for &WlanFullmacImplAssocRespRequest
4105 {
4106 unsafe fn encode(
4107 self,
4108 encoder: &mut fidl::encoding::Encoder<'_, D>,
4109 offset: usize,
4110 mut depth: fidl::encoding::Depth,
4111 ) -> fidl::Result<()> {
4112 encoder.debug_check_bounds::<WlanFullmacImplAssocRespRequest>(offset);
4113 let max_ordinal: u64 = self.max_ordinal_present();
4115 encoder.write_num(max_ordinal, offset);
4116 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4117 if max_ordinal == 0 {
4119 return Ok(());
4120 }
4121 depth.increment()?;
4122 let envelope_size = 8;
4123 let bytes_len = max_ordinal as usize * envelope_size;
4124 #[allow(unused_variables)]
4125 let offset = encoder.out_of_line_offset(bytes_len);
4126 let mut _prev_end_offset: usize = 0;
4127 if 1 > max_ordinal {
4128 return Ok(());
4129 }
4130
4131 let cur_offset: usize = (1 - 1) * envelope_size;
4134
4135 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4137
4138 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4143 self.peer_sta_address
4144 .as_ref()
4145 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4146 encoder,
4147 offset + cur_offset,
4148 depth,
4149 )?;
4150
4151 _prev_end_offset = cur_offset + envelope_size;
4152 if 2 > max_ordinal {
4153 return Ok(());
4154 }
4155
4156 let cur_offset: usize = (2 - 1) * envelope_size;
4159
4160 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4162
4163 fidl::encoding::encode_in_envelope_optional::<WlanAssocResult, D>(
4168 self.result_code
4169 .as_ref()
4170 .map(<WlanAssocResult as fidl::encoding::ValueTypeMarker>::borrow),
4171 encoder,
4172 offset + cur_offset,
4173 depth,
4174 )?;
4175
4176 _prev_end_offset = cur_offset + envelope_size;
4177 if 3 > max_ordinal {
4178 return Ok(());
4179 }
4180
4181 let cur_offset: usize = (3 - 1) * envelope_size;
4184
4185 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4187
4188 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4193 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4194 encoder,
4195 offset + cur_offset,
4196 depth,
4197 )?;
4198
4199 _prev_end_offset = cur_offset + envelope_size;
4200
4201 Ok(())
4202 }
4203 }
4204
4205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4206 for WlanFullmacImplAssocRespRequest
4207 {
4208 #[inline(always)]
4209 fn new_empty() -> Self {
4210 Self::default()
4211 }
4212
4213 unsafe fn decode(
4214 &mut self,
4215 decoder: &mut fidl::encoding::Decoder<'_, D>,
4216 offset: usize,
4217 mut depth: fidl::encoding::Depth,
4218 ) -> fidl::Result<()> {
4219 decoder.debug_check_bounds::<Self>(offset);
4220 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4221 None => return Err(fidl::Error::NotNullable),
4222 Some(len) => len,
4223 };
4224 if len == 0 {
4226 return Ok(());
4227 };
4228 depth.increment()?;
4229 let envelope_size = 8;
4230 let bytes_len = len * envelope_size;
4231 let offset = decoder.out_of_line_offset(bytes_len)?;
4232 let mut _next_ordinal_to_read = 0;
4234 let mut next_offset = offset;
4235 let end_offset = offset + bytes_len;
4236 _next_ordinal_to_read += 1;
4237 if next_offset >= end_offset {
4238 return Ok(());
4239 }
4240
4241 while _next_ordinal_to_read < 1 {
4243 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4244 _next_ordinal_to_read += 1;
4245 next_offset += envelope_size;
4246 }
4247
4248 let next_out_of_line = decoder.next_out_of_line();
4249 let handles_before = decoder.remaining_handles();
4250 if let Some((inlined, num_bytes, num_handles)) =
4251 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4252 {
4253 let member_inline_size =
4254 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4255 decoder.context,
4256 );
4257 if inlined != (member_inline_size <= 4) {
4258 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4259 }
4260 let inner_offset;
4261 let mut inner_depth = depth.clone();
4262 if inlined {
4263 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4264 inner_offset = next_offset;
4265 } else {
4266 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4267 inner_depth.increment()?;
4268 }
4269 let val_ref = self
4270 .peer_sta_address
4271 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4272 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4274 {
4275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4276 }
4277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4279 }
4280 }
4281
4282 next_offset += envelope_size;
4283 _next_ordinal_to_read += 1;
4284 if next_offset >= end_offset {
4285 return Ok(());
4286 }
4287
4288 while _next_ordinal_to_read < 2 {
4290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4291 _next_ordinal_to_read += 1;
4292 next_offset += envelope_size;
4293 }
4294
4295 let next_out_of_line = decoder.next_out_of_line();
4296 let handles_before = decoder.remaining_handles();
4297 if let Some((inlined, num_bytes, num_handles)) =
4298 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4299 {
4300 let member_inline_size =
4301 <WlanAssocResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4302 if inlined != (member_inline_size <= 4) {
4303 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4304 }
4305 let inner_offset;
4306 let mut inner_depth = depth.clone();
4307 if inlined {
4308 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4309 inner_offset = next_offset;
4310 } else {
4311 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4312 inner_depth.increment()?;
4313 }
4314 let val_ref =
4315 self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAssocResult, D));
4316 fidl::decode!(WlanAssocResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4317 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4318 {
4319 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4320 }
4321 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4322 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4323 }
4324 }
4325
4326 next_offset += envelope_size;
4327 _next_ordinal_to_read += 1;
4328 if next_offset >= end_offset {
4329 return Ok(());
4330 }
4331
4332 while _next_ordinal_to_read < 3 {
4334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4335 _next_ordinal_to_read += 1;
4336 next_offset += envelope_size;
4337 }
4338
4339 let next_out_of_line = decoder.next_out_of_line();
4340 let handles_before = decoder.remaining_handles();
4341 if let Some((inlined, num_bytes, num_handles)) =
4342 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4343 {
4344 let member_inline_size =
4345 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4346 if inlined != (member_inline_size <= 4) {
4347 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4348 }
4349 let inner_offset;
4350 let mut inner_depth = depth.clone();
4351 if inlined {
4352 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4353 inner_offset = next_offset;
4354 } else {
4355 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4356 inner_depth.increment()?;
4357 }
4358 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4359 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4361 {
4362 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4363 }
4364 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4365 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4366 }
4367 }
4368
4369 next_offset += envelope_size;
4370
4371 while next_offset < end_offset {
4373 _next_ordinal_to_read += 1;
4374 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4375 next_offset += envelope_size;
4376 }
4377
4378 Ok(())
4379 }
4380 }
4381
4382 impl WlanFullmacImplAuthRespRequest {
4383 #[inline(always)]
4384 fn max_ordinal_present(&self) -> u64 {
4385 if let Some(_) = self.result_code {
4386 return 2;
4387 }
4388 if let Some(_) = self.peer_sta_address {
4389 return 1;
4390 }
4391 0
4392 }
4393 }
4394
4395 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAuthRespRequest {
4396 type Borrowed<'a> = &'a Self;
4397 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4398 value
4399 }
4400 }
4401
4402 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAuthRespRequest {
4403 type Owned = Self;
4404
4405 #[inline(always)]
4406 fn inline_align(_context: fidl::encoding::Context) -> usize {
4407 8
4408 }
4409
4410 #[inline(always)]
4411 fn inline_size(_context: fidl::encoding::Context) -> usize {
4412 16
4413 }
4414 }
4415
4416 unsafe impl<D: fidl::encoding::ResourceDialect>
4417 fidl::encoding::Encode<WlanFullmacImplAuthRespRequest, D>
4418 for &WlanFullmacImplAuthRespRequest
4419 {
4420 unsafe fn encode(
4421 self,
4422 encoder: &mut fidl::encoding::Encoder<'_, D>,
4423 offset: usize,
4424 mut depth: fidl::encoding::Depth,
4425 ) -> fidl::Result<()> {
4426 encoder.debug_check_bounds::<WlanFullmacImplAuthRespRequest>(offset);
4427 let max_ordinal: u64 = self.max_ordinal_present();
4429 encoder.write_num(max_ordinal, offset);
4430 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4431 if max_ordinal == 0 {
4433 return Ok(());
4434 }
4435 depth.increment()?;
4436 let envelope_size = 8;
4437 let bytes_len = max_ordinal as usize * envelope_size;
4438 #[allow(unused_variables)]
4439 let offset = encoder.out_of_line_offset(bytes_len);
4440 let mut _prev_end_offset: usize = 0;
4441 if 1 > max_ordinal {
4442 return Ok(());
4443 }
4444
4445 let cur_offset: usize = (1 - 1) * envelope_size;
4448
4449 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4451
4452 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4457 self.peer_sta_address
4458 .as_ref()
4459 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4460 encoder,
4461 offset + cur_offset,
4462 depth,
4463 )?;
4464
4465 _prev_end_offset = cur_offset + envelope_size;
4466 if 2 > max_ordinal {
4467 return Ok(());
4468 }
4469
4470 let cur_offset: usize = (2 - 1) * envelope_size;
4473
4474 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4476
4477 fidl::encoding::encode_in_envelope_optional::<WlanAuthResult, D>(
4482 self.result_code
4483 .as_ref()
4484 .map(<WlanAuthResult as fidl::encoding::ValueTypeMarker>::borrow),
4485 encoder,
4486 offset + cur_offset,
4487 depth,
4488 )?;
4489
4490 _prev_end_offset = cur_offset + envelope_size;
4491
4492 Ok(())
4493 }
4494 }
4495
4496 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4497 for WlanFullmacImplAuthRespRequest
4498 {
4499 #[inline(always)]
4500 fn new_empty() -> Self {
4501 Self::default()
4502 }
4503
4504 unsafe fn decode(
4505 &mut self,
4506 decoder: &mut fidl::encoding::Decoder<'_, D>,
4507 offset: usize,
4508 mut depth: fidl::encoding::Depth,
4509 ) -> fidl::Result<()> {
4510 decoder.debug_check_bounds::<Self>(offset);
4511 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4512 None => return Err(fidl::Error::NotNullable),
4513 Some(len) => len,
4514 };
4515 if len == 0 {
4517 return Ok(());
4518 };
4519 depth.increment()?;
4520 let envelope_size = 8;
4521 let bytes_len = len * envelope_size;
4522 let offset = decoder.out_of_line_offset(bytes_len)?;
4523 let mut _next_ordinal_to_read = 0;
4525 let mut next_offset = offset;
4526 let end_offset = offset + bytes_len;
4527 _next_ordinal_to_read += 1;
4528 if next_offset >= end_offset {
4529 return Ok(());
4530 }
4531
4532 while _next_ordinal_to_read < 1 {
4534 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4535 _next_ordinal_to_read += 1;
4536 next_offset += envelope_size;
4537 }
4538
4539 let next_out_of_line = decoder.next_out_of_line();
4540 let handles_before = decoder.remaining_handles();
4541 if let Some((inlined, num_bytes, num_handles)) =
4542 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4543 {
4544 let member_inline_size =
4545 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4546 decoder.context,
4547 );
4548 if inlined != (member_inline_size <= 4) {
4549 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4550 }
4551 let inner_offset;
4552 let mut inner_depth = depth.clone();
4553 if inlined {
4554 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4555 inner_offset = next_offset;
4556 } else {
4557 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4558 inner_depth.increment()?;
4559 }
4560 let val_ref = self
4561 .peer_sta_address
4562 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4563 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4564 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4565 {
4566 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4567 }
4568 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4569 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4570 }
4571 }
4572
4573 next_offset += envelope_size;
4574 _next_ordinal_to_read += 1;
4575 if next_offset >= end_offset {
4576 return Ok(());
4577 }
4578
4579 while _next_ordinal_to_read < 2 {
4581 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4582 _next_ordinal_to_read += 1;
4583 next_offset += envelope_size;
4584 }
4585
4586 let next_out_of_line = decoder.next_out_of_line();
4587 let handles_before = decoder.remaining_handles();
4588 if let Some((inlined, num_bytes, num_handles)) =
4589 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4590 {
4591 let member_inline_size =
4592 <WlanAuthResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4593 if inlined != (member_inline_size <= 4) {
4594 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4595 }
4596 let inner_offset;
4597 let mut inner_depth = depth.clone();
4598 if inlined {
4599 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4600 inner_offset = next_offset;
4601 } else {
4602 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4603 inner_depth.increment()?;
4604 }
4605 let val_ref =
4606 self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAuthResult, D));
4607 fidl::decode!(WlanAuthResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4608 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4609 {
4610 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4611 }
4612 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4613 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4614 }
4615 }
4616
4617 next_offset += envelope_size;
4618
4619 while next_offset < end_offset {
4621 _next_ordinal_to_read += 1;
4622 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4623 next_offset += envelope_size;
4624 }
4625
4626 Ok(())
4627 }
4628 }
4629
4630 impl WlanFullmacImplConnectRequest {
4631 #[inline(always)]
4632 fn max_ordinal_present(&self) -> u64 {
4633 if let Some(_) = self.wep_key_desc {
4634 return 7;
4635 }
4636 if let Some(_) = self.security_ie {
4637 return 6;
4638 }
4639 if let Some(_) = self.wep_key {
4640 return 5;
4641 }
4642 if let Some(_) = self.sae_password {
4643 return 4;
4644 }
4645 if let Some(_) = self.auth_type {
4646 return 3;
4647 }
4648 if let Some(_) = self.connect_failure_timeout {
4649 return 2;
4650 }
4651 if let Some(_) = self.selected_bss {
4652 return 1;
4653 }
4654 0
4655 }
4656 }
4657
4658 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplConnectRequest {
4659 type Borrowed<'a> = &'a Self;
4660 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4661 value
4662 }
4663 }
4664
4665 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplConnectRequest {
4666 type Owned = Self;
4667
4668 #[inline(always)]
4669 fn inline_align(_context: fidl::encoding::Context) -> usize {
4670 8
4671 }
4672
4673 #[inline(always)]
4674 fn inline_size(_context: fidl::encoding::Context) -> usize {
4675 16
4676 }
4677 }
4678
4679 unsafe impl<D: fidl::encoding::ResourceDialect>
4680 fidl::encoding::Encode<WlanFullmacImplConnectRequest, D>
4681 for &WlanFullmacImplConnectRequest
4682 {
4683 unsafe fn encode(
4684 self,
4685 encoder: &mut fidl::encoding::Encoder<'_, D>,
4686 offset: usize,
4687 mut depth: fidl::encoding::Depth,
4688 ) -> fidl::Result<()> {
4689 encoder.debug_check_bounds::<WlanFullmacImplConnectRequest>(offset);
4690 let max_ordinal: u64 = self.max_ordinal_present();
4692 encoder.write_num(max_ordinal, offset);
4693 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4694 if max_ordinal == 0 {
4696 return Ok(());
4697 }
4698 depth.increment()?;
4699 let envelope_size = 8;
4700 let bytes_len = max_ordinal as usize * envelope_size;
4701 #[allow(unused_variables)]
4702 let offset = encoder.out_of_line_offset(bytes_len);
4703 let mut _prev_end_offset: usize = 0;
4704 if 1 > max_ordinal {
4705 return Ok(());
4706 }
4707
4708 let cur_offset: usize = (1 - 1) * envelope_size;
4711
4712 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4714
4715 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
4720 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
4721 encoder, offset + cur_offset, depth
4722 )?;
4723
4724 _prev_end_offset = cur_offset + envelope_size;
4725 if 2 > max_ordinal {
4726 return Ok(());
4727 }
4728
4729 let cur_offset: usize = (2 - 1) * envelope_size;
4732
4733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4735
4736 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4741 self.connect_failure_timeout
4742 .as_ref()
4743 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4744 encoder,
4745 offset + cur_offset,
4746 depth,
4747 )?;
4748
4749 _prev_end_offset = cur_offset + envelope_size;
4750 if 3 > max_ordinal {
4751 return Ok(());
4752 }
4753
4754 let cur_offset: usize = (3 - 1) * envelope_size;
4757
4758 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4760
4761 fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
4766 self.auth_type
4767 .as_ref()
4768 .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
4769 encoder,
4770 offset + cur_offset,
4771 depth,
4772 )?;
4773
4774 _prev_end_offset = cur_offset + envelope_size;
4775 if 4 > max_ordinal {
4776 return Ok(());
4777 }
4778
4779 let cur_offset: usize = (4 - 1) * envelope_size;
4782
4783 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4785
4786 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4791 self.sae_password.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4792 encoder, offset + cur_offset, depth
4793 )?;
4794
4795 _prev_end_offset = cur_offset + envelope_size;
4796 if 5 > max_ordinal {
4797 return Ok(());
4798 }
4799
4800 let cur_offset: usize = (5 - 1) * envelope_size;
4803
4804 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4806
4807 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanKeyConfig, D>(
4812 self.wep_key.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::ValueTypeMarker>::borrow),
4813 encoder, offset + cur_offset, depth
4814 )?;
4815
4816 _prev_end_offset = cur_offset + envelope_size;
4817 if 6 > max_ordinal {
4818 return Ok(());
4819 }
4820
4821 let cur_offset: usize = (6 - 1) * envelope_size;
4824
4825 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4827
4828 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
4833 self.security_ie.as_ref().map(
4834 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
4835 ),
4836 encoder,
4837 offset + cur_offset,
4838 depth,
4839 )?;
4840
4841 _prev_end_offset = cur_offset + envelope_size;
4842 if 7 > max_ordinal {
4843 return Ok(());
4844 }
4845
4846 let cur_offset: usize = (7 - 1) * envelope_size;
4849
4850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4852
4853 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D>(
4858 self.wep_key_desc.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::ValueTypeMarker>::borrow),
4859 encoder, offset + cur_offset, depth
4860 )?;
4861
4862 _prev_end_offset = cur_offset + envelope_size;
4863
4864 Ok(())
4865 }
4866 }
4867
4868 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4869 for WlanFullmacImplConnectRequest
4870 {
4871 #[inline(always)]
4872 fn new_empty() -> Self {
4873 Self::default()
4874 }
4875
4876 unsafe fn decode(
4877 &mut self,
4878 decoder: &mut fidl::encoding::Decoder<'_, D>,
4879 offset: usize,
4880 mut depth: fidl::encoding::Depth,
4881 ) -> fidl::Result<()> {
4882 decoder.debug_check_bounds::<Self>(offset);
4883 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4884 None => return Err(fidl::Error::NotNullable),
4885 Some(len) => len,
4886 };
4887 if len == 0 {
4889 return Ok(());
4890 };
4891 depth.increment()?;
4892 let envelope_size = 8;
4893 let bytes_len = len * envelope_size;
4894 let offset = decoder.out_of_line_offset(bytes_len)?;
4895 let mut _next_ordinal_to_read = 0;
4897 let mut next_offset = offset;
4898 let end_offset = offset + bytes_len;
4899 _next_ordinal_to_read += 1;
4900 if next_offset >= end_offset {
4901 return Ok(());
4902 }
4903
4904 while _next_ordinal_to_read < 1 {
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 = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4917 if inlined != (member_inline_size <= 4) {
4918 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4919 }
4920 let inner_offset;
4921 let mut inner_depth = depth.clone();
4922 if inlined {
4923 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4924 inner_offset = next_offset;
4925 } else {
4926 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4927 inner_depth.increment()?;
4928 }
4929 let val_ref = self.selected_bss.get_or_insert_with(|| {
4930 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
4931 });
4932 fidl::decode!(
4933 fidl_fuchsia_wlan_common__common::BssDescription,
4934 D,
4935 val_ref,
4936 decoder,
4937 inner_offset,
4938 inner_depth
4939 )?;
4940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4941 {
4942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4943 }
4944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4946 }
4947 }
4948
4949 next_offset += envelope_size;
4950 _next_ordinal_to_read += 1;
4951 if next_offset >= end_offset {
4952 return Ok(());
4953 }
4954
4955 while _next_ordinal_to_read < 2 {
4957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4958 _next_ordinal_to_read += 1;
4959 next_offset += envelope_size;
4960 }
4961
4962 let next_out_of_line = decoder.next_out_of_line();
4963 let handles_before = decoder.remaining_handles();
4964 if let Some((inlined, num_bytes, num_handles)) =
4965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4966 {
4967 let member_inline_size =
4968 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4969 if inlined != (member_inline_size <= 4) {
4970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4971 }
4972 let inner_offset;
4973 let mut inner_depth = depth.clone();
4974 if inlined {
4975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4976 inner_offset = next_offset;
4977 } else {
4978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4979 inner_depth.increment()?;
4980 }
4981 let val_ref =
4982 self.connect_failure_timeout.get_or_insert_with(|| fidl::new_empty!(u32, D));
4983 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4984 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4985 {
4986 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4987 }
4988 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4989 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4990 }
4991 }
4992
4993 next_offset += envelope_size;
4994 _next_ordinal_to_read += 1;
4995 if next_offset >= end_offset {
4996 return Ok(());
4997 }
4998
4999 while _next_ordinal_to_read < 3 {
5001 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5002 _next_ordinal_to_read += 1;
5003 next_offset += envelope_size;
5004 }
5005
5006 let next_out_of_line = decoder.next_out_of_line();
5007 let handles_before = decoder.remaining_handles();
5008 if let Some((inlined, num_bytes, num_handles)) =
5009 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5010 {
5011 let member_inline_size =
5012 <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5013 if inlined != (member_inline_size <= 4) {
5014 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5015 }
5016 let inner_offset;
5017 let mut inner_depth = depth.clone();
5018 if inlined {
5019 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5020 inner_offset = next_offset;
5021 } else {
5022 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5023 inner_depth.increment()?;
5024 }
5025 let val_ref =
5026 self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
5027 fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 4 {
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::encoding::UnboundedVector<u8> 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.sae_password.get_or_insert_with(|| {
5069 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5070 });
5071 fidl::decode!(
5072 fidl::encoding::UnboundedVector<u8>,
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 < 5 {
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 = <fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5107 if inlined != (member_inline_size <= 4) {
5108 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5109 }
5110 let inner_offset;
5111 let mut inner_depth = depth.clone();
5112 if inlined {
5113 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5114 inner_offset = next_offset;
5115 } else {
5116 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5117 inner_depth.increment()?;
5118 }
5119 let val_ref = self.wep_key.get_or_insert_with(|| {
5120 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanKeyConfig, D)
5121 });
5122 fidl::decode!(
5123 fidl_fuchsia_wlan_common__common::WlanKeyConfig,
5124 D,
5125 val_ref,
5126 decoder,
5127 inner_offset,
5128 inner_depth
5129 )?;
5130 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5131 {
5132 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5133 }
5134 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5135 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5136 }
5137 }
5138
5139 next_offset += envelope_size;
5140 _next_ordinal_to_read += 1;
5141 if next_offset >= end_offset {
5142 return Ok(());
5143 }
5144
5145 while _next_ordinal_to_read < 6 {
5147 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5148 _next_ordinal_to_read += 1;
5149 next_offset += envelope_size;
5150 }
5151
5152 let next_out_of_line = decoder.next_out_of_line();
5153 let handles_before = decoder.remaining_handles();
5154 if let Some((inlined, num_bytes, num_handles)) =
5155 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5156 {
5157 let member_inline_size =
5158 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
5159 decoder.context,
5160 );
5161 if inlined != (member_inline_size <= 4) {
5162 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5163 }
5164 let inner_offset;
5165 let mut inner_depth = depth.clone();
5166 if inlined {
5167 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5168 inner_offset = next_offset;
5169 } else {
5170 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5171 inner_depth.increment()?;
5172 }
5173 let val_ref = self
5174 .security_ie
5175 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
5176 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
5188 if next_offset >= end_offset {
5189 return Ok(());
5190 }
5191
5192 while _next_ordinal_to_read < 7 {
5194 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5195 _next_ordinal_to_read += 1;
5196 next_offset += envelope_size;
5197 }
5198
5199 let next_out_of_line = decoder.next_out_of_line();
5200 let handles_before = decoder.remaining_handles();
5201 if let Some((inlined, num_bytes, num_handles)) =
5202 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5203 {
5204 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5205 if inlined != (member_inline_size <= 4) {
5206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5207 }
5208 let inner_offset;
5209 let mut inner_depth = depth.clone();
5210 if inlined {
5211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5212 inner_offset = next_offset;
5213 } else {
5214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5215 inner_depth.increment()?;
5216 }
5217 let val_ref = self.wep_key_desc.get_or_insert_with(|| {
5218 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D)
5219 });
5220 fidl::decode!(
5221 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
5222 D,
5223 val_ref,
5224 decoder,
5225 inner_offset,
5226 inner_depth
5227 )?;
5228 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5229 {
5230 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5231 }
5232 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5233 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5234 }
5235 }
5236
5237 next_offset += envelope_size;
5238
5239 while next_offset < end_offset {
5241 _next_ordinal_to_read += 1;
5242 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5243 next_offset += envelope_size;
5244 }
5245
5246 Ok(())
5247 }
5248 }
5249
5250 impl WlanFullmacImplDeauthRequest {
5251 #[inline(always)]
5252 fn max_ordinal_present(&self) -> u64 {
5253 if let Some(_) = self.reason_code {
5254 return 2;
5255 }
5256 if let Some(_) = self.peer_sta_address {
5257 return 1;
5258 }
5259 0
5260 }
5261 }
5262
5263 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDeauthRequest {
5264 type Borrowed<'a> = &'a Self;
5265 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5266 value
5267 }
5268 }
5269
5270 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDeauthRequest {
5271 type Owned = Self;
5272
5273 #[inline(always)]
5274 fn inline_align(_context: fidl::encoding::Context) -> usize {
5275 8
5276 }
5277
5278 #[inline(always)]
5279 fn inline_size(_context: fidl::encoding::Context) -> usize {
5280 16
5281 }
5282 }
5283
5284 unsafe impl<D: fidl::encoding::ResourceDialect>
5285 fidl::encoding::Encode<WlanFullmacImplDeauthRequest, D> for &WlanFullmacImplDeauthRequest
5286 {
5287 unsafe fn encode(
5288 self,
5289 encoder: &mut fidl::encoding::Encoder<'_, D>,
5290 offset: usize,
5291 mut depth: fidl::encoding::Depth,
5292 ) -> fidl::Result<()> {
5293 encoder.debug_check_bounds::<WlanFullmacImplDeauthRequest>(offset);
5294 let max_ordinal: u64 = self.max_ordinal_present();
5296 encoder.write_num(max_ordinal, offset);
5297 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5298 if max_ordinal == 0 {
5300 return Ok(());
5301 }
5302 depth.increment()?;
5303 let envelope_size = 8;
5304 let bytes_len = max_ordinal as usize * envelope_size;
5305 #[allow(unused_variables)]
5306 let offset = encoder.out_of_line_offset(bytes_len);
5307 let mut _prev_end_offset: usize = 0;
5308 if 1 > max_ordinal {
5309 return Ok(());
5310 }
5311
5312 let cur_offset: usize = (1 - 1) * envelope_size;
5315
5316 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5318
5319 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5324 self.peer_sta_address
5325 .as_ref()
5326 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5327 encoder,
5328 offset + cur_offset,
5329 depth,
5330 )?;
5331
5332 _prev_end_offset = cur_offset + envelope_size;
5333 if 2 > max_ordinal {
5334 return Ok(());
5335 }
5336
5337 let cur_offset: usize = (2 - 1) * envelope_size;
5340
5341 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5349 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5350 encoder, offset + cur_offset, depth
5351 )?;
5352
5353 _prev_end_offset = cur_offset + envelope_size;
5354
5355 Ok(())
5356 }
5357 }
5358
5359 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5360 for WlanFullmacImplDeauthRequest
5361 {
5362 #[inline(always)]
5363 fn new_empty() -> Self {
5364 Self::default()
5365 }
5366
5367 unsafe fn decode(
5368 &mut self,
5369 decoder: &mut fidl::encoding::Decoder<'_, D>,
5370 offset: usize,
5371 mut depth: fidl::encoding::Depth,
5372 ) -> fidl::Result<()> {
5373 decoder.debug_check_bounds::<Self>(offset);
5374 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5375 None => return Err(fidl::Error::NotNullable),
5376 Some(len) => len,
5377 };
5378 if len == 0 {
5380 return Ok(());
5381 };
5382 depth.increment()?;
5383 let envelope_size = 8;
5384 let bytes_len = len * envelope_size;
5385 let offset = decoder.out_of_line_offset(bytes_len)?;
5386 let mut _next_ordinal_to_read = 0;
5388 let mut next_offset = offset;
5389 let end_offset = offset + bytes_len;
5390 _next_ordinal_to_read += 1;
5391 if next_offset >= end_offset {
5392 return Ok(());
5393 }
5394
5395 while _next_ordinal_to_read < 1 {
5397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5398 _next_ordinal_to_read += 1;
5399 next_offset += envelope_size;
5400 }
5401
5402 let next_out_of_line = decoder.next_out_of_line();
5403 let handles_before = decoder.remaining_handles();
5404 if let Some((inlined, num_bytes, num_handles)) =
5405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5406 {
5407 let member_inline_size =
5408 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5409 decoder.context,
5410 );
5411 if inlined != (member_inline_size <= 4) {
5412 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5413 }
5414 let inner_offset;
5415 let mut inner_depth = depth.clone();
5416 if inlined {
5417 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5418 inner_offset = next_offset;
5419 } else {
5420 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5421 inner_depth.increment()?;
5422 }
5423 let val_ref = self
5424 .peer_sta_address
5425 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5426 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
5438 if next_offset >= end_offset {
5439 return Ok(());
5440 }
5441
5442 while _next_ordinal_to_read < 2 {
5444 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5445 _next_ordinal_to_read += 1;
5446 next_offset += envelope_size;
5447 }
5448
5449 let next_out_of_line = decoder.next_out_of_line();
5450 let handles_before = decoder.remaining_handles();
5451 if let Some((inlined, num_bytes, num_handles)) =
5452 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5453 {
5454 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5455 if inlined != (member_inline_size <= 4) {
5456 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5457 }
5458 let inner_offset;
5459 let mut inner_depth = depth.clone();
5460 if inlined {
5461 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5462 inner_offset = next_offset;
5463 } else {
5464 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5465 inner_depth.increment()?;
5466 }
5467 let val_ref = self.reason_code.get_or_insert_with(|| {
5468 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5469 });
5470 fidl::decode!(
5471 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5472 D,
5473 val_ref,
5474 decoder,
5475 inner_offset,
5476 inner_depth
5477 )?;
5478 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5479 {
5480 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5481 }
5482 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5483 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5484 }
5485 }
5486
5487 next_offset += envelope_size;
5488
5489 while next_offset < end_offset {
5491 _next_ordinal_to_read += 1;
5492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5493 next_offset += envelope_size;
5494 }
5495
5496 Ok(())
5497 }
5498 }
5499
5500 impl WlanFullmacImplDisassocRequest {
5501 #[inline(always)]
5502 fn max_ordinal_present(&self) -> u64 {
5503 if let Some(_) = self.reason_code {
5504 return 2;
5505 }
5506 if let Some(_) = self.peer_sta_address {
5507 return 1;
5508 }
5509 0
5510 }
5511 }
5512
5513 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDisassocRequest {
5514 type Borrowed<'a> = &'a Self;
5515 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5516 value
5517 }
5518 }
5519
5520 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDisassocRequest {
5521 type Owned = Self;
5522
5523 #[inline(always)]
5524 fn inline_align(_context: fidl::encoding::Context) -> usize {
5525 8
5526 }
5527
5528 #[inline(always)]
5529 fn inline_size(_context: fidl::encoding::Context) -> usize {
5530 16
5531 }
5532 }
5533
5534 unsafe impl<D: fidl::encoding::ResourceDialect>
5535 fidl::encoding::Encode<WlanFullmacImplDisassocRequest, D>
5536 for &WlanFullmacImplDisassocRequest
5537 {
5538 unsafe fn encode(
5539 self,
5540 encoder: &mut fidl::encoding::Encoder<'_, D>,
5541 offset: usize,
5542 mut depth: fidl::encoding::Depth,
5543 ) -> fidl::Result<()> {
5544 encoder.debug_check_bounds::<WlanFullmacImplDisassocRequest>(offset);
5545 let max_ordinal: u64 = self.max_ordinal_present();
5547 encoder.write_num(max_ordinal, offset);
5548 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5549 if max_ordinal == 0 {
5551 return Ok(());
5552 }
5553 depth.increment()?;
5554 let envelope_size = 8;
5555 let bytes_len = max_ordinal as usize * envelope_size;
5556 #[allow(unused_variables)]
5557 let offset = encoder.out_of_line_offset(bytes_len);
5558 let mut _prev_end_offset: usize = 0;
5559 if 1 > max_ordinal {
5560 return Ok(());
5561 }
5562
5563 let cur_offset: usize = (1 - 1) * envelope_size;
5566
5567 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5569
5570 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5575 self.peer_sta_address
5576 .as_ref()
5577 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5578 encoder,
5579 offset + cur_offset,
5580 depth,
5581 )?;
5582
5583 _prev_end_offset = cur_offset + envelope_size;
5584 if 2 > max_ordinal {
5585 return Ok(());
5586 }
5587
5588 let cur_offset: usize = (2 - 1) * envelope_size;
5591
5592 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5594
5595 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5600 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5601 encoder, offset + cur_offset, depth
5602 )?;
5603
5604 _prev_end_offset = cur_offset + envelope_size;
5605
5606 Ok(())
5607 }
5608 }
5609
5610 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5611 for WlanFullmacImplDisassocRequest
5612 {
5613 #[inline(always)]
5614 fn new_empty() -> Self {
5615 Self::default()
5616 }
5617
5618 unsafe fn decode(
5619 &mut self,
5620 decoder: &mut fidl::encoding::Decoder<'_, D>,
5621 offset: usize,
5622 mut depth: fidl::encoding::Depth,
5623 ) -> fidl::Result<()> {
5624 decoder.debug_check_bounds::<Self>(offset);
5625 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5626 None => return Err(fidl::Error::NotNullable),
5627 Some(len) => len,
5628 };
5629 if len == 0 {
5631 return Ok(());
5632 };
5633 depth.increment()?;
5634 let envelope_size = 8;
5635 let bytes_len = len * envelope_size;
5636 let offset = decoder.out_of_line_offset(bytes_len)?;
5637 let mut _next_ordinal_to_read = 0;
5639 let mut next_offset = offset;
5640 let end_offset = offset + bytes_len;
5641 _next_ordinal_to_read += 1;
5642 if next_offset >= end_offset {
5643 return Ok(());
5644 }
5645
5646 while _next_ordinal_to_read < 1 {
5648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5649 _next_ordinal_to_read += 1;
5650 next_offset += envelope_size;
5651 }
5652
5653 let next_out_of_line = decoder.next_out_of_line();
5654 let handles_before = decoder.remaining_handles();
5655 if let Some((inlined, num_bytes, num_handles)) =
5656 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5657 {
5658 let member_inline_size =
5659 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5660 decoder.context,
5661 );
5662 if inlined != (member_inline_size <= 4) {
5663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5664 }
5665 let inner_offset;
5666 let mut inner_depth = depth.clone();
5667 if inlined {
5668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5669 inner_offset = next_offset;
5670 } else {
5671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5672 inner_depth.increment()?;
5673 }
5674 let val_ref = self
5675 .peer_sta_address
5676 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5677 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
5689 if next_offset >= end_offset {
5690 return Ok(());
5691 }
5692
5693 while _next_ordinal_to_read < 2 {
5695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5696 _next_ordinal_to_read += 1;
5697 next_offset += envelope_size;
5698 }
5699
5700 let next_out_of_line = decoder.next_out_of_line();
5701 let handles_before = decoder.remaining_handles();
5702 if let Some((inlined, num_bytes, num_handles)) =
5703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5704 {
5705 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5706 if inlined != (member_inline_size <= 4) {
5707 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5708 }
5709 let inner_offset;
5710 let mut inner_depth = depth.clone();
5711 if inlined {
5712 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5713 inner_offset = next_offset;
5714 } else {
5715 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5716 inner_depth.increment()?;
5717 }
5718 let val_ref = self.reason_code.get_or_insert_with(|| {
5719 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5720 });
5721 fidl::decode!(
5722 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5723 D,
5724 val_ref,
5725 decoder,
5726 inner_offset,
5727 inner_depth
5728 )?;
5729 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5730 {
5731 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5732 }
5733 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5734 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5735 }
5736 }
5737
5738 next_offset += envelope_size;
5739
5740 while next_offset < end_offset {
5742 _next_ordinal_to_read += 1;
5743 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5744 next_offset += envelope_size;
5745 }
5746
5747 Ok(())
5748 }
5749 }
5750
5751 impl WlanFullmacImplEapolTxRequest {
5752 #[inline(always)]
5753 fn max_ordinal_present(&self) -> u64 {
5754 if let Some(_) = self.data {
5755 return 3;
5756 }
5757 if let Some(_) = self.dst_addr {
5758 return 2;
5759 }
5760 if let Some(_) = self.src_addr {
5761 return 1;
5762 }
5763 0
5764 }
5765 }
5766
5767 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplEapolTxRequest {
5768 type Borrowed<'a> = &'a Self;
5769 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5770 value
5771 }
5772 }
5773
5774 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplEapolTxRequest {
5775 type Owned = Self;
5776
5777 #[inline(always)]
5778 fn inline_align(_context: fidl::encoding::Context) -> usize {
5779 8
5780 }
5781
5782 #[inline(always)]
5783 fn inline_size(_context: fidl::encoding::Context) -> usize {
5784 16
5785 }
5786 }
5787
5788 unsafe impl<D: fidl::encoding::ResourceDialect>
5789 fidl::encoding::Encode<WlanFullmacImplEapolTxRequest, D>
5790 for &WlanFullmacImplEapolTxRequest
5791 {
5792 unsafe fn encode(
5793 self,
5794 encoder: &mut fidl::encoding::Encoder<'_, D>,
5795 offset: usize,
5796 mut depth: fidl::encoding::Depth,
5797 ) -> fidl::Result<()> {
5798 encoder.debug_check_bounds::<WlanFullmacImplEapolTxRequest>(offset);
5799 let max_ordinal: u64 = self.max_ordinal_present();
5801 encoder.write_num(max_ordinal, offset);
5802 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5803 if max_ordinal == 0 {
5805 return Ok(());
5806 }
5807 depth.increment()?;
5808 let envelope_size = 8;
5809 let bytes_len = max_ordinal as usize * envelope_size;
5810 #[allow(unused_variables)]
5811 let offset = encoder.out_of_line_offset(bytes_len);
5812 let mut _prev_end_offset: usize = 0;
5813 if 1 > max_ordinal {
5814 return Ok(());
5815 }
5816
5817 let cur_offset: usize = (1 - 1) * envelope_size;
5820
5821 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5823
5824 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5829 self.src_addr
5830 .as_ref()
5831 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5832 encoder,
5833 offset + cur_offset,
5834 depth,
5835 )?;
5836
5837 _prev_end_offset = cur_offset + envelope_size;
5838 if 2 > max_ordinal {
5839 return Ok(());
5840 }
5841
5842 let cur_offset: usize = (2 - 1) * envelope_size;
5845
5846 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5848
5849 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5854 self.dst_addr
5855 .as_ref()
5856 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5857 encoder,
5858 offset + cur_offset,
5859 depth,
5860 )?;
5861
5862 _prev_end_offset = cur_offset + envelope_size;
5863 if 3 > max_ordinal {
5864 return Ok(());
5865 }
5866
5867 let cur_offset: usize = (3 - 1) * envelope_size;
5870
5871 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5873
5874 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
5879 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
5880 encoder, offset + cur_offset, depth
5881 )?;
5882
5883 _prev_end_offset = cur_offset + envelope_size;
5884
5885 Ok(())
5886 }
5887 }
5888
5889 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5890 for WlanFullmacImplEapolTxRequest
5891 {
5892 #[inline(always)]
5893 fn new_empty() -> Self {
5894 Self::default()
5895 }
5896
5897 unsafe fn decode(
5898 &mut self,
5899 decoder: &mut fidl::encoding::Decoder<'_, D>,
5900 offset: usize,
5901 mut depth: fidl::encoding::Depth,
5902 ) -> fidl::Result<()> {
5903 decoder.debug_check_bounds::<Self>(offset);
5904 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5905 None => return Err(fidl::Error::NotNullable),
5906 Some(len) => len,
5907 };
5908 if len == 0 {
5910 return Ok(());
5911 };
5912 depth.increment()?;
5913 let envelope_size = 8;
5914 let bytes_len = len * envelope_size;
5915 let offset = decoder.out_of_line_offset(bytes_len)?;
5916 let mut _next_ordinal_to_read = 0;
5918 let mut next_offset = offset;
5919 let end_offset = offset + bytes_len;
5920 _next_ordinal_to_read += 1;
5921 if next_offset >= end_offset {
5922 return Ok(());
5923 }
5924
5925 while _next_ordinal_to_read < 1 {
5927 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5928 _next_ordinal_to_read += 1;
5929 next_offset += envelope_size;
5930 }
5931
5932 let next_out_of_line = decoder.next_out_of_line();
5933 let handles_before = decoder.remaining_handles();
5934 if let Some((inlined, num_bytes, num_handles)) =
5935 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5936 {
5937 let member_inline_size =
5938 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5939 decoder.context,
5940 );
5941 if inlined != (member_inline_size <= 4) {
5942 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5943 }
5944 let inner_offset;
5945 let mut inner_depth = depth.clone();
5946 if inlined {
5947 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5948 inner_offset = next_offset;
5949 } else {
5950 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5951 inner_depth.increment()?;
5952 }
5953 let val_ref = self
5954 .src_addr
5955 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5956 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5958 {
5959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5960 }
5961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5963 }
5964 }
5965
5966 next_offset += envelope_size;
5967 _next_ordinal_to_read += 1;
5968 if next_offset >= end_offset {
5969 return Ok(());
5970 }
5971
5972 while _next_ordinal_to_read < 2 {
5974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5975 _next_ordinal_to_read += 1;
5976 next_offset += envelope_size;
5977 }
5978
5979 let next_out_of_line = decoder.next_out_of_line();
5980 let handles_before = decoder.remaining_handles();
5981 if let Some((inlined, num_bytes, num_handles)) =
5982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5983 {
5984 let member_inline_size =
5985 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5986 decoder.context,
5987 );
5988 if inlined != (member_inline_size <= 4) {
5989 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5990 }
5991 let inner_offset;
5992 let mut inner_depth = depth.clone();
5993 if inlined {
5994 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5995 inner_offset = next_offset;
5996 } else {
5997 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5998 inner_depth.increment()?;
5999 }
6000 let val_ref = self
6001 .dst_addr
6002 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6003 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
6015 if next_offset >= end_offset {
6016 return Ok(());
6017 }
6018
6019 while _next_ordinal_to_read < 3 {
6021 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6022 _next_ordinal_to_read += 1;
6023 next_offset += envelope_size;
6024 }
6025
6026 let next_out_of_line = decoder.next_out_of_line();
6027 let handles_before = decoder.remaining_handles();
6028 if let Some((inlined, num_bytes, num_handles)) =
6029 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6030 {
6031 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6032 if inlined != (member_inline_size <= 4) {
6033 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6034 }
6035 let inner_offset;
6036 let mut inner_depth = depth.clone();
6037 if inlined {
6038 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6039 inner_offset = next_offset;
6040 } else {
6041 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6042 inner_depth.increment()?;
6043 }
6044 let val_ref = self.data.get_or_insert_with(|| {
6045 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6046 });
6047 fidl::decode!(
6048 fidl::encoding::UnboundedVector<u8>,
6049 D,
6050 val_ref,
6051 decoder,
6052 inner_offset,
6053 inner_depth
6054 )?;
6055 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6056 {
6057 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6058 }
6059 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6060 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6061 }
6062 }
6063
6064 next_offset += envelope_size;
6065
6066 while next_offset < end_offset {
6068 _next_ordinal_to_read += 1;
6069 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6070 next_offset += envelope_size;
6071 }
6072
6073 Ok(())
6074 }
6075 }
6076
6077 impl WlanFullmacImplIfcAssocIndRequest {
6078 #[inline(always)]
6079 fn max_ordinal_present(&self) -> u64 {
6080 if let Some(_) = self.vendor_ie {
6081 return 5;
6082 }
6083 if let Some(_) = self.rsne {
6084 return 4;
6085 }
6086 if let Some(_) = self.ssid {
6087 return 3;
6088 }
6089 if let Some(_) = self.listen_interval {
6090 return 2;
6091 }
6092 if let Some(_) = self.peer_sta_address {
6093 return 1;
6094 }
6095 0
6096 }
6097 }
6098
6099 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAssocIndRequest {
6100 type Borrowed<'a> = &'a Self;
6101 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6102 value
6103 }
6104 }
6105
6106 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAssocIndRequest {
6107 type Owned = Self;
6108
6109 #[inline(always)]
6110 fn inline_align(_context: fidl::encoding::Context) -> usize {
6111 8
6112 }
6113
6114 #[inline(always)]
6115 fn inline_size(_context: fidl::encoding::Context) -> usize {
6116 16
6117 }
6118 }
6119
6120 unsafe impl<D: fidl::encoding::ResourceDialect>
6121 fidl::encoding::Encode<WlanFullmacImplIfcAssocIndRequest, D>
6122 for &WlanFullmacImplIfcAssocIndRequest
6123 {
6124 unsafe fn encode(
6125 self,
6126 encoder: &mut fidl::encoding::Encoder<'_, D>,
6127 offset: usize,
6128 mut depth: fidl::encoding::Depth,
6129 ) -> fidl::Result<()> {
6130 encoder.debug_check_bounds::<WlanFullmacImplIfcAssocIndRequest>(offset);
6131 let max_ordinal: u64 = self.max_ordinal_present();
6133 encoder.write_num(max_ordinal, offset);
6134 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6135 if max_ordinal == 0 {
6137 return Ok(());
6138 }
6139 depth.increment()?;
6140 let envelope_size = 8;
6141 let bytes_len = max_ordinal as usize * envelope_size;
6142 #[allow(unused_variables)]
6143 let offset = encoder.out_of_line_offset(bytes_len);
6144 let mut _prev_end_offset: usize = 0;
6145 if 1 > max_ordinal {
6146 return Ok(());
6147 }
6148
6149 let cur_offset: usize = (1 - 1) * envelope_size;
6152
6153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6155
6156 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6161 self.peer_sta_address
6162 .as_ref()
6163 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6164 encoder,
6165 offset + cur_offset,
6166 depth,
6167 )?;
6168
6169 _prev_end_offset = cur_offset + envelope_size;
6170 if 2 > max_ordinal {
6171 return Ok(());
6172 }
6173
6174 let cur_offset: usize = (2 - 1) * envelope_size;
6177
6178 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6180
6181 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6186 self.listen_interval.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6187 encoder,
6188 offset + cur_offset,
6189 depth,
6190 )?;
6191
6192 _prev_end_offset = cur_offset + envelope_size;
6193 if 3 > max_ordinal {
6194 return Ok(());
6195 }
6196
6197 let cur_offset: usize = (3 - 1) * envelope_size;
6200
6201 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6203
6204 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
6209 self.ssid.as_ref().map(
6210 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
6211 ),
6212 encoder,
6213 offset + cur_offset,
6214 depth,
6215 )?;
6216
6217 _prev_end_offset = cur_offset + envelope_size;
6218 if 4 > max_ordinal {
6219 return Ok(());
6220 }
6221
6222 let cur_offset: usize = (4 - 1) * envelope_size;
6225
6226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6228
6229 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
6234 self.rsne.as_ref().map(
6235 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
6236 ),
6237 encoder,
6238 offset + cur_offset,
6239 depth,
6240 )?;
6241
6242 _prev_end_offset = cur_offset + envelope_size;
6243 if 5 > max_ordinal {
6244 return Ok(());
6245 }
6246
6247 let cur_offset: usize = (5 - 1) * envelope_size;
6250
6251 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6253
6254 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
6259 self.vendor_ie.as_ref().map(
6260 <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
6261 ),
6262 encoder,
6263 offset + cur_offset,
6264 depth,
6265 )?;
6266
6267 _prev_end_offset = cur_offset + envelope_size;
6268
6269 Ok(())
6270 }
6271 }
6272
6273 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6274 for WlanFullmacImplIfcAssocIndRequest
6275 {
6276 #[inline(always)]
6277 fn new_empty() -> Self {
6278 Self::default()
6279 }
6280
6281 unsafe fn decode(
6282 &mut self,
6283 decoder: &mut fidl::encoding::Decoder<'_, D>,
6284 offset: usize,
6285 mut depth: fidl::encoding::Depth,
6286 ) -> fidl::Result<()> {
6287 decoder.debug_check_bounds::<Self>(offset);
6288 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6289 None => return Err(fidl::Error::NotNullable),
6290 Some(len) => len,
6291 };
6292 if len == 0 {
6294 return Ok(());
6295 };
6296 depth.increment()?;
6297 let envelope_size = 8;
6298 let bytes_len = len * envelope_size;
6299 let offset = decoder.out_of_line_offset(bytes_len)?;
6300 let mut _next_ordinal_to_read = 0;
6302 let mut next_offset = offset;
6303 let end_offset = offset + bytes_len;
6304 _next_ordinal_to_read += 1;
6305 if next_offset >= end_offset {
6306 return Ok(());
6307 }
6308
6309 while _next_ordinal_to_read < 1 {
6311 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6312 _next_ordinal_to_read += 1;
6313 next_offset += envelope_size;
6314 }
6315
6316 let next_out_of_line = decoder.next_out_of_line();
6317 let handles_before = decoder.remaining_handles();
6318 if let Some((inlined, num_bytes, num_handles)) =
6319 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6320 {
6321 let member_inline_size =
6322 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6323 decoder.context,
6324 );
6325 if inlined != (member_inline_size <= 4) {
6326 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6327 }
6328 let inner_offset;
6329 let mut inner_depth = depth.clone();
6330 if inlined {
6331 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6332 inner_offset = next_offset;
6333 } else {
6334 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6335 inner_depth.increment()?;
6336 }
6337 let val_ref = self
6338 .peer_sta_address
6339 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6340 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6341 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6342 {
6343 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6344 }
6345 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6346 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6347 }
6348 }
6349
6350 next_offset += envelope_size;
6351 _next_ordinal_to_read += 1;
6352 if next_offset >= end_offset {
6353 return Ok(());
6354 }
6355
6356 while _next_ordinal_to_read < 2 {
6358 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6359 _next_ordinal_to_read += 1;
6360 next_offset += envelope_size;
6361 }
6362
6363 let next_out_of_line = decoder.next_out_of_line();
6364 let handles_before = decoder.remaining_handles();
6365 if let Some((inlined, num_bytes, num_handles)) =
6366 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6367 {
6368 let member_inline_size =
6369 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6370 if inlined != (member_inline_size <= 4) {
6371 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6372 }
6373 let inner_offset;
6374 let mut inner_depth = depth.clone();
6375 if inlined {
6376 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6377 inner_offset = next_offset;
6378 } else {
6379 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6380 inner_depth.increment()?;
6381 }
6382 let val_ref = self.listen_interval.get_or_insert_with(|| fidl::new_empty!(u16, D));
6383 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6384 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6385 {
6386 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6387 }
6388 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6389 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6390 }
6391 }
6392
6393 next_offset += envelope_size;
6394 _next_ordinal_to_read += 1;
6395 if next_offset >= end_offset {
6396 return Ok(());
6397 }
6398
6399 while _next_ordinal_to_read < 3 {
6401 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6402 _next_ordinal_to_read += 1;
6403 next_offset += envelope_size;
6404 }
6405
6406 let next_out_of_line = decoder.next_out_of_line();
6407 let handles_before = decoder.remaining_handles();
6408 if let Some((inlined, num_bytes, num_handles)) =
6409 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6410 {
6411 let member_inline_size =
6412 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6413 decoder.context,
6414 );
6415 if inlined != (member_inline_size <= 4) {
6416 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6417 }
6418 let inner_offset;
6419 let mut inner_depth = depth.clone();
6420 if inlined {
6421 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6422 inner_offset = next_offset;
6423 } else {
6424 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6425 inner_depth.increment()?;
6426 }
6427 let val_ref = self
6428 .ssid
6429 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
6430 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6432 {
6433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6434 }
6435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6437 }
6438 }
6439
6440 next_offset += envelope_size;
6441 _next_ordinal_to_read += 1;
6442 if next_offset >= end_offset {
6443 return Ok(());
6444 }
6445
6446 while _next_ordinal_to_read < 4 {
6448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6449 _next_ordinal_to_read += 1;
6450 next_offset += envelope_size;
6451 }
6452
6453 let next_out_of_line = decoder.next_out_of_line();
6454 let handles_before = decoder.remaining_handles();
6455 if let Some((inlined, num_bytes, num_handles)) =
6456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6457 {
6458 let member_inline_size =
6459 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
6460 decoder.context,
6461 );
6462 if inlined != (member_inline_size <= 4) {
6463 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6464 }
6465 let inner_offset;
6466 let mut inner_depth = depth.clone();
6467 if inlined {
6468 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6469 inner_offset = next_offset;
6470 } else {
6471 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6472 inner_depth.increment()?;
6473 }
6474 let val_ref = self
6475 .rsne
6476 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
6477 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
6478 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6479 {
6480 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6481 }
6482 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6483 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6484 }
6485 }
6486
6487 next_offset += envelope_size;
6488 _next_ordinal_to_read += 1;
6489 if next_offset >= end_offset {
6490 return Ok(());
6491 }
6492
6493 while _next_ordinal_to_read < 5 {
6495 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6496 _next_ordinal_to_read += 1;
6497 next_offset += envelope_size;
6498 }
6499
6500 let next_out_of_line = decoder.next_out_of_line();
6501 let handles_before = decoder.remaining_handles();
6502 if let Some((inlined, num_bytes, num_handles)) =
6503 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6504 {
6505 let member_inline_size =
6506 <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
6507 decoder.context,
6508 );
6509 if inlined != (member_inline_size <= 4) {
6510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6511 }
6512 let inner_offset;
6513 let mut inner_depth = depth.clone();
6514 if inlined {
6515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6516 inner_offset = next_offset;
6517 } else {
6518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6519 inner_depth.increment()?;
6520 }
6521 let val_ref = self
6522 .vendor_ie
6523 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
6524 fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
6525 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6526 {
6527 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6528 }
6529 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6530 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6531 }
6532 }
6533
6534 next_offset += envelope_size;
6535
6536 while next_offset < end_offset {
6538 _next_ordinal_to_read += 1;
6539 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6540 next_offset += envelope_size;
6541 }
6542
6543 Ok(())
6544 }
6545 }
6546
6547 impl WlanFullmacImplIfcAuthIndRequest {
6548 #[inline(always)]
6549 fn max_ordinal_present(&self) -> u64 {
6550 if let Some(_) = self.auth_type {
6551 return 2;
6552 }
6553 if let Some(_) = self.peer_sta_address {
6554 return 1;
6555 }
6556 0
6557 }
6558 }
6559
6560 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAuthIndRequest {
6561 type Borrowed<'a> = &'a Self;
6562 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6563 value
6564 }
6565 }
6566
6567 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAuthIndRequest {
6568 type Owned = Self;
6569
6570 #[inline(always)]
6571 fn inline_align(_context: fidl::encoding::Context) -> usize {
6572 8
6573 }
6574
6575 #[inline(always)]
6576 fn inline_size(_context: fidl::encoding::Context) -> usize {
6577 16
6578 }
6579 }
6580
6581 unsafe impl<D: fidl::encoding::ResourceDialect>
6582 fidl::encoding::Encode<WlanFullmacImplIfcAuthIndRequest, D>
6583 for &WlanFullmacImplIfcAuthIndRequest
6584 {
6585 unsafe fn encode(
6586 self,
6587 encoder: &mut fidl::encoding::Encoder<'_, D>,
6588 offset: usize,
6589 mut depth: fidl::encoding::Depth,
6590 ) -> fidl::Result<()> {
6591 encoder.debug_check_bounds::<WlanFullmacImplIfcAuthIndRequest>(offset);
6592 let max_ordinal: u64 = self.max_ordinal_present();
6594 encoder.write_num(max_ordinal, offset);
6595 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6596 if max_ordinal == 0 {
6598 return Ok(());
6599 }
6600 depth.increment()?;
6601 let envelope_size = 8;
6602 let bytes_len = max_ordinal as usize * envelope_size;
6603 #[allow(unused_variables)]
6604 let offset = encoder.out_of_line_offset(bytes_len);
6605 let mut _prev_end_offset: usize = 0;
6606 if 1 > max_ordinal {
6607 return Ok(());
6608 }
6609
6610 let cur_offset: usize = (1 - 1) * envelope_size;
6613
6614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6616
6617 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6622 self.peer_sta_address
6623 .as_ref()
6624 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6625 encoder,
6626 offset + cur_offset,
6627 depth,
6628 )?;
6629
6630 _prev_end_offset = cur_offset + envelope_size;
6631 if 2 > max_ordinal {
6632 return Ok(());
6633 }
6634
6635 let cur_offset: usize = (2 - 1) * envelope_size;
6638
6639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6641
6642 fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
6647 self.auth_type
6648 .as_ref()
6649 .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
6650 encoder,
6651 offset + cur_offset,
6652 depth,
6653 )?;
6654
6655 _prev_end_offset = cur_offset + envelope_size;
6656
6657 Ok(())
6658 }
6659 }
6660
6661 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6662 for WlanFullmacImplIfcAuthIndRequest
6663 {
6664 #[inline(always)]
6665 fn new_empty() -> Self {
6666 Self::default()
6667 }
6668
6669 unsafe fn decode(
6670 &mut self,
6671 decoder: &mut fidl::encoding::Decoder<'_, D>,
6672 offset: usize,
6673 mut depth: fidl::encoding::Depth,
6674 ) -> fidl::Result<()> {
6675 decoder.debug_check_bounds::<Self>(offset);
6676 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6677 None => return Err(fidl::Error::NotNullable),
6678 Some(len) => len,
6679 };
6680 if len == 0 {
6682 return Ok(());
6683 };
6684 depth.increment()?;
6685 let envelope_size = 8;
6686 let bytes_len = len * envelope_size;
6687 let offset = decoder.out_of_line_offset(bytes_len)?;
6688 let mut _next_ordinal_to_read = 0;
6690 let mut next_offset = offset;
6691 let end_offset = offset + bytes_len;
6692 _next_ordinal_to_read += 1;
6693 if next_offset >= end_offset {
6694 return Ok(());
6695 }
6696
6697 while _next_ordinal_to_read < 1 {
6699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6700 _next_ordinal_to_read += 1;
6701 next_offset += envelope_size;
6702 }
6703
6704 let next_out_of_line = decoder.next_out_of_line();
6705 let handles_before = decoder.remaining_handles();
6706 if let Some((inlined, num_bytes, num_handles)) =
6707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6708 {
6709 let member_inline_size =
6710 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6711 decoder.context,
6712 );
6713 if inlined != (member_inline_size <= 4) {
6714 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6715 }
6716 let inner_offset;
6717 let mut inner_depth = depth.clone();
6718 if inlined {
6719 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6720 inner_offset = next_offset;
6721 } else {
6722 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6723 inner_depth.increment()?;
6724 }
6725 let val_ref = self
6726 .peer_sta_address
6727 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6728 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6729 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6730 {
6731 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6732 }
6733 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6734 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6735 }
6736 }
6737
6738 next_offset += envelope_size;
6739 _next_ordinal_to_read += 1;
6740 if next_offset >= end_offset {
6741 return Ok(());
6742 }
6743
6744 while _next_ordinal_to_read < 2 {
6746 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6747 _next_ordinal_to_read += 1;
6748 next_offset += envelope_size;
6749 }
6750
6751 let next_out_of_line = decoder.next_out_of_line();
6752 let handles_before = decoder.remaining_handles();
6753 if let Some((inlined, num_bytes, num_handles)) =
6754 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6755 {
6756 let member_inline_size =
6757 <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6758 if inlined != (member_inline_size <= 4) {
6759 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6760 }
6761 let inner_offset;
6762 let mut inner_depth = depth.clone();
6763 if inlined {
6764 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6765 inner_offset = next_offset;
6766 } else {
6767 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6768 inner_depth.increment()?;
6769 }
6770 let val_ref =
6771 self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
6772 fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
6773 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6774 {
6775 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6776 }
6777 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6778 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6779 }
6780 }
6781
6782 next_offset += envelope_size;
6783
6784 while next_offset < end_offset {
6786 _next_ordinal_to_read += 1;
6787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6788 next_offset += envelope_size;
6789 }
6790
6791 Ok(())
6792 }
6793 }
6794
6795 impl WlanFullmacImplIfcConnectConfRequest {
6796 #[inline(always)]
6797 fn max_ordinal_present(&self) -> u64 {
6798 if let Some(_) = self.association_ies {
6799 return 4;
6800 }
6801 if let Some(_) = self.association_id {
6802 return 3;
6803 }
6804 if let Some(_) = self.result_code {
6805 return 2;
6806 }
6807 if let Some(_) = self.peer_sta_address {
6808 return 1;
6809 }
6810 0
6811 }
6812 }
6813
6814 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcConnectConfRequest {
6815 type Borrowed<'a> = &'a Self;
6816 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6817 value
6818 }
6819 }
6820
6821 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcConnectConfRequest {
6822 type Owned = Self;
6823
6824 #[inline(always)]
6825 fn inline_align(_context: fidl::encoding::Context) -> usize {
6826 8
6827 }
6828
6829 #[inline(always)]
6830 fn inline_size(_context: fidl::encoding::Context) -> usize {
6831 16
6832 }
6833 }
6834
6835 unsafe impl<D: fidl::encoding::ResourceDialect>
6836 fidl::encoding::Encode<WlanFullmacImplIfcConnectConfRequest, D>
6837 for &WlanFullmacImplIfcConnectConfRequest
6838 {
6839 unsafe fn encode(
6840 self,
6841 encoder: &mut fidl::encoding::Encoder<'_, D>,
6842 offset: usize,
6843 mut depth: fidl::encoding::Depth,
6844 ) -> fidl::Result<()> {
6845 encoder.debug_check_bounds::<WlanFullmacImplIfcConnectConfRequest>(offset);
6846 let max_ordinal: u64 = self.max_ordinal_present();
6848 encoder.write_num(max_ordinal, offset);
6849 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6850 if max_ordinal == 0 {
6852 return Ok(());
6853 }
6854 depth.increment()?;
6855 let envelope_size = 8;
6856 let bytes_len = max_ordinal as usize * envelope_size;
6857 #[allow(unused_variables)]
6858 let offset = encoder.out_of_line_offset(bytes_len);
6859 let mut _prev_end_offset: usize = 0;
6860 if 1 > max_ordinal {
6861 return Ok(());
6862 }
6863
6864 let cur_offset: usize = (1 - 1) * envelope_size;
6867
6868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6876 self.peer_sta_address
6877 .as_ref()
6878 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6879 encoder,
6880 offset + cur_offset,
6881 depth,
6882 )?;
6883
6884 _prev_end_offset = cur_offset + envelope_size;
6885 if 2 > max_ordinal {
6886 return Ok(());
6887 }
6888
6889 let cur_offset: usize = (2 - 1) * envelope_size;
6892
6893 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6895
6896 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
6901 self.result_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
6902 encoder, offset + cur_offset, depth
6903 )?;
6904
6905 _prev_end_offset = cur_offset + envelope_size;
6906 if 3 > max_ordinal {
6907 return Ok(());
6908 }
6909
6910 let cur_offset: usize = (3 - 1) * envelope_size;
6913
6914 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6916
6917 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6922 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6923 encoder,
6924 offset + cur_offset,
6925 depth,
6926 )?;
6927
6928 _prev_end_offset = cur_offset + envelope_size;
6929 if 4 > max_ordinal {
6930 return Ok(());
6931 }
6932
6933 let cur_offset: usize = (4 - 1) * envelope_size;
6936
6937 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6939
6940 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6945 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6946 encoder, offset + cur_offset, depth
6947 )?;
6948
6949 _prev_end_offset = cur_offset + envelope_size;
6950
6951 Ok(())
6952 }
6953 }
6954
6955 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6956 for WlanFullmacImplIfcConnectConfRequest
6957 {
6958 #[inline(always)]
6959 fn new_empty() -> Self {
6960 Self::default()
6961 }
6962
6963 unsafe fn decode(
6964 &mut self,
6965 decoder: &mut fidl::encoding::Decoder<'_, D>,
6966 offset: usize,
6967 mut depth: fidl::encoding::Depth,
6968 ) -> fidl::Result<()> {
6969 decoder.debug_check_bounds::<Self>(offset);
6970 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6971 None => return Err(fidl::Error::NotNullable),
6972 Some(len) => len,
6973 };
6974 if len == 0 {
6976 return Ok(());
6977 };
6978 depth.increment()?;
6979 let envelope_size = 8;
6980 let bytes_len = len * envelope_size;
6981 let offset = decoder.out_of_line_offset(bytes_len)?;
6982 let mut _next_ordinal_to_read = 0;
6984 let mut next_offset = offset;
6985 let end_offset = offset + bytes_len;
6986 _next_ordinal_to_read += 1;
6987 if next_offset >= end_offset {
6988 return Ok(());
6989 }
6990
6991 while _next_ordinal_to_read < 1 {
6993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6994 _next_ordinal_to_read += 1;
6995 next_offset += envelope_size;
6996 }
6997
6998 let next_out_of_line = decoder.next_out_of_line();
6999 let handles_before = decoder.remaining_handles();
7000 if let Some((inlined, num_bytes, num_handles)) =
7001 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7002 {
7003 let member_inline_size =
7004 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7005 decoder.context,
7006 );
7007 if inlined != (member_inline_size <= 4) {
7008 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7009 }
7010 let inner_offset;
7011 let mut inner_depth = depth.clone();
7012 if inlined {
7013 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7014 inner_offset = next_offset;
7015 } else {
7016 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7017 inner_depth.increment()?;
7018 }
7019 let val_ref = self
7020 .peer_sta_address
7021 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7022 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7051 if inlined != (member_inline_size <= 4) {
7052 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7053 }
7054 let inner_offset;
7055 let mut inner_depth = depth.clone();
7056 if inlined {
7057 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7058 inner_offset = next_offset;
7059 } else {
7060 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7061 inner_depth.increment()?;
7062 }
7063 let val_ref = self.result_code.get_or_insert_with(|| {
7064 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
7065 });
7066 fidl::decode!(
7067 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
7068 D,
7069 val_ref,
7070 decoder,
7071 inner_offset,
7072 inner_depth
7073 )?;
7074 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7075 {
7076 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7077 }
7078 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7079 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7080 }
7081 }
7082
7083 next_offset += envelope_size;
7084 _next_ordinal_to_read += 1;
7085 if next_offset >= end_offset {
7086 return Ok(());
7087 }
7088
7089 while _next_ordinal_to_read < 3 {
7091 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7092 _next_ordinal_to_read += 1;
7093 next_offset += envelope_size;
7094 }
7095
7096 let next_out_of_line = decoder.next_out_of_line();
7097 let handles_before = decoder.remaining_handles();
7098 if let Some((inlined, num_bytes, num_handles)) =
7099 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7100 {
7101 let member_inline_size =
7102 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7103 if inlined != (member_inline_size <= 4) {
7104 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7105 }
7106 let inner_offset;
7107 let mut inner_depth = depth.clone();
7108 if inlined {
7109 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7110 inner_offset = next_offset;
7111 } else {
7112 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7113 inner_depth.increment()?;
7114 }
7115 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
7116 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
7128 if next_offset >= end_offset {
7129 return Ok(());
7130 }
7131
7132 while _next_ordinal_to_read < 4 {
7134 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7135 _next_ordinal_to_read += 1;
7136 next_offset += envelope_size;
7137 }
7138
7139 let next_out_of_line = decoder.next_out_of_line();
7140 let handles_before = decoder.remaining_handles();
7141 if let Some((inlined, num_bytes, num_handles)) =
7142 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7143 {
7144 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7145 if inlined != (member_inline_size <= 4) {
7146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7147 }
7148 let inner_offset;
7149 let mut inner_depth = depth.clone();
7150 if inlined {
7151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7152 inner_offset = next_offset;
7153 } else {
7154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7155 inner_depth.increment()?;
7156 }
7157 let val_ref = self.association_ies.get_or_insert_with(|| {
7158 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
7159 });
7160 fidl::decode!(
7161 fidl::encoding::UnboundedVector<u8>,
7162 D,
7163 val_ref,
7164 decoder,
7165 inner_offset,
7166 inner_depth
7167 )?;
7168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7169 {
7170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7171 }
7172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7174 }
7175 }
7176
7177 next_offset += envelope_size;
7178
7179 while next_offset < end_offset {
7181 _next_ordinal_to_read += 1;
7182 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7183 next_offset += envelope_size;
7184 }
7185
7186 Ok(())
7187 }
7188 }
7189
7190 impl WlanFullmacImplIfcDeauthConfRequest {
7191 #[inline(always)]
7192 fn max_ordinal_present(&self) -> u64 {
7193 if let Some(_) = self.peer_sta_address {
7194 return 1;
7195 }
7196 0
7197 }
7198 }
7199
7200 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7201 type Borrowed<'a> = &'a Self;
7202 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7203 value
7204 }
7205 }
7206
7207 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7208 type Owned = Self;
7209
7210 #[inline(always)]
7211 fn inline_align(_context: fidl::encoding::Context) -> usize {
7212 8
7213 }
7214
7215 #[inline(always)]
7216 fn inline_size(_context: fidl::encoding::Context) -> usize {
7217 16
7218 }
7219 }
7220
7221 unsafe impl<D: fidl::encoding::ResourceDialect>
7222 fidl::encoding::Encode<WlanFullmacImplIfcDeauthConfRequest, D>
7223 for &WlanFullmacImplIfcDeauthConfRequest
7224 {
7225 unsafe fn encode(
7226 self,
7227 encoder: &mut fidl::encoding::Encoder<'_, D>,
7228 offset: usize,
7229 mut depth: fidl::encoding::Depth,
7230 ) -> fidl::Result<()> {
7231 encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthConfRequest>(offset);
7232 let max_ordinal: u64 = self.max_ordinal_present();
7234 encoder.write_num(max_ordinal, offset);
7235 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7236 if max_ordinal == 0 {
7238 return Ok(());
7239 }
7240 depth.increment()?;
7241 let envelope_size = 8;
7242 let bytes_len = max_ordinal as usize * envelope_size;
7243 #[allow(unused_variables)]
7244 let offset = encoder.out_of_line_offset(bytes_len);
7245 let mut _prev_end_offset: usize = 0;
7246 if 1 > max_ordinal {
7247 return Ok(());
7248 }
7249
7250 let cur_offset: usize = (1 - 1) * envelope_size;
7253
7254 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7256
7257 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7262 self.peer_sta_address
7263 .as_ref()
7264 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7265 encoder,
7266 offset + cur_offset,
7267 depth,
7268 )?;
7269
7270 _prev_end_offset = cur_offset + envelope_size;
7271
7272 Ok(())
7273 }
7274 }
7275
7276 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7277 for WlanFullmacImplIfcDeauthConfRequest
7278 {
7279 #[inline(always)]
7280 fn new_empty() -> Self {
7281 Self::default()
7282 }
7283
7284 unsafe fn decode(
7285 &mut self,
7286 decoder: &mut fidl::encoding::Decoder<'_, D>,
7287 offset: usize,
7288 mut depth: fidl::encoding::Depth,
7289 ) -> fidl::Result<()> {
7290 decoder.debug_check_bounds::<Self>(offset);
7291 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7292 None => return Err(fidl::Error::NotNullable),
7293 Some(len) => len,
7294 };
7295 if len == 0 {
7297 return Ok(());
7298 };
7299 depth.increment()?;
7300 let envelope_size = 8;
7301 let bytes_len = len * envelope_size;
7302 let offset = decoder.out_of_line_offset(bytes_len)?;
7303 let mut _next_ordinal_to_read = 0;
7305 let mut next_offset = offset;
7306 let end_offset = offset + bytes_len;
7307 _next_ordinal_to_read += 1;
7308 if next_offset >= end_offset {
7309 return Ok(());
7310 }
7311
7312 while _next_ordinal_to_read < 1 {
7314 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7315 _next_ordinal_to_read += 1;
7316 next_offset += envelope_size;
7317 }
7318
7319 let next_out_of_line = decoder.next_out_of_line();
7320 let handles_before = decoder.remaining_handles();
7321 if let Some((inlined, num_bytes, num_handles)) =
7322 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7323 {
7324 let member_inline_size =
7325 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7326 decoder.context,
7327 );
7328 if inlined != (member_inline_size <= 4) {
7329 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7330 }
7331 let inner_offset;
7332 let mut inner_depth = depth.clone();
7333 if inlined {
7334 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7335 inner_offset = next_offset;
7336 } else {
7337 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7338 inner_depth.increment()?;
7339 }
7340 let val_ref = self
7341 .peer_sta_address
7342 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7343 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7344 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7345 {
7346 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7347 }
7348 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7349 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7350 }
7351 }
7352
7353 next_offset += envelope_size;
7354
7355 while next_offset < end_offset {
7357 _next_ordinal_to_read += 1;
7358 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7359 next_offset += envelope_size;
7360 }
7361
7362 Ok(())
7363 }
7364 }
7365
7366 impl WlanFullmacImplIfcDeauthIndRequest {
7367 #[inline(always)]
7368 fn max_ordinal_present(&self) -> u64 {
7369 if let Some(_) = self.locally_initiated {
7370 return 3;
7371 }
7372 if let Some(_) = self.reason_code {
7373 return 2;
7374 }
7375 if let Some(_) = self.peer_sta_address {
7376 return 1;
7377 }
7378 0
7379 }
7380 }
7381
7382 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7383 type Borrowed<'a> = &'a Self;
7384 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7385 value
7386 }
7387 }
7388
7389 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7390 type Owned = Self;
7391
7392 #[inline(always)]
7393 fn inline_align(_context: fidl::encoding::Context) -> usize {
7394 8
7395 }
7396
7397 #[inline(always)]
7398 fn inline_size(_context: fidl::encoding::Context) -> usize {
7399 16
7400 }
7401 }
7402
7403 unsafe impl<D: fidl::encoding::ResourceDialect>
7404 fidl::encoding::Encode<WlanFullmacImplIfcDeauthIndRequest, D>
7405 for &WlanFullmacImplIfcDeauthIndRequest
7406 {
7407 unsafe fn encode(
7408 self,
7409 encoder: &mut fidl::encoding::Encoder<'_, D>,
7410 offset: usize,
7411 mut depth: fidl::encoding::Depth,
7412 ) -> fidl::Result<()> {
7413 encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthIndRequest>(offset);
7414 let max_ordinal: u64 = self.max_ordinal_present();
7416 encoder.write_num(max_ordinal, offset);
7417 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7418 if max_ordinal == 0 {
7420 return Ok(());
7421 }
7422 depth.increment()?;
7423 let envelope_size = 8;
7424 let bytes_len = max_ordinal as usize * envelope_size;
7425 #[allow(unused_variables)]
7426 let offset = encoder.out_of_line_offset(bytes_len);
7427 let mut _prev_end_offset: usize = 0;
7428 if 1 > max_ordinal {
7429 return Ok(());
7430 }
7431
7432 let cur_offset: usize = (1 - 1) * envelope_size;
7435
7436 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7438
7439 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7444 self.peer_sta_address
7445 .as_ref()
7446 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7447 encoder,
7448 offset + cur_offset,
7449 depth,
7450 )?;
7451
7452 _prev_end_offset = cur_offset + envelope_size;
7453 if 2 > max_ordinal {
7454 return Ok(());
7455 }
7456
7457 let cur_offset: usize = (2 - 1) * envelope_size;
7460
7461 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7463
7464 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7469 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7470 encoder, offset + cur_offset, depth
7471 )?;
7472
7473 _prev_end_offset = cur_offset + envelope_size;
7474 if 3 > max_ordinal {
7475 return Ok(());
7476 }
7477
7478 let cur_offset: usize = (3 - 1) * envelope_size;
7481
7482 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7484
7485 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7490 self.locally_initiated
7491 .as_ref()
7492 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7493 encoder,
7494 offset + cur_offset,
7495 depth,
7496 )?;
7497
7498 _prev_end_offset = cur_offset + envelope_size;
7499
7500 Ok(())
7501 }
7502 }
7503
7504 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7505 for WlanFullmacImplIfcDeauthIndRequest
7506 {
7507 #[inline(always)]
7508 fn new_empty() -> Self {
7509 Self::default()
7510 }
7511
7512 unsafe fn decode(
7513 &mut self,
7514 decoder: &mut fidl::encoding::Decoder<'_, D>,
7515 offset: usize,
7516 mut depth: fidl::encoding::Depth,
7517 ) -> fidl::Result<()> {
7518 decoder.debug_check_bounds::<Self>(offset);
7519 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7520 None => return Err(fidl::Error::NotNullable),
7521 Some(len) => len,
7522 };
7523 if len == 0 {
7525 return Ok(());
7526 };
7527 depth.increment()?;
7528 let envelope_size = 8;
7529 let bytes_len = len * envelope_size;
7530 let offset = decoder.out_of_line_offset(bytes_len)?;
7531 let mut _next_ordinal_to_read = 0;
7533 let mut next_offset = offset;
7534 let end_offset = offset + bytes_len;
7535 _next_ordinal_to_read += 1;
7536 if next_offset >= end_offset {
7537 return Ok(());
7538 }
7539
7540 while _next_ordinal_to_read < 1 {
7542 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7543 _next_ordinal_to_read += 1;
7544 next_offset += envelope_size;
7545 }
7546
7547 let next_out_of_line = decoder.next_out_of_line();
7548 let handles_before = decoder.remaining_handles();
7549 if let Some((inlined, num_bytes, num_handles)) =
7550 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7551 {
7552 let member_inline_size =
7553 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7554 decoder.context,
7555 );
7556 if inlined != (member_inline_size <= 4) {
7557 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7558 }
7559 let inner_offset;
7560 let mut inner_depth = depth.clone();
7561 if inlined {
7562 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7563 inner_offset = next_offset;
7564 } else {
7565 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7566 inner_depth.increment()?;
7567 }
7568 let val_ref = self
7569 .peer_sta_address
7570 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7571 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7600 if inlined != (member_inline_size <= 4) {
7601 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7602 }
7603 let inner_offset;
7604 let mut inner_depth = depth.clone();
7605 if inlined {
7606 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7607 inner_offset = next_offset;
7608 } else {
7609 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7610 inner_depth.increment()?;
7611 }
7612 let val_ref = self.reason_code.get_or_insert_with(|| {
7613 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
7614 });
7615 fidl::decode!(
7616 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
7617 D,
7618 val_ref,
7619 decoder,
7620 inner_offset,
7621 inner_depth
7622 )?;
7623 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7624 {
7625 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7626 }
7627 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7628 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7629 }
7630 }
7631
7632 next_offset += envelope_size;
7633 _next_ordinal_to_read += 1;
7634 if next_offset >= end_offset {
7635 return Ok(());
7636 }
7637
7638 while _next_ordinal_to_read < 3 {
7640 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7641 _next_ordinal_to_read += 1;
7642 next_offset += envelope_size;
7643 }
7644
7645 let next_out_of_line = decoder.next_out_of_line();
7646 let handles_before = decoder.remaining_handles();
7647 if let Some((inlined, num_bytes, num_handles)) =
7648 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7649 {
7650 let member_inline_size =
7651 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7652 if inlined != (member_inline_size <= 4) {
7653 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7654 }
7655 let inner_offset;
7656 let mut inner_depth = depth.clone();
7657 if inlined {
7658 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7659 inner_offset = next_offset;
7660 } else {
7661 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7662 inner_depth.increment()?;
7663 }
7664 let val_ref =
7665 self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
7666 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7667 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7668 {
7669 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7670 }
7671 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7672 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7673 }
7674 }
7675
7676 next_offset += envelope_size;
7677
7678 while next_offset < end_offset {
7680 _next_ordinal_to_read += 1;
7681 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7682 next_offset += envelope_size;
7683 }
7684
7685 Ok(())
7686 }
7687 }
7688
7689 impl WlanFullmacImplIfcDisassocConfRequest {
7690 #[inline(always)]
7691 fn max_ordinal_present(&self) -> u64 {
7692 if let Some(_) = self.status {
7693 return 1;
7694 }
7695 0
7696 }
7697 }
7698
7699 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7700 type Borrowed<'a> = &'a Self;
7701 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7702 value
7703 }
7704 }
7705
7706 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7707 type Owned = Self;
7708
7709 #[inline(always)]
7710 fn inline_align(_context: fidl::encoding::Context) -> usize {
7711 8
7712 }
7713
7714 #[inline(always)]
7715 fn inline_size(_context: fidl::encoding::Context) -> usize {
7716 16
7717 }
7718 }
7719
7720 unsafe impl<D: fidl::encoding::ResourceDialect>
7721 fidl::encoding::Encode<WlanFullmacImplIfcDisassocConfRequest, D>
7722 for &WlanFullmacImplIfcDisassocConfRequest
7723 {
7724 unsafe fn encode(
7725 self,
7726 encoder: &mut fidl::encoding::Encoder<'_, D>,
7727 offset: usize,
7728 mut depth: fidl::encoding::Depth,
7729 ) -> fidl::Result<()> {
7730 encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocConfRequest>(offset);
7731 let max_ordinal: u64 = self.max_ordinal_present();
7733 encoder.write_num(max_ordinal, offset);
7734 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7735 if max_ordinal == 0 {
7737 return Ok(());
7738 }
7739 depth.increment()?;
7740 let envelope_size = 8;
7741 let bytes_len = max_ordinal as usize * envelope_size;
7742 #[allow(unused_variables)]
7743 let offset = encoder.out_of_line_offset(bytes_len);
7744 let mut _prev_end_offset: usize = 0;
7745 if 1 > max_ordinal {
7746 return Ok(());
7747 }
7748
7749 let cur_offset: usize = (1 - 1) * envelope_size;
7752
7753 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7755
7756 fidl::encoding::encode_in_envelope_optional::<i32, D>(
7761 self.status.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
7762 encoder,
7763 offset + cur_offset,
7764 depth,
7765 )?;
7766
7767 _prev_end_offset = cur_offset + envelope_size;
7768
7769 Ok(())
7770 }
7771 }
7772
7773 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7774 for WlanFullmacImplIfcDisassocConfRequest
7775 {
7776 #[inline(always)]
7777 fn new_empty() -> Self {
7778 Self::default()
7779 }
7780
7781 unsafe fn decode(
7782 &mut self,
7783 decoder: &mut fidl::encoding::Decoder<'_, D>,
7784 offset: usize,
7785 mut depth: fidl::encoding::Depth,
7786 ) -> fidl::Result<()> {
7787 decoder.debug_check_bounds::<Self>(offset);
7788 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7789 None => return Err(fidl::Error::NotNullable),
7790 Some(len) => len,
7791 };
7792 if len == 0 {
7794 return Ok(());
7795 };
7796 depth.increment()?;
7797 let envelope_size = 8;
7798 let bytes_len = len * envelope_size;
7799 let offset = decoder.out_of_line_offset(bytes_len)?;
7800 let mut _next_ordinal_to_read = 0;
7802 let mut next_offset = offset;
7803 let end_offset = offset + bytes_len;
7804 _next_ordinal_to_read += 1;
7805 if next_offset >= end_offset {
7806 return Ok(());
7807 }
7808
7809 while _next_ordinal_to_read < 1 {
7811 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7812 _next_ordinal_to_read += 1;
7813 next_offset += envelope_size;
7814 }
7815
7816 let next_out_of_line = decoder.next_out_of_line();
7817 let handles_before = decoder.remaining_handles();
7818 if let Some((inlined, num_bytes, num_handles)) =
7819 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7820 {
7821 let member_inline_size =
7822 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7823 if inlined != (member_inline_size <= 4) {
7824 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7825 }
7826 let inner_offset;
7827 let mut inner_depth = depth.clone();
7828 if inlined {
7829 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7830 inner_offset = next_offset;
7831 } else {
7832 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7833 inner_depth.increment()?;
7834 }
7835 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(i32, D));
7836 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
7837 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7838 {
7839 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7840 }
7841 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7842 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7843 }
7844 }
7845
7846 next_offset += envelope_size;
7847
7848 while next_offset < end_offset {
7850 _next_ordinal_to_read += 1;
7851 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7852 next_offset += envelope_size;
7853 }
7854
7855 Ok(())
7856 }
7857 }
7858
7859 impl WlanFullmacImplIfcDisassocIndRequest {
7860 #[inline(always)]
7861 fn max_ordinal_present(&self) -> u64 {
7862 if let Some(_) = self.locally_initiated {
7863 return 3;
7864 }
7865 if let Some(_) = self.reason_code {
7866 return 2;
7867 }
7868 if let Some(_) = self.peer_sta_address {
7869 return 1;
7870 }
7871 0
7872 }
7873 }
7874
7875 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7876 type Borrowed<'a> = &'a Self;
7877 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7878 value
7879 }
7880 }
7881
7882 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7883 type Owned = Self;
7884
7885 #[inline(always)]
7886 fn inline_align(_context: fidl::encoding::Context) -> usize {
7887 8
7888 }
7889
7890 #[inline(always)]
7891 fn inline_size(_context: fidl::encoding::Context) -> usize {
7892 16
7893 }
7894 }
7895
7896 unsafe impl<D: fidl::encoding::ResourceDialect>
7897 fidl::encoding::Encode<WlanFullmacImplIfcDisassocIndRequest, D>
7898 for &WlanFullmacImplIfcDisassocIndRequest
7899 {
7900 unsafe fn encode(
7901 self,
7902 encoder: &mut fidl::encoding::Encoder<'_, D>,
7903 offset: usize,
7904 mut depth: fidl::encoding::Depth,
7905 ) -> fidl::Result<()> {
7906 encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocIndRequest>(offset);
7907 let max_ordinal: u64 = self.max_ordinal_present();
7909 encoder.write_num(max_ordinal, offset);
7910 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7911 if max_ordinal == 0 {
7913 return Ok(());
7914 }
7915 depth.increment()?;
7916 let envelope_size = 8;
7917 let bytes_len = max_ordinal as usize * envelope_size;
7918 #[allow(unused_variables)]
7919 let offset = encoder.out_of_line_offset(bytes_len);
7920 let mut _prev_end_offset: usize = 0;
7921 if 1 > max_ordinal {
7922 return Ok(());
7923 }
7924
7925 let cur_offset: usize = (1 - 1) * envelope_size;
7928
7929 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7931
7932 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7937 self.peer_sta_address
7938 .as_ref()
7939 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7940 encoder,
7941 offset + cur_offset,
7942 depth,
7943 )?;
7944
7945 _prev_end_offset = cur_offset + envelope_size;
7946 if 2 > max_ordinal {
7947 return Ok(());
7948 }
7949
7950 let cur_offset: usize = (2 - 1) * envelope_size;
7953
7954 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7956
7957 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7962 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7963 encoder, offset + cur_offset, depth
7964 )?;
7965
7966 _prev_end_offset = cur_offset + envelope_size;
7967 if 3 > max_ordinal {
7968 return Ok(());
7969 }
7970
7971 let cur_offset: usize = (3 - 1) * envelope_size;
7974
7975 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7977
7978 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7983 self.locally_initiated
7984 .as_ref()
7985 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7986 encoder,
7987 offset + cur_offset,
7988 depth,
7989 )?;
7990
7991 _prev_end_offset = cur_offset + envelope_size;
7992
7993 Ok(())
7994 }
7995 }
7996
7997 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7998 for WlanFullmacImplIfcDisassocIndRequest
7999 {
8000 #[inline(always)]
8001 fn new_empty() -> Self {
8002 Self::default()
8003 }
8004
8005 unsafe fn decode(
8006 &mut self,
8007 decoder: &mut fidl::encoding::Decoder<'_, D>,
8008 offset: usize,
8009 mut depth: fidl::encoding::Depth,
8010 ) -> fidl::Result<()> {
8011 decoder.debug_check_bounds::<Self>(offset);
8012 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8013 None => return Err(fidl::Error::NotNullable),
8014 Some(len) => len,
8015 };
8016 if len == 0 {
8018 return Ok(());
8019 };
8020 depth.increment()?;
8021 let envelope_size = 8;
8022 let bytes_len = len * envelope_size;
8023 let offset = decoder.out_of_line_offset(bytes_len)?;
8024 let mut _next_ordinal_to_read = 0;
8026 let mut next_offset = offset;
8027 let end_offset = offset + bytes_len;
8028 _next_ordinal_to_read += 1;
8029 if next_offset >= end_offset {
8030 return Ok(());
8031 }
8032
8033 while _next_ordinal_to_read < 1 {
8035 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8036 _next_ordinal_to_read += 1;
8037 next_offset += envelope_size;
8038 }
8039
8040 let next_out_of_line = decoder.next_out_of_line();
8041 let handles_before = decoder.remaining_handles();
8042 if let Some((inlined, num_bytes, num_handles)) =
8043 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8044 {
8045 let member_inline_size =
8046 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8047 decoder.context,
8048 );
8049 if inlined != (member_inline_size <= 4) {
8050 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8051 }
8052 let inner_offset;
8053 let mut inner_depth = depth.clone();
8054 if inlined {
8055 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8056 inner_offset = next_offset;
8057 } else {
8058 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8059 inner_depth.increment()?;
8060 }
8061 let val_ref = self
8062 .peer_sta_address
8063 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8064 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8093 if inlined != (member_inline_size <= 4) {
8094 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8095 }
8096 let inner_offset;
8097 let mut inner_depth = depth.clone();
8098 if inlined {
8099 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8100 inner_offset = next_offset;
8101 } else {
8102 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8103 inner_depth.increment()?;
8104 }
8105 let val_ref = self.reason_code.get_or_insert_with(|| {
8106 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
8107 });
8108 fidl::decode!(
8109 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
8110 D,
8111 val_ref,
8112 decoder,
8113 inner_offset,
8114 inner_depth
8115 )?;
8116 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8117 {
8118 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8119 }
8120 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8121 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8122 }
8123 }
8124
8125 next_offset += envelope_size;
8126 _next_ordinal_to_read += 1;
8127 if next_offset >= end_offset {
8128 return Ok(());
8129 }
8130
8131 while _next_ordinal_to_read < 3 {
8133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8134 _next_ordinal_to_read += 1;
8135 next_offset += envelope_size;
8136 }
8137
8138 let next_out_of_line = decoder.next_out_of_line();
8139 let handles_before = decoder.remaining_handles();
8140 if let Some((inlined, num_bytes, num_handles)) =
8141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8142 {
8143 let member_inline_size =
8144 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8145 if inlined != (member_inline_size <= 4) {
8146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8147 }
8148 let inner_offset;
8149 let mut inner_depth = depth.clone();
8150 if inlined {
8151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8152 inner_offset = next_offset;
8153 } else {
8154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8155 inner_depth.increment()?;
8156 }
8157 let val_ref =
8158 self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
8159 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8160 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8161 {
8162 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8163 }
8164 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8165 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8166 }
8167 }
8168
8169 next_offset += envelope_size;
8170
8171 while next_offset < end_offset {
8173 _next_ordinal_to_read += 1;
8174 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8175 next_offset += envelope_size;
8176 }
8177
8178 Ok(())
8179 }
8180 }
8181
8182 impl WlanFullmacImplIfcEapolConfRequest {
8183 #[inline(always)]
8184 fn max_ordinal_present(&self) -> u64 {
8185 if let Some(_) = self.dst_addr {
8186 return 2;
8187 }
8188 if let Some(_) = self.result_code {
8189 return 1;
8190 }
8191 0
8192 }
8193 }
8194
8195 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolConfRequest {
8196 type Borrowed<'a> = &'a Self;
8197 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8198 value
8199 }
8200 }
8201
8202 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolConfRequest {
8203 type Owned = Self;
8204
8205 #[inline(always)]
8206 fn inline_align(_context: fidl::encoding::Context) -> usize {
8207 8
8208 }
8209
8210 #[inline(always)]
8211 fn inline_size(_context: fidl::encoding::Context) -> usize {
8212 16
8213 }
8214 }
8215
8216 unsafe impl<D: fidl::encoding::ResourceDialect>
8217 fidl::encoding::Encode<WlanFullmacImplIfcEapolConfRequest, D>
8218 for &WlanFullmacImplIfcEapolConfRequest
8219 {
8220 unsafe fn encode(
8221 self,
8222 encoder: &mut fidl::encoding::Encoder<'_, D>,
8223 offset: usize,
8224 mut depth: fidl::encoding::Depth,
8225 ) -> fidl::Result<()> {
8226 encoder.debug_check_bounds::<WlanFullmacImplIfcEapolConfRequest>(offset);
8227 let max_ordinal: u64 = self.max_ordinal_present();
8229 encoder.write_num(max_ordinal, offset);
8230 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8231 if max_ordinal == 0 {
8233 return Ok(());
8234 }
8235 depth.increment()?;
8236 let envelope_size = 8;
8237 let bytes_len = max_ordinal as usize * envelope_size;
8238 #[allow(unused_variables)]
8239 let offset = encoder.out_of_line_offset(bytes_len);
8240 let mut _prev_end_offset: usize = 0;
8241 if 1 > max_ordinal {
8242 return Ok(());
8243 }
8244
8245 let cur_offset: usize = (1 - 1) * envelope_size;
8248
8249 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8251
8252 fidl::encoding::encode_in_envelope_optional::<EapolTxResult, D>(
8257 self.result_code
8258 .as_ref()
8259 .map(<EapolTxResult as fidl::encoding::ValueTypeMarker>::borrow),
8260 encoder,
8261 offset + cur_offset,
8262 depth,
8263 )?;
8264
8265 _prev_end_offset = cur_offset + envelope_size;
8266 if 2 > max_ordinal {
8267 return Ok(());
8268 }
8269
8270 let cur_offset: usize = (2 - 1) * envelope_size;
8273
8274 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8276
8277 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8282 self.dst_addr
8283 .as_ref()
8284 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8285 encoder,
8286 offset + cur_offset,
8287 depth,
8288 )?;
8289
8290 _prev_end_offset = cur_offset + envelope_size;
8291
8292 Ok(())
8293 }
8294 }
8295
8296 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8297 for WlanFullmacImplIfcEapolConfRequest
8298 {
8299 #[inline(always)]
8300 fn new_empty() -> Self {
8301 Self::default()
8302 }
8303
8304 unsafe fn decode(
8305 &mut self,
8306 decoder: &mut fidl::encoding::Decoder<'_, D>,
8307 offset: usize,
8308 mut depth: fidl::encoding::Depth,
8309 ) -> fidl::Result<()> {
8310 decoder.debug_check_bounds::<Self>(offset);
8311 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8312 None => return Err(fidl::Error::NotNullable),
8313 Some(len) => len,
8314 };
8315 if len == 0 {
8317 return Ok(());
8318 };
8319 depth.increment()?;
8320 let envelope_size = 8;
8321 let bytes_len = len * envelope_size;
8322 let offset = decoder.out_of_line_offset(bytes_len)?;
8323 let mut _next_ordinal_to_read = 0;
8325 let mut next_offset = offset;
8326 let end_offset = offset + bytes_len;
8327 _next_ordinal_to_read += 1;
8328 if next_offset >= end_offset {
8329 return Ok(());
8330 }
8331
8332 while _next_ordinal_to_read < 1 {
8334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8335 _next_ordinal_to_read += 1;
8336 next_offset += envelope_size;
8337 }
8338
8339 let next_out_of_line = decoder.next_out_of_line();
8340 let handles_before = decoder.remaining_handles();
8341 if let Some((inlined, num_bytes, num_handles)) =
8342 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8343 {
8344 let member_inline_size =
8345 <EapolTxResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8346 if inlined != (member_inline_size <= 4) {
8347 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8348 }
8349 let inner_offset;
8350 let mut inner_depth = depth.clone();
8351 if inlined {
8352 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8353 inner_offset = next_offset;
8354 } else {
8355 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8356 inner_depth.increment()?;
8357 }
8358 let val_ref =
8359 self.result_code.get_or_insert_with(|| fidl::new_empty!(EapolTxResult, D));
8360 fidl::decode!(EapolTxResult, D, val_ref, decoder, inner_offset, inner_depth)?;
8361 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8362 {
8363 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8364 }
8365 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8366 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8367 }
8368 }
8369
8370 next_offset += envelope_size;
8371 _next_ordinal_to_read += 1;
8372 if next_offset >= end_offset {
8373 return Ok(());
8374 }
8375
8376 while _next_ordinal_to_read < 2 {
8378 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8379 _next_ordinal_to_read += 1;
8380 next_offset += envelope_size;
8381 }
8382
8383 let next_out_of_line = decoder.next_out_of_line();
8384 let handles_before = decoder.remaining_handles();
8385 if let Some((inlined, num_bytes, num_handles)) =
8386 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8387 {
8388 let member_inline_size =
8389 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8390 decoder.context,
8391 );
8392 if inlined != (member_inline_size <= 4) {
8393 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8394 }
8395 let inner_offset;
8396 let mut inner_depth = depth.clone();
8397 if inlined {
8398 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8399 inner_offset = next_offset;
8400 } else {
8401 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8402 inner_depth.increment()?;
8403 }
8404 let val_ref = self
8405 .dst_addr
8406 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8407 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8408 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8409 {
8410 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8411 }
8412 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8413 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8414 }
8415 }
8416
8417 next_offset += envelope_size;
8418
8419 while next_offset < end_offset {
8421 _next_ordinal_to_read += 1;
8422 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8423 next_offset += envelope_size;
8424 }
8425
8426 Ok(())
8427 }
8428 }
8429
8430 impl WlanFullmacImplIfcEapolIndRequest {
8431 #[inline(always)]
8432 fn max_ordinal_present(&self) -> u64 {
8433 if let Some(_) = self.data {
8434 return 3;
8435 }
8436 if let Some(_) = self.dst_addr {
8437 return 2;
8438 }
8439 if let Some(_) = self.src_addr {
8440 return 1;
8441 }
8442 0
8443 }
8444 }
8445
8446 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolIndRequest {
8447 type Borrowed<'a> = &'a Self;
8448 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8449 value
8450 }
8451 }
8452
8453 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolIndRequest {
8454 type Owned = Self;
8455
8456 #[inline(always)]
8457 fn inline_align(_context: fidl::encoding::Context) -> usize {
8458 8
8459 }
8460
8461 #[inline(always)]
8462 fn inline_size(_context: fidl::encoding::Context) -> usize {
8463 16
8464 }
8465 }
8466
8467 unsafe impl<D: fidl::encoding::ResourceDialect>
8468 fidl::encoding::Encode<WlanFullmacImplIfcEapolIndRequest, D>
8469 for &WlanFullmacImplIfcEapolIndRequest
8470 {
8471 unsafe fn encode(
8472 self,
8473 encoder: &mut fidl::encoding::Encoder<'_, D>,
8474 offset: usize,
8475 mut depth: fidl::encoding::Depth,
8476 ) -> fidl::Result<()> {
8477 encoder.debug_check_bounds::<WlanFullmacImplIfcEapolIndRequest>(offset);
8478 let max_ordinal: u64 = self.max_ordinal_present();
8480 encoder.write_num(max_ordinal, offset);
8481 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8482 if max_ordinal == 0 {
8484 return Ok(());
8485 }
8486 depth.increment()?;
8487 let envelope_size = 8;
8488 let bytes_len = max_ordinal as usize * envelope_size;
8489 #[allow(unused_variables)]
8490 let offset = encoder.out_of_line_offset(bytes_len);
8491 let mut _prev_end_offset: usize = 0;
8492 if 1 > max_ordinal {
8493 return Ok(());
8494 }
8495
8496 let cur_offset: usize = (1 - 1) * envelope_size;
8499
8500 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8502
8503 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8508 self.src_addr
8509 .as_ref()
8510 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8511 encoder,
8512 offset + cur_offset,
8513 depth,
8514 )?;
8515
8516 _prev_end_offset = cur_offset + envelope_size;
8517 if 2 > max_ordinal {
8518 return Ok(());
8519 }
8520
8521 let cur_offset: usize = (2 - 1) * envelope_size;
8524
8525 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8527
8528 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8533 self.dst_addr
8534 .as_ref()
8535 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8536 encoder,
8537 offset + cur_offset,
8538 depth,
8539 )?;
8540
8541 _prev_end_offset = cur_offset + envelope_size;
8542 if 3 > max_ordinal {
8543 return Ok(());
8544 }
8545
8546 let cur_offset: usize = (3 - 1) * envelope_size;
8549
8550 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8552
8553 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8558 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8559 encoder, offset + cur_offset, depth
8560 )?;
8561
8562 _prev_end_offset = cur_offset + envelope_size;
8563
8564 Ok(())
8565 }
8566 }
8567
8568 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8569 for WlanFullmacImplIfcEapolIndRequest
8570 {
8571 #[inline(always)]
8572 fn new_empty() -> Self {
8573 Self::default()
8574 }
8575
8576 unsafe fn decode(
8577 &mut self,
8578 decoder: &mut fidl::encoding::Decoder<'_, D>,
8579 offset: usize,
8580 mut depth: fidl::encoding::Depth,
8581 ) -> fidl::Result<()> {
8582 decoder.debug_check_bounds::<Self>(offset);
8583 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8584 None => return Err(fidl::Error::NotNullable),
8585 Some(len) => len,
8586 };
8587 if len == 0 {
8589 return Ok(());
8590 };
8591 depth.increment()?;
8592 let envelope_size = 8;
8593 let bytes_len = len * envelope_size;
8594 let offset = decoder.out_of_line_offset(bytes_len)?;
8595 let mut _next_ordinal_to_read = 0;
8597 let mut next_offset = offset;
8598 let end_offset = offset + bytes_len;
8599 _next_ordinal_to_read += 1;
8600 if next_offset >= end_offset {
8601 return Ok(());
8602 }
8603
8604 while _next_ordinal_to_read < 1 {
8606 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8607 _next_ordinal_to_read += 1;
8608 next_offset += envelope_size;
8609 }
8610
8611 let next_out_of_line = decoder.next_out_of_line();
8612 let handles_before = decoder.remaining_handles();
8613 if let Some((inlined, num_bytes, num_handles)) =
8614 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8615 {
8616 let member_inline_size =
8617 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8618 decoder.context,
8619 );
8620 if inlined != (member_inline_size <= 4) {
8621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8622 }
8623 let inner_offset;
8624 let mut inner_depth = depth.clone();
8625 if inlined {
8626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8627 inner_offset = next_offset;
8628 } else {
8629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8630 inner_depth.increment()?;
8631 }
8632 let val_ref = self
8633 .src_addr
8634 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8635 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8636 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8637 {
8638 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8639 }
8640 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8641 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8642 }
8643 }
8644
8645 next_offset += envelope_size;
8646 _next_ordinal_to_read += 1;
8647 if next_offset >= end_offset {
8648 return Ok(());
8649 }
8650
8651 while _next_ordinal_to_read < 2 {
8653 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8654 _next_ordinal_to_read += 1;
8655 next_offset += envelope_size;
8656 }
8657
8658 let next_out_of_line = decoder.next_out_of_line();
8659 let handles_before = decoder.remaining_handles();
8660 if let Some((inlined, num_bytes, num_handles)) =
8661 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8662 {
8663 let member_inline_size =
8664 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8665 decoder.context,
8666 );
8667 if inlined != (member_inline_size <= 4) {
8668 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8669 }
8670 let inner_offset;
8671 let mut inner_depth = depth.clone();
8672 if inlined {
8673 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8674 inner_offset = next_offset;
8675 } else {
8676 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8677 inner_depth.increment()?;
8678 }
8679 let val_ref = self
8680 .dst_addr
8681 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8682 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
8694 if next_offset >= end_offset {
8695 return Ok(());
8696 }
8697
8698 while _next_ordinal_to_read < 3 {
8700 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8701 _next_ordinal_to_read += 1;
8702 next_offset += envelope_size;
8703 }
8704
8705 let next_out_of_line = decoder.next_out_of_line();
8706 let handles_before = decoder.remaining_handles();
8707 if let Some((inlined, num_bytes, num_handles)) =
8708 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8709 {
8710 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8711 if inlined != (member_inline_size <= 4) {
8712 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8713 }
8714 let inner_offset;
8715 let mut inner_depth = depth.clone();
8716 if inlined {
8717 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8718 inner_offset = next_offset;
8719 } else {
8720 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8721 inner_depth.increment()?;
8722 }
8723 let val_ref = self.data.get_or_insert_with(|| {
8724 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8725 });
8726 fidl::decode!(
8727 fidl::encoding::UnboundedVector<u8>,
8728 D,
8729 val_ref,
8730 decoder,
8731 inner_offset,
8732 inner_depth
8733 )?;
8734 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8735 {
8736 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8737 }
8738 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8739 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8740 }
8741 }
8742
8743 next_offset += envelope_size;
8744
8745 while next_offset < end_offset {
8747 _next_ordinal_to_read += 1;
8748 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8749 next_offset += envelope_size;
8750 }
8751
8752 Ok(())
8753 }
8754 }
8755
8756 impl WlanFullmacImplIfcOnPmkAvailableRequest {
8757 #[inline(always)]
8758 fn max_ordinal_present(&self) -> u64 {
8759 if let Some(_) = self.pmkid {
8760 return 2;
8761 }
8762 if let Some(_) = self.pmk {
8763 return 1;
8764 }
8765 0
8766 }
8767 }
8768
8769 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8770 type Borrowed<'a> = &'a Self;
8771 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8772 value
8773 }
8774 }
8775
8776 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8777 type Owned = Self;
8778
8779 #[inline(always)]
8780 fn inline_align(_context: fidl::encoding::Context) -> usize {
8781 8
8782 }
8783
8784 #[inline(always)]
8785 fn inline_size(_context: fidl::encoding::Context) -> usize {
8786 16
8787 }
8788 }
8789
8790 unsafe impl<D: fidl::encoding::ResourceDialect>
8791 fidl::encoding::Encode<WlanFullmacImplIfcOnPmkAvailableRequest, D>
8792 for &WlanFullmacImplIfcOnPmkAvailableRequest
8793 {
8794 unsafe fn encode(
8795 self,
8796 encoder: &mut fidl::encoding::Encoder<'_, D>,
8797 offset: usize,
8798 mut depth: fidl::encoding::Depth,
8799 ) -> fidl::Result<()> {
8800 encoder.debug_check_bounds::<WlanFullmacImplIfcOnPmkAvailableRequest>(offset);
8801 let max_ordinal: u64 = self.max_ordinal_present();
8803 encoder.write_num(max_ordinal, offset);
8804 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8805 if max_ordinal == 0 {
8807 return Ok(());
8808 }
8809 depth.increment()?;
8810 let envelope_size = 8;
8811 let bytes_len = max_ordinal as usize * envelope_size;
8812 #[allow(unused_variables)]
8813 let offset = encoder.out_of_line_offset(bytes_len);
8814 let mut _prev_end_offset: usize = 0;
8815 if 1 > max_ordinal {
8816 return Ok(());
8817 }
8818
8819 let cur_offset: usize = (1 - 1) * envelope_size;
8822
8823 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8825
8826 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8831 self.pmk.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8832 encoder, offset + cur_offset, depth
8833 )?;
8834
8835 _prev_end_offset = cur_offset + envelope_size;
8836 if 2 > max_ordinal {
8837 return Ok(());
8838 }
8839
8840 let cur_offset: usize = (2 - 1) * envelope_size;
8843
8844 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8846
8847 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8852 self.pmkid.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8853 encoder, offset + cur_offset, depth
8854 )?;
8855
8856 _prev_end_offset = cur_offset + envelope_size;
8857
8858 Ok(())
8859 }
8860 }
8861
8862 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8863 for WlanFullmacImplIfcOnPmkAvailableRequest
8864 {
8865 #[inline(always)]
8866 fn new_empty() -> Self {
8867 Self::default()
8868 }
8869
8870 unsafe fn decode(
8871 &mut self,
8872 decoder: &mut fidl::encoding::Decoder<'_, D>,
8873 offset: usize,
8874 mut depth: fidl::encoding::Depth,
8875 ) -> fidl::Result<()> {
8876 decoder.debug_check_bounds::<Self>(offset);
8877 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8878 None => return Err(fidl::Error::NotNullable),
8879 Some(len) => len,
8880 };
8881 if len == 0 {
8883 return Ok(());
8884 };
8885 depth.increment()?;
8886 let envelope_size = 8;
8887 let bytes_len = len * envelope_size;
8888 let offset = decoder.out_of_line_offset(bytes_len)?;
8889 let mut _next_ordinal_to_read = 0;
8891 let mut next_offset = offset;
8892 let end_offset = offset + bytes_len;
8893 _next_ordinal_to_read += 1;
8894 if next_offset >= end_offset {
8895 return Ok(());
8896 }
8897
8898 while _next_ordinal_to_read < 1 {
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.pmk.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 _next_ordinal_to_read += 1;
8945 if next_offset >= end_offset {
8946 return Ok(());
8947 }
8948
8949 while _next_ordinal_to_read < 2 {
8951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8952 _next_ordinal_to_read += 1;
8953 next_offset += envelope_size;
8954 }
8955
8956 let next_out_of_line = decoder.next_out_of_line();
8957 let handles_before = decoder.remaining_handles();
8958 if let Some((inlined, num_bytes, num_handles)) =
8959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8960 {
8961 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8962 if inlined != (member_inline_size <= 4) {
8963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8964 }
8965 let inner_offset;
8966 let mut inner_depth = depth.clone();
8967 if inlined {
8968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8969 inner_offset = next_offset;
8970 } else {
8971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8972 inner_depth.increment()?;
8973 }
8974 let val_ref = self.pmkid.get_or_insert_with(|| {
8975 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8976 });
8977 fidl::decode!(
8978 fidl::encoding::UnboundedVector<u8>,
8979 D,
8980 val_ref,
8981 decoder,
8982 inner_offset,
8983 inner_depth
8984 )?;
8985 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8986 {
8987 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8988 }
8989 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8990 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8991 }
8992 }
8993
8994 next_offset += envelope_size;
8995
8996 while next_offset < end_offset {
8998 _next_ordinal_to_read += 1;
8999 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9000 next_offset += envelope_size;
9001 }
9002
9003 Ok(())
9004 }
9005 }
9006
9007 impl WlanFullmacImplIfcOnScanEndRequest {
9008 #[inline(always)]
9009 fn max_ordinal_present(&self) -> u64 {
9010 if let Some(_) = self.code {
9011 return 2;
9012 }
9013 if let Some(_) = self.txn_id {
9014 return 1;
9015 }
9016 0
9017 }
9018 }
9019
9020 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanEndRequest {
9021 type Borrowed<'a> = &'a Self;
9022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9023 value
9024 }
9025 }
9026
9027 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanEndRequest {
9028 type Owned = Self;
9029
9030 #[inline(always)]
9031 fn inline_align(_context: fidl::encoding::Context) -> usize {
9032 8
9033 }
9034
9035 #[inline(always)]
9036 fn inline_size(_context: fidl::encoding::Context) -> usize {
9037 16
9038 }
9039 }
9040
9041 unsafe impl<D: fidl::encoding::ResourceDialect>
9042 fidl::encoding::Encode<WlanFullmacImplIfcOnScanEndRequest, D>
9043 for &WlanFullmacImplIfcOnScanEndRequest
9044 {
9045 unsafe fn encode(
9046 self,
9047 encoder: &mut fidl::encoding::Encoder<'_, D>,
9048 offset: usize,
9049 mut depth: fidl::encoding::Depth,
9050 ) -> fidl::Result<()> {
9051 encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanEndRequest>(offset);
9052 let max_ordinal: u64 = self.max_ordinal_present();
9054 encoder.write_num(max_ordinal, offset);
9055 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9056 if max_ordinal == 0 {
9058 return Ok(());
9059 }
9060 depth.increment()?;
9061 let envelope_size = 8;
9062 let bytes_len = max_ordinal as usize * envelope_size;
9063 #[allow(unused_variables)]
9064 let offset = encoder.out_of_line_offset(bytes_len);
9065 let mut _prev_end_offset: usize = 0;
9066 if 1 > max_ordinal {
9067 return Ok(());
9068 }
9069
9070 let cur_offset: usize = (1 - 1) * envelope_size;
9073
9074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9076
9077 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9082 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9083 encoder,
9084 offset + cur_offset,
9085 depth,
9086 )?;
9087
9088 _prev_end_offset = cur_offset + envelope_size;
9089 if 2 > max_ordinal {
9090 return Ok(());
9091 }
9092
9093 let cur_offset: usize = (2 - 1) * envelope_size;
9096
9097 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9099
9100 fidl::encoding::encode_in_envelope_optional::<WlanScanResult, D>(
9105 self.code.as_ref().map(<WlanScanResult as fidl::encoding::ValueTypeMarker>::borrow),
9106 encoder,
9107 offset + cur_offset,
9108 depth,
9109 )?;
9110
9111 _prev_end_offset = cur_offset + envelope_size;
9112
9113 Ok(())
9114 }
9115 }
9116
9117 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9118 for WlanFullmacImplIfcOnScanEndRequest
9119 {
9120 #[inline(always)]
9121 fn new_empty() -> Self {
9122 Self::default()
9123 }
9124
9125 unsafe fn decode(
9126 &mut self,
9127 decoder: &mut fidl::encoding::Decoder<'_, D>,
9128 offset: usize,
9129 mut depth: fidl::encoding::Depth,
9130 ) -> fidl::Result<()> {
9131 decoder.debug_check_bounds::<Self>(offset);
9132 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9133 None => return Err(fidl::Error::NotNullable),
9134 Some(len) => len,
9135 };
9136 if len == 0 {
9138 return Ok(());
9139 };
9140 depth.increment()?;
9141 let envelope_size = 8;
9142 let bytes_len = len * envelope_size;
9143 let offset = decoder.out_of_line_offset(bytes_len)?;
9144 let mut _next_ordinal_to_read = 0;
9146 let mut next_offset = offset;
9147 let end_offset = offset + bytes_len;
9148 _next_ordinal_to_read += 1;
9149 if next_offset >= end_offset {
9150 return Ok(());
9151 }
9152
9153 while _next_ordinal_to_read < 1 {
9155 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9156 _next_ordinal_to_read += 1;
9157 next_offset += envelope_size;
9158 }
9159
9160 let next_out_of_line = decoder.next_out_of_line();
9161 let handles_before = decoder.remaining_handles();
9162 if let Some((inlined, num_bytes, num_handles)) =
9163 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9164 {
9165 let member_inline_size =
9166 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9167 if inlined != (member_inline_size <= 4) {
9168 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9169 }
9170 let inner_offset;
9171 let mut inner_depth = depth.clone();
9172 if inlined {
9173 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9174 inner_offset = next_offset;
9175 } else {
9176 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9177 inner_depth.increment()?;
9178 }
9179 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9180 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9181 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9182 {
9183 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9184 }
9185 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9186 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9187 }
9188 }
9189
9190 next_offset += envelope_size;
9191 _next_ordinal_to_read += 1;
9192 if next_offset >= end_offset {
9193 return Ok(());
9194 }
9195
9196 while _next_ordinal_to_read < 2 {
9198 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9199 _next_ordinal_to_read += 1;
9200 next_offset += envelope_size;
9201 }
9202
9203 let next_out_of_line = decoder.next_out_of_line();
9204 let handles_before = decoder.remaining_handles();
9205 if let Some((inlined, num_bytes, num_handles)) =
9206 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9207 {
9208 let member_inline_size =
9209 <WlanScanResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9210 if inlined != (member_inline_size <= 4) {
9211 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9212 }
9213 let inner_offset;
9214 let mut inner_depth = depth.clone();
9215 if inlined {
9216 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9217 inner_offset = next_offset;
9218 } else {
9219 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9220 inner_depth.increment()?;
9221 }
9222 let val_ref = self.code.get_or_insert_with(|| fidl::new_empty!(WlanScanResult, D));
9223 fidl::decode!(WlanScanResult, D, val_ref, decoder, inner_offset, inner_depth)?;
9224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9225 {
9226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9227 }
9228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9230 }
9231 }
9232
9233 next_offset += envelope_size;
9234
9235 while next_offset < end_offset {
9237 _next_ordinal_to_read += 1;
9238 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9239 next_offset += envelope_size;
9240 }
9241
9242 Ok(())
9243 }
9244 }
9245
9246 impl WlanFullmacImplIfcOnScanResultRequest {
9247 #[inline(always)]
9248 fn max_ordinal_present(&self) -> u64 {
9249 if let Some(_) = self.bss {
9250 return 3;
9251 }
9252 if let Some(_) = self.timestamp_nanos {
9253 return 2;
9254 }
9255 if let Some(_) = self.txn_id {
9256 return 1;
9257 }
9258 0
9259 }
9260 }
9261
9262 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9263 type Borrowed<'a> = &'a Self;
9264 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9265 value
9266 }
9267 }
9268
9269 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9270 type Owned = Self;
9271
9272 #[inline(always)]
9273 fn inline_align(_context: fidl::encoding::Context) -> usize {
9274 8
9275 }
9276
9277 #[inline(always)]
9278 fn inline_size(_context: fidl::encoding::Context) -> usize {
9279 16
9280 }
9281 }
9282
9283 unsafe impl<D: fidl::encoding::ResourceDialect>
9284 fidl::encoding::Encode<WlanFullmacImplIfcOnScanResultRequest, D>
9285 for &WlanFullmacImplIfcOnScanResultRequest
9286 {
9287 unsafe fn encode(
9288 self,
9289 encoder: &mut fidl::encoding::Encoder<'_, D>,
9290 offset: usize,
9291 mut depth: fidl::encoding::Depth,
9292 ) -> fidl::Result<()> {
9293 encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanResultRequest>(offset);
9294 let max_ordinal: u64 = self.max_ordinal_present();
9296 encoder.write_num(max_ordinal, offset);
9297 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9298 if max_ordinal == 0 {
9300 return Ok(());
9301 }
9302 depth.increment()?;
9303 let envelope_size = 8;
9304 let bytes_len = max_ordinal as usize * envelope_size;
9305 #[allow(unused_variables)]
9306 let offset = encoder.out_of_line_offset(bytes_len);
9307 let mut _prev_end_offset: usize = 0;
9308 if 1 > max_ordinal {
9309 return Ok(());
9310 }
9311
9312 let cur_offset: usize = (1 - 1) * envelope_size;
9315
9316 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9318
9319 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9324 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9325 encoder,
9326 offset + cur_offset,
9327 depth,
9328 )?;
9329
9330 _prev_end_offset = cur_offset + envelope_size;
9331 if 2 > max_ordinal {
9332 return Ok(());
9333 }
9334
9335 let cur_offset: usize = (2 - 1) * envelope_size;
9338
9339 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9341
9342 fidl::encoding::encode_in_envelope_optional::<i64, D>(
9347 self.timestamp_nanos.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9348 encoder,
9349 offset + cur_offset,
9350 depth,
9351 )?;
9352
9353 _prev_end_offset = cur_offset + envelope_size;
9354 if 3 > max_ordinal {
9355 return Ok(());
9356 }
9357
9358 let cur_offset: usize = (3 - 1) * envelope_size;
9361
9362 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9364
9365 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
9370 self.bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
9371 encoder, offset + cur_offset, depth
9372 )?;
9373
9374 _prev_end_offset = cur_offset + envelope_size;
9375
9376 Ok(())
9377 }
9378 }
9379
9380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9381 for WlanFullmacImplIfcOnScanResultRequest
9382 {
9383 #[inline(always)]
9384 fn new_empty() -> Self {
9385 Self::default()
9386 }
9387
9388 unsafe fn decode(
9389 &mut self,
9390 decoder: &mut fidl::encoding::Decoder<'_, D>,
9391 offset: usize,
9392 mut depth: fidl::encoding::Depth,
9393 ) -> fidl::Result<()> {
9394 decoder.debug_check_bounds::<Self>(offset);
9395 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9396 None => return Err(fidl::Error::NotNullable),
9397 Some(len) => len,
9398 };
9399 if len == 0 {
9401 return Ok(());
9402 };
9403 depth.increment()?;
9404 let envelope_size = 8;
9405 let bytes_len = len * envelope_size;
9406 let offset = decoder.out_of_line_offset(bytes_len)?;
9407 let mut _next_ordinal_to_read = 0;
9409 let mut next_offset = offset;
9410 let end_offset = offset + bytes_len;
9411 _next_ordinal_to_read += 1;
9412 if next_offset >= end_offset {
9413 return Ok(());
9414 }
9415
9416 while _next_ordinal_to_read < 1 {
9418 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9419 _next_ordinal_to_read += 1;
9420 next_offset += envelope_size;
9421 }
9422
9423 let next_out_of_line = decoder.next_out_of_line();
9424 let handles_before = decoder.remaining_handles();
9425 if let Some((inlined, num_bytes, num_handles)) =
9426 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9427 {
9428 let member_inline_size =
9429 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9430 if inlined != (member_inline_size <= 4) {
9431 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9432 }
9433 let inner_offset;
9434 let mut inner_depth = depth.clone();
9435 if inlined {
9436 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9437 inner_offset = next_offset;
9438 } else {
9439 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9440 inner_depth.increment()?;
9441 }
9442 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9443 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9444 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9445 {
9446 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9447 }
9448 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9449 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9450 }
9451 }
9452
9453 next_offset += envelope_size;
9454 _next_ordinal_to_read += 1;
9455 if next_offset >= end_offset {
9456 return Ok(());
9457 }
9458
9459 while _next_ordinal_to_read < 2 {
9461 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9462 _next_ordinal_to_read += 1;
9463 next_offset += envelope_size;
9464 }
9465
9466 let next_out_of_line = decoder.next_out_of_line();
9467 let handles_before = decoder.remaining_handles();
9468 if let Some((inlined, num_bytes, num_handles)) =
9469 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9470 {
9471 let member_inline_size =
9472 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9473 if inlined != (member_inline_size <= 4) {
9474 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9475 }
9476 let inner_offset;
9477 let mut inner_depth = depth.clone();
9478 if inlined {
9479 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9480 inner_offset = next_offset;
9481 } else {
9482 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9483 inner_depth.increment()?;
9484 }
9485 let val_ref = self.timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(i64, D));
9486 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
9498 if next_offset >= end_offset {
9499 return Ok(());
9500 }
9501
9502 while _next_ordinal_to_read < 3 {
9504 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9505 _next_ordinal_to_read += 1;
9506 next_offset += envelope_size;
9507 }
9508
9509 let next_out_of_line = decoder.next_out_of_line();
9510 let handles_before = decoder.remaining_handles();
9511 if let Some((inlined, num_bytes, num_handles)) =
9512 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9513 {
9514 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9515 if inlined != (member_inline_size <= 4) {
9516 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9517 }
9518 let inner_offset;
9519 let mut inner_depth = depth.clone();
9520 if inlined {
9521 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9522 inner_offset = next_offset;
9523 } else {
9524 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9525 inner_depth.increment()?;
9526 }
9527 let val_ref = self.bss.get_or_insert_with(|| {
9528 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
9529 });
9530 fidl::decode!(
9531 fidl_fuchsia_wlan_common__common::BssDescription,
9532 D,
9533 val_ref,
9534 decoder,
9535 inner_offset,
9536 inner_depth
9537 )?;
9538 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9539 {
9540 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9541 }
9542 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9543 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9544 }
9545 }
9546
9547 next_offset += envelope_size;
9548
9549 while next_offset < end_offset {
9551 _next_ordinal_to_read += 1;
9552 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9553 next_offset += envelope_size;
9554 }
9555
9556 Ok(())
9557 }
9558 }
9559
9560 impl WlanFullmacImplIfcRoamConfRequest {
9561 #[inline(always)]
9562 fn max_ordinal_present(&self) -> u64 {
9563 if let Some(_) = self.association_ies {
9564 return 6;
9565 }
9566 if let Some(_) = self.association_id {
9567 return 5;
9568 }
9569 if let Some(_) = self.target_bss_authenticated {
9570 return 4;
9571 }
9572 if let Some(_) = self.original_association_maintained {
9573 return 3;
9574 }
9575 if let Some(_) = self.status_code {
9576 return 2;
9577 }
9578 if let Some(_) = self.selected_bssid {
9579 return 1;
9580 }
9581 0
9582 }
9583 }
9584
9585 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamConfRequest {
9586 type Borrowed<'a> = &'a Self;
9587 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9588 value
9589 }
9590 }
9591
9592 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamConfRequest {
9593 type Owned = Self;
9594
9595 #[inline(always)]
9596 fn inline_align(_context: fidl::encoding::Context) -> usize {
9597 8
9598 }
9599
9600 #[inline(always)]
9601 fn inline_size(_context: fidl::encoding::Context) -> usize {
9602 16
9603 }
9604 }
9605
9606 unsafe impl<D: fidl::encoding::ResourceDialect>
9607 fidl::encoding::Encode<WlanFullmacImplIfcRoamConfRequest, D>
9608 for &WlanFullmacImplIfcRoamConfRequest
9609 {
9610 unsafe fn encode(
9611 self,
9612 encoder: &mut fidl::encoding::Encoder<'_, D>,
9613 offset: usize,
9614 mut depth: fidl::encoding::Depth,
9615 ) -> fidl::Result<()> {
9616 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamConfRequest>(offset);
9617 let max_ordinal: u64 = self.max_ordinal_present();
9619 encoder.write_num(max_ordinal, offset);
9620 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9621 if max_ordinal == 0 {
9623 return Ok(());
9624 }
9625 depth.increment()?;
9626 let envelope_size = 8;
9627 let bytes_len = max_ordinal as usize * envelope_size;
9628 #[allow(unused_variables)]
9629 let offset = encoder.out_of_line_offset(bytes_len);
9630 let mut _prev_end_offset: usize = 0;
9631 if 1 > max_ordinal {
9632 return Ok(());
9633 }
9634
9635 let cur_offset: usize = (1 - 1) * envelope_size;
9638
9639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9641
9642 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
9647 self.selected_bssid
9648 .as_ref()
9649 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
9650 encoder,
9651 offset + cur_offset,
9652 depth,
9653 )?;
9654
9655 _prev_end_offset = cur_offset + envelope_size;
9656 if 2 > max_ordinal {
9657 return Ok(());
9658 }
9659
9660 let cur_offset: usize = (2 - 1) * envelope_size;
9663
9664 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9666
9667 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
9672 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
9673 encoder, offset + cur_offset, depth
9674 )?;
9675
9676 _prev_end_offset = cur_offset + envelope_size;
9677 if 3 > max_ordinal {
9678 return Ok(());
9679 }
9680
9681 let cur_offset: usize = (3 - 1) * envelope_size;
9684
9685 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9687
9688 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9693 self.original_association_maintained
9694 .as_ref()
9695 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9696 encoder,
9697 offset + cur_offset,
9698 depth,
9699 )?;
9700
9701 _prev_end_offset = cur_offset + envelope_size;
9702 if 4 > max_ordinal {
9703 return Ok(());
9704 }
9705
9706 let cur_offset: usize = (4 - 1) * envelope_size;
9709
9710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9712
9713 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9718 self.target_bss_authenticated
9719 .as_ref()
9720 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9721 encoder,
9722 offset + cur_offset,
9723 depth,
9724 )?;
9725
9726 _prev_end_offset = cur_offset + envelope_size;
9727 if 5 > max_ordinal {
9728 return Ok(());
9729 }
9730
9731 let cur_offset: usize = (5 - 1) * envelope_size;
9734
9735 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9737
9738 fidl::encoding::encode_in_envelope_optional::<u16, D>(
9743 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9744 encoder,
9745 offset + cur_offset,
9746 depth,
9747 )?;
9748
9749 _prev_end_offset = cur_offset + envelope_size;
9750 if 6 > max_ordinal {
9751 return Ok(());
9752 }
9753
9754 let cur_offset: usize = (6 - 1) * envelope_size;
9757
9758 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9760
9761 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
9766 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
9767 encoder, offset + cur_offset, depth
9768 )?;
9769
9770 _prev_end_offset = cur_offset + envelope_size;
9771
9772 Ok(())
9773 }
9774 }
9775
9776 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9777 for WlanFullmacImplIfcRoamConfRequest
9778 {
9779 #[inline(always)]
9780 fn new_empty() -> Self {
9781 Self::default()
9782 }
9783
9784 unsafe fn decode(
9785 &mut self,
9786 decoder: &mut fidl::encoding::Decoder<'_, D>,
9787 offset: usize,
9788 mut depth: fidl::encoding::Depth,
9789 ) -> fidl::Result<()> {
9790 decoder.debug_check_bounds::<Self>(offset);
9791 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9792 None => return Err(fidl::Error::NotNullable),
9793 Some(len) => len,
9794 };
9795 if len == 0 {
9797 return Ok(());
9798 };
9799 depth.increment()?;
9800 let envelope_size = 8;
9801 let bytes_len = len * envelope_size;
9802 let offset = decoder.out_of_line_offset(bytes_len)?;
9803 let mut _next_ordinal_to_read = 0;
9805 let mut next_offset = offset;
9806 let end_offset = offset + bytes_len;
9807 _next_ordinal_to_read += 1;
9808 if next_offset >= end_offset {
9809 return Ok(());
9810 }
9811
9812 while _next_ordinal_to_read < 1 {
9814 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9815 _next_ordinal_to_read += 1;
9816 next_offset += envelope_size;
9817 }
9818
9819 let next_out_of_line = decoder.next_out_of_line();
9820 let handles_before = decoder.remaining_handles();
9821 if let Some((inlined, num_bytes, num_handles)) =
9822 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9823 {
9824 let member_inline_size =
9825 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
9826 decoder.context,
9827 );
9828 if inlined != (member_inline_size <= 4) {
9829 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9830 }
9831 let inner_offset;
9832 let mut inner_depth = depth.clone();
9833 if inlined {
9834 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9835 inner_offset = next_offset;
9836 } else {
9837 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9838 inner_depth.increment()?;
9839 }
9840 let val_ref = self
9841 .selected_bssid
9842 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
9843 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9872 if inlined != (member_inline_size <= 4) {
9873 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9874 }
9875 let inner_offset;
9876 let mut inner_depth = depth.clone();
9877 if inlined {
9878 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9879 inner_offset = next_offset;
9880 } else {
9881 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9882 inner_depth.increment()?;
9883 }
9884 let val_ref = self.status_code.get_or_insert_with(|| {
9885 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
9886 });
9887 fidl::decode!(
9888 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
9889 D,
9890 val_ref,
9891 decoder,
9892 inner_offset,
9893 inner_depth
9894 )?;
9895 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9896 {
9897 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9898 }
9899 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9900 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9901 }
9902 }
9903
9904 next_offset += envelope_size;
9905 _next_ordinal_to_read += 1;
9906 if next_offset >= end_offset {
9907 return Ok(());
9908 }
9909
9910 while _next_ordinal_to_read < 3 {
9912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9913 _next_ordinal_to_read += 1;
9914 next_offset += envelope_size;
9915 }
9916
9917 let next_out_of_line = decoder.next_out_of_line();
9918 let handles_before = decoder.remaining_handles();
9919 if let Some((inlined, num_bytes, num_handles)) =
9920 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9921 {
9922 let member_inline_size =
9923 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9924 if inlined != (member_inline_size <= 4) {
9925 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9926 }
9927 let inner_offset;
9928 let mut inner_depth = depth.clone();
9929 if inlined {
9930 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9931 inner_offset = next_offset;
9932 } else {
9933 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9934 inner_depth.increment()?;
9935 }
9936 let val_ref = self
9937 .original_association_maintained
9938 .get_or_insert_with(|| fidl::new_empty!(bool, D));
9939 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9941 {
9942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9943 }
9944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9946 }
9947 }
9948
9949 next_offset += envelope_size;
9950 _next_ordinal_to_read += 1;
9951 if next_offset >= end_offset {
9952 return Ok(());
9953 }
9954
9955 while _next_ordinal_to_read < 4 {
9957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9958 _next_ordinal_to_read += 1;
9959 next_offset += envelope_size;
9960 }
9961
9962 let next_out_of_line = decoder.next_out_of_line();
9963 let handles_before = decoder.remaining_handles();
9964 if let Some((inlined, num_bytes, num_handles)) =
9965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9966 {
9967 let member_inline_size =
9968 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9969 if inlined != (member_inline_size <= 4) {
9970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9971 }
9972 let inner_offset;
9973 let mut inner_depth = depth.clone();
9974 if inlined {
9975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9976 inner_offset = next_offset;
9977 } else {
9978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9979 inner_depth.increment()?;
9980 }
9981 let val_ref =
9982 self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
9983 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9984 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9985 {
9986 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9987 }
9988 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9989 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9990 }
9991 }
9992
9993 next_offset += envelope_size;
9994 _next_ordinal_to_read += 1;
9995 if next_offset >= end_offset {
9996 return Ok(());
9997 }
9998
9999 while _next_ordinal_to_read < 5 {
10001 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10002 _next_ordinal_to_read += 1;
10003 next_offset += envelope_size;
10004 }
10005
10006 let next_out_of_line = decoder.next_out_of_line();
10007 let handles_before = decoder.remaining_handles();
10008 if let Some((inlined, num_bytes, num_handles)) =
10009 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10010 {
10011 let member_inline_size =
10012 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10013 if inlined != (member_inline_size <= 4) {
10014 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10015 }
10016 let inner_offset;
10017 let mut inner_depth = depth.clone();
10018 if inlined {
10019 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10020 inner_offset = next_offset;
10021 } else {
10022 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10023 inner_depth.increment()?;
10024 }
10025 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10026 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
10038 if next_offset >= end_offset {
10039 return Ok(());
10040 }
10041
10042 while _next_ordinal_to_read < 6 {
10044 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10045 _next_ordinal_to_read += 1;
10046 next_offset += envelope_size;
10047 }
10048
10049 let next_out_of_line = decoder.next_out_of_line();
10050 let handles_before = decoder.remaining_handles();
10051 if let Some((inlined, num_bytes, num_handles)) =
10052 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10053 {
10054 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10055 if inlined != (member_inline_size <= 4) {
10056 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10057 }
10058 let inner_offset;
10059 let mut inner_depth = depth.clone();
10060 if inlined {
10061 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10062 inner_offset = next_offset;
10063 } else {
10064 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10065 inner_depth.increment()?;
10066 }
10067 let val_ref = self.association_ies.get_or_insert_with(|| {
10068 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10069 });
10070 fidl::decode!(
10071 fidl::encoding::UnboundedVector<u8>,
10072 D,
10073 val_ref,
10074 decoder,
10075 inner_offset,
10076 inner_depth
10077 )?;
10078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10079 {
10080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10081 }
10082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10084 }
10085 }
10086
10087 next_offset += envelope_size;
10088
10089 while next_offset < end_offset {
10091 _next_ordinal_to_read += 1;
10092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10093 next_offset += envelope_size;
10094 }
10095
10096 Ok(())
10097 }
10098 }
10099
10100 impl WlanFullmacImplIfcRoamResultIndRequest {
10101 #[inline(always)]
10102 fn max_ordinal_present(&self) -> u64 {
10103 if let Some(_) = self.association_ies {
10104 return 6;
10105 }
10106 if let Some(_) = self.association_id {
10107 return 5;
10108 }
10109 if let Some(_) = self.target_bss_authenticated {
10110 return 4;
10111 }
10112 if let Some(_) = self.original_association_maintained {
10113 return 3;
10114 }
10115 if let Some(_) = self.status_code {
10116 return 2;
10117 }
10118 if let Some(_) = self.selected_bssid {
10119 return 1;
10120 }
10121 0
10122 }
10123 }
10124
10125 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10126 type Borrowed<'a> = &'a Self;
10127 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10128 value
10129 }
10130 }
10131
10132 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10133 type Owned = Self;
10134
10135 #[inline(always)]
10136 fn inline_align(_context: fidl::encoding::Context) -> usize {
10137 8
10138 }
10139
10140 #[inline(always)]
10141 fn inline_size(_context: fidl::encoding::Context) -> usize {
10142 16
10143 }
10144 }
10145
10146 unsafe impl<D: fidl::encoding::ResourceDialect>
10147 fidl::encoding::Encode<WlanFullmacImplIfcRoamResultIndRequest, D>
10148 for &WlanFullmacImplIfcRoamResultIndRequest
10149 {
10150 unsafe fn encode(
10151 self,
10152 encoder: &mut fidl::encoding::Encoder<'_, D>,
10153 offset: usize,
10154 mut depth: fidl::encoding::Depth,
10155 ) -> fidl::Result<()> {
10156 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamResultIndRequest>(offset);
10157 let max_ordinal: u64 = self.max_ordinal_present();
10159 encoder.write_num(max_ordinal, offset);
10160 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10161 if max_ordinal == 0 {
10163 return Ok(());
10164 }
10165 depth.increment()?;
10166 let envelope_size = 8;
10167 let bytes_len = max_ordinal as usize * envelope_size;
10168 #[allow(unused_variables)]
10169 let offset = encoder.out_of_line_offset(bytes_len);
10170 let mut _prev_end_offset: usize = 0;
10171 if 1 > max_ordinal {
10172 return Ok(());
10173 }
10174
10175 let cur_offset: usize = (1 - 1) * envelope_size;
10178
10179 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10181
10182 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10187 self.selected_bssid
10188 .as_ref()
10189 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10190 encoder,
10191 offset + cur_offset,
10192 depth,
10193 )?;
10194
10195 _prev_end_offset = cur_offset + envelope_size;
10196 if 2 > max_ordinal {
10197 return Ok(());
10198 }
10199
10200 let cur_offset: usize = (2 - 1) * envelope_size;
10203
10204 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10206
10207 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
10212 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
10213 encoder, offset + cur_offset, depth
10214 )?;
10215
10216 _prev_end_offset = cur_offset + envelope_size;
10217 if 3 > max_ordinal {
10218 return Ok(());
10219 }
10220
10221 let cur_offset: usize = (3 - 1) * envelope_size;
10224
10225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10227
10228 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10233 self.original_association_maintained
10234 .as_ref()
10235 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10236 encoder,
10237 offset + cur_offset,
10238 depth,
10239 )?;
10240
10241 _prev_end_offset = cur_offset + envelope_size;
10242 if 4 > max_ordinal {
10243 return Ok(());
10244 }
10245
10246 let cur_offset: usize = (4 - 1) * envelope_size;
10249
10250 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10252
10253 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10258 self.target_bss_authenticated
10259 .as_ref()
10260 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10261 encoder,
10262 offset + cur_offset,
10263 depth,
10264 )?;
10265
10266 _prev_end_offset = cur_offset + envelope_size;
10267 if 5 > max_ordinal {
10268 return Ok(());
10269 }
10270
10271 let cur_offset: usize = (5 - 1) * envelope_size;
10274
10275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10277
10278 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10283 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10284 encoder,
10285 offset + cur_offset,
10286 depth,
10287 )?;
10288
10289 _prev_end_offset = cur_offset + envelope_size;
10290 if 6 > max_ordinal {
10291 return Ok(());
10292 }
10293
10294 let cur_offset: usize = (6 - 1) * envelope_size;
10297
10298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10300
10301 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10306 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10307 encoder, offset + cur_offset, depth
10308 )?;
10309
10310 _prev_end_offset = cur_offset + envelope_size;
10311
10312 Ok(())
10313 }
10314 }
10315
10316 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10317 for WlanFullmacImplIfcRoamResultIndRequest
10318 {
10319 #[inline(always)]
10320 fn new_empty() -> Self {
10321 Self::default()
10322 }
10323
10324 unsafe fn decode(
10325 &mut self,
10326 decoder: &mut fidl::encoding::Decoder<'_, D>,
10327 offset: usize,
10328 mut depth: fidl::encoding::Depth,
10329 ) -> fidl::Result<()> {
10330 decoder.debug_check_bounds::<Self>(offset);
10331 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10332 None => return Err(fidl::Error::NotNullable),
10333 Some(len) => len,
10334 };
10335 if len == 0 {
10337 return Ok(());
10338 };
10339 depth.increment()?;
10340 let envelope_size = 8;
10341 let bytes_len = len * envelope_size;
10342 let offset = decoder.out_of_line_offset(bytes_len)?;
10343 let mut _next_ordinal_to_read = 0;
10345 let mut next_offset = offset;
10346 let end_offset = offset + bytes_len;
10347 _next_ordinal_to_read += 1;
10348 if next_offset >= end_offset {
10349 return Ok(());
10350 }
10351
10352 while _next_ordinal_to_read < 1 {
10354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10355 _next_ordinal_to_read += 1;
10356 next_offset += envelope_size;
10357 }
10358
10359 let next_out_of_line = decoder.next_out_of_line();
10360 let handles_before = decoder.remaining_handles();
10361 if let Some((inlined, num_bytes, num_handles)) =
10362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10363 {
10364 let member_inline_size =
10365 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10366 decoder.context,
10367 );
10368 if inlined != (member_inline_size <= 4) {
10369 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10370 }
10371 let inner_offset;
10372 let mut inner_depth = depth.clone();
10373 if inlined {
10374 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10375 inner_offset = next_offset;
10376 } else {
10377 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10378 inner_depth.increment()?;
10379 }
10380 let val_ref = self
10381 .selected_bssid
10382 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10383 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10412 if inlined != (member_inline_size <= 4) {
10413 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10414 }
10415 let inner_offset;
10416 let mut inner_depth = depth.clone();
10417 if inlined {
10418 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10419 inner_offset = next_offset;
10420 } else {
10421 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10422 inner_depth.increment()?;
10423 }
10424 let val_ref = self.status_code.get_or_insert_with(|| {
10425 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
10426 });
10427 fidl::decode!(
10428 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
10429 D,
10430 val_ref,
10431 decoder,
10432 inner_offset,
10433 inner_depth
10434 )?;
10435 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10436 {
10437 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10438 }
10439 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10440 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10441 }
10442 }
10443
10444 next_offset += envelope_size;
10445 _next_ordinal_to_read += 1;
10446 if next_offset >= end_offset {
10447 return Ok(());
10448 }
10449
10450 while _next_ordinal_to_read < 3 {
10452 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10453 _next_ordinal_to_read += 1;
10454 next_offset += envelope_size;
10455 }
10456
10457 let next_out_of_line = decoder.next_out_of_line();
10458 let handles_before = decoder.remaining_handles();
10459 if let Some((inlined, num_bytes, num_handles)) =
10460 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10461 {
10462 let member_inline_size =
10463 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10464 if inlined != (member_inline_size <= 4) {
10465 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10466 }
10467 let inner_offset;
10468 let mut inner_depth = depth.clone();
10469 if inlined {
10470 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10471 inner_offset = next_offset;
10472 } else {
10473 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10474 inner_depth.increment()?;
10475 }
10476 let val_ref = self
10477 .original_association_maintained
10478 .get_or_insert_with(|| fidl::new_empty!(bool, D));
10479 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10481 {
10482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10483 }
10484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10486 }
10487 }
10488
10489 next_offset += envelope_size;
10490 _next_ordinal_to_read += 1;
10491 if next_offset >= end_offset {
10492 return Ok(());
10493 }
10494
10495 while _next_ordinal_to_read < 4 {
10497 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10498 _next_ordinal_to_read += 1;
10499 next_offset += envelope_size;
10500 }
10501
10502 let next_out_of_line = decoder.next_out_of_line();
10503 let handles_before = decoder.remaining_handles();
10504 if let Some((inlined, num_bytes, num_handles)) =
10505 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10506 {
10507 let member_inline_size =
10508 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10509 if inlined != (member_inline_size <= 4) {
10510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10511 }
10512 let inner_offset;
10513 let mut inner_depth = depth.clone();
10514 if inlined {
10515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10516 inner_offset = next_offset;
10517 } else {
10518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10519 inner_depth.increment()?;
10520 }
10521 let val_ref =
10522 self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
10523 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10524 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10525 {
10526 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10527 }
10528 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10529 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10530 }
10531 }
10532
10533 next_offset += envelope_size;
10534 _next_ordinal_to_read += 1;
10535 if next_offset >= end_offset {
10536 return Ok(());
10537 }
10538
10539 while _next_ordinal_to_read < 5 {
10541 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10542 _next_ordinal_to_read += 1;
10543 next_offset += envelope_size;
10544 }
10545
10546 let next_out_of_line = decoder.next_out_of_line();
10547 let handles_before = decoder.remaining_handles();
10548 if let Some((inlined, num_bytes, num_handles)) =
10549 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10550 {
10551 let member_inline_size =
10552 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10553 if inlined != (member_inline_size <= 4) {
10554 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10555 }
10556 let inner_offset;
10557 let mut inner_depth = depth.clone();
10558 if inlined {
10559 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10560 inner_offset = next_offset;
10561 } else {
10562 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10563 inner_depth.increment()?;
10564 }
10565 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10566 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
10578 if next_offset >= end_offset {
10579 return Ok(());
10580 }
10581
10582 while _next_ordinal_to_read < 6 {
10584 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10585 _next_ordinal_to_read += 1;
10586 next_offset += envelope_size;
10587 }
10588
10589 let next_out_of_line = decoder.next_out_of_line();
10590 let handles_before = decoder.remaining_handles();
10591 if let Some((inlined, num_bytes, num_handles)) =
10592 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10593 {
10594 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10595 if inlined != (member_inline_size <= 4) {
10596 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10597 }
10598 let inner_offset;
10599 let mut inner_depth = depth.clone();
10600 if inlined {
10601 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10602 inner_offset = next_offset;
10603 } else {
10604 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10605 inner_depth.increment()?;
10606 }
10607 let val_ref = self.association_ies.get_or_insert_with(|| {
10608 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10609 });
10610 fidl::decode!(
10611 fidl::encoding::UnboundedVector<u8>,
10612 D,
10613 val_ref,
10614 decoder,
10615 inner_offset,
10616 inner_depth
10617 )?;
10618 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10619 {
10620 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10621 }
10622 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10623 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10624 }
10625 }
10626
10627 next_offset += envelope_size;
10628
10629 while next_offset < end_offset {
10631 _next_ordinal_to_read += 1;
10632 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10633 next_offset += envelope_size;
10634 }
10635
10636 Ok(())
10637 }
10638 }
10639
10640 impl WlanFullmacImplIfcRoamStartIndRequest {
10641 #[inline(always)]
10642 fn max_ordinal_present(&self) -> u64 {
10643 if let Some(_) = self.original_association_maintained {
10644 return 3;
10645 }
10646 if let Some(_) = self.selected_bss {
10647 return 2;
10648 }
10649 if let Some(_) = self.selected_bssid {
10650 return 1;
10651 }
10652 0
10653 }
10654 }
10655
10656 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10657 type Borrowed<'a> = &'a Self;
10658 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10659 value
10660 }
10661 }
10662
10663 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10664 type Owned = Self;
10665
10666 #[inline(always)]
10667 fn inline_align(_context: fidl::encoding::Context) -> usize {
10668 8
10669 }
10670
10671 #[inline(always)]
10672 fn inline_size(_context: fidl::encoding::Context) -> usize {
10673 16
10674 }
10675 }
10676
10677 unsafe impl<D: fidl::encoding::ResourceDialect>
10678 fidl::encoding::Encode<WlanFullmacImplIfcRoamStartIndRequest, D>
10679 for &WlanFullmacImplIfcRoamStartIndRequest
10680 {
10681 unsafe fn encode(
10682 self,
10683 encoder: &mut fidl::encoding::Encoder<'_, D>,
10684 offset: usize,
10685 mut depth: fidl::encoding::Depth,
10686 ) -> fidl::Result<()> {
10687 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamStartIndRequest>(offset);
10688 let max_ordinal: u64 = self.max_ordinal_present();
10690 encoder.write_num(max_ordinal, offset);
10691 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10692 if max_ordinal == 0 {
10694 return Ok(());
10695 }
10696 depth.increment()?;
10697 let envelope_size = 8;
10698 let bytes_len = max_ordinal as usize * envelope_size;
10699 #[allow(unused_variables)]
10700 let offset = encoder.out_of_line_offset(bytes_len);
10701 let mut _prev_end_offset: usize = 0;
10702 if 1 > max_ordinal {
10703 return Ok(());
10704 }
10705
10706 let cur_offset: usize = (1 - 1) * envelope_size;
10709
10710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10712
10713 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10718 self.selected_bssid
10719 .as_ref()
10720 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10721 encoder,
10722 offset + cur_offset,
10723 depth,
10724 )?;
10725
10726 _prev_end_offset = cur_offset + envelope_size;
10727 if 2 > max_ordinal {
10728 return Ok(());
10729 }
10730
10731 let cur_offset: usize = (2 - 1) * envelope_size;
10734
10735 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10737
10738 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
10743 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
10744 encoder, offset + cur_offset, depth
10745 )?;
10746
10747 _prev_end_offset = cur_offset + envelope_size;
10748 if 3 > max_ordinal {
10749 return Ok(());
10750 }
10751
10752 let cur_offset: usize = (3 - 1) * envelope_size;
10755
10756 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10758
10759 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10764 self.original_association_maintained
10765 .as_ref()
10766 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10767 encoder,
10768 offset + cur_offset,
10769 depth,
10770 )?;
10771
10772 _prev_end_offset = cur_offset + envelope_size;
10773
10774 Ok(())
10775 }
10776 }
10777
10778 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10779 for WlanFullmacImplIfcRoamStartIndRequest
10780 {
10781 #[inline(always)]
10782 fn new_empty() -> Self {
10783 Self::default()
10784 }
10785
10786 unsafe fn decode(
10787 &mut self,
10788 decoder: &mut fidl::encoding::Decoder<'_, D>,
10789 offset: usize,
10790 mut depth: fidl::encoding::Depth,
10791 ) -> fidl::Result<()> {
10792 decoder.debug_check_bounds::<Self>(offset);
10793 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10794 None => return Err(fidl::Error::NotNullable),
10795 Some(len) => len,
10796 };
10797 if len == 0 {
10799 return Ok(());
10800 };
10801 depth.increment()?;
10802 let envelope_size = 8;
10803 let bytes_len = len * envelope_size;
10804 let offset = decoder.out_of_line_offset(bytes_len)?;
10805 let mut _next_ordinal_to_read = 0;
10807 let mut next_offset = offset;
10808 let end_offset = offset + bytes_len;
10809 _next_ordinal_to_read += 1;
10810 if next_offset >= end_offset {
10811 return Ok(());
10812 }
10813
10814 while _next_ordinal_to_read < 1 {
10816 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10817 _next_ordinal_to_read += 1;
10818 next_offset += envelope_size;
10819 }
10820
10821 let next_out_of_line = decoder.next_out_of_line();
10822 let handles_before = decoder.remaining_handles();
10823 if let Some((inlined, num_bytes, num_handles)) =
10824 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10825 {
10826 let member_inline_size =
10827 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10828 decoder.context,
10829 );
10830 if inlined != (member_inline_size <= 4) {
10831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10832 }
10833 let inner_offset;
10834 let mut inner_depth = depth.clone();
10835 if inlined {
10836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10837 inner_offset = next_offset;
10838 } else {
10839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10840 inner_depth.increment()?;
10841 }
10842 let val_ref = self
10843 .selected_bssid
10844 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10845 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
10863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10864 _next_ordinal_to_read += 1;
10865 next_offset += envelope_size;
10866 }
10867
10868 let next_out_of_line = decoder.next_out_of_line();
10869 let handles_before = decoder.remaining_handles();
10870 if let Some((inlined, num_bytes, num_handles)) =
10871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10872 {
10873 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10874 if inlined != (member_inline_size <= 4) {
10875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10876 }
10877 let inner_offset;
10878 let mut inner_depth = depth.clone();
10879 if inlined {
10880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10881 inner_offset = next_offset;
10882 } else {
10883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10884 inner_depth.increment()?;
10885 }
10886 let val_ref = self.selected_bss.get_or_insert_with(|| {
10887 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
10888 });
10889 fidl::decode!(
10890 fidl_fuchsia_wlan_common__common::BssDescription,
10891 D,
10892 val_ref,
10893 decoder,
10894 inner_offset,
10895 inner_depth
10896 )?;
10897 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898 {
10899 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900 }
10901 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903 }
10904 }
10905
10906 next_offset += envelope_size;
10907 _next_ordinal_to_read += 1;
10908 if next_offset >= end_offset {
10909 return Ok(());
10910 }
10911
10912 while _next_ordinal_to_read < 3 {
10914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915 _next_ordinal_to_read += 1;
10916 next_offset += envelope_size;
10917 }
10918
10919 let next_out_of_line = decoder.next_out_of_line();
10920 let handles_before = decoder.remaining_handles();
10921 if let Some((inlined, num_bytes, num_handles)) =
10922 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923 {
10924 let member_inline_size =
10925 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926 if inlined != (member_inline_size <= 4) {
10927 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928 }
10929 let inner_offset;
10930 let mut inner_depth = depth.clone();
10931 if inlined {
10932 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933 inner_offset = next_offset;
10934 } else {
10935 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936 inner_depth.increment()?;
10937 }
10938 let val_ref = self
10939 .original_association_maintained
10940 .get_or_insert_with(|| fidl::new_empty!(bool, D));
10941 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10942 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10943 {
10944 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10945 }
10946 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10947 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10948 }
10949 }
10950
10951 next_offset += envelope_size;
10952
10953 while next_offset < end_offset {
10955 _next_ordinal_to_read += 1;
10956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10957 next_offset += envelope_size;
10958 }
10959
10960 Ok(())
10961 }
10962 }
10963
10964 impl WlanFullmacImplIfcSaeHandshakeIndRequest {
10965 #[inline(always)]
10966 fn max_ordinal_present(&self) -> u64 {
10967 if let Some(_) = self.peer_sta_address {
10968 return 1;
10969 }
10970 0
10971 }
10972 }
10973
10974 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10975 type Borrowed<'a> = &'a Self;
10976 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10977 value
10978 }
10979 }
10980
10981 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10982 type Owned = Self;
10983
10984 #[inline(always)]
10985 fn inline_align(_context: fidl::encoding::Context) -> usize {
10986 8
10987 }
10988
10989 #[inline(always)]
10990 fn inline_size(_context: fidl::encoding::Context) -> usize {
10991 16
10992 }
10993 }
10994
10995 unsafe impl<D: fidl::encoding::ResourceDialect>
10996 fidl::encoding::Encode<WlanFullmacImplIfcSaeHandshakeIndRequest, D>
10997 for &WlanFullmacImplIfcSaeHandshakeIndRequest
10998 {
10999 unsafe fn encode(
11000 self,
11001 encoder: &mut fidl::encoding::Encoder<'_, D>,
11002 offset: usize,
11003 mut depth: fidl::encoding::Depth,
11004 ) -> fidl::Result<()> {
11005 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeHandshakeIndRequest>(offset);
11006 let max_ordinal: u64 = self.max_ordinal_present();
11008 encoder.write_num(max_ordinal, offset);
11009 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11010 if max_ordinal == 0 {
11012 return Ok(());
11013 }
11014 depth.increment()?;
11015 let envelope_size = 8;
11016 let bytes_len = max_ordinal as usize * envelope_size;
11017 #[allow(unused_variables)]
11018 let offset = encoder.out_of_line_offset(bytes_len);
11019 let mut _prev_end_offset: usize = 0;
11020 if 1 > max_ordinal {
11021 return Ok(());
11022 }
11023
11024 let cur_offset: usize = (1 - 1) * envelope_size;
11027
11028 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11030
11031 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11036 self.peer_sta_address
11037 .as_ref()
11038 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11039 encoder,
11040 offset + cur_offset,
11041 depth,
11042 )?;
11043
11044 _prev_end_offset = cur_offset + envelope_size;
11045
11046 Ok(())
11047 }
11048 }
11049
11050 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11051 for WlanFullmacImplIfcSaeHandshakeIndRequest
11052 {
11053 #[inline(always)]
11054 fn new_empty() -> Self {
11055 Self::default()
11056 }
11057
11058 unsafe fn decode(
11059 &mut self,
11060 decoder: &mut fidl::encoding::Decoder<'_, D>,
11061 offset: usize,
11062 mut depth: fidl::encoding::Depth,
11063 ) -> fidl::Result<()> {
11064 decoder.debug_check_bounds::<Self>(offset);
11065 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11066 None => return Err(fidl::Error::NotNullable),
11067 Some(len) => len,
11068 };
11069 if len == 0 {
11071 return Ok(());
11072 };
11073 depth.increment()?;
11074 let envelope_size = 8;
11075 let bytes_len = len * envelope_size;
11076 let offset = decoder.out_of_line_offset(bytes_len)?;
11077 let mut _next_ordinal_to_read = 0;
11079 let mut next_offset = offset;
11080 let end_offset = offset + bytes_len;
11081 _next_ordinal_to_read += 1;
11082 if next_offset >= end_offset {
11083 return Ok(());
11084 }
11085
11086 while _next_ordinal_to_read < 1 {
11088 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11089 _next_ordinal_to_read += 1;
11090 next_offset += envelope_size;
11091 }
11092
11093 let next_out_of_line = decoder.next_out_of_line();
11094 let handles_before = decoder.remaining_handles();
11095 if let Some((inlined, num_bytes, num_handles)) =
11096 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11097 {
11098 let member_inline_size =
11099 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11100 decoder.context,
11101 );
11102 if inlined != (member_inline_size <= 4) {
11103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11104 }
11105 let inner_offset;
11106 let mut inner_depth = depth.clone();
11107 if inlined {
11108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11109 inner_offset = next_offset;
11110 } else {
11111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11112 inner_depth.increment()?;
11113 }
11114 let val_ref = self
11115 .peer_sta_address
11116 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11117 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11118 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11119 {
11120 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11121 }
11122 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11123 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11124 }
11125 }
11126
11127 next_offset += envelope_size;
11128
11129 while next_offset < end_offset {
11131 _next_ordinal_to_read += 1;
11132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11133 next_offset += envelope_size;
11134 }
11135
11136 Ok(())
11137 }
11138 }
11139
11140 impl WlanFullmacImplIfcStartConfRequest {
11141 #[inline(always)]
11142 fn max_ordinal_present(&self) -> u64 {
11143 if let Some(_) = self.result_code {
11144 return 1;
11145 }
11146 0
11147 }
11148 }
11149
11150 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStartConfRequest {
11151 type Borrowed<'a> = &'a Self;
11152 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11153 value
11154 }
11155 }
11156
11157 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStartConfRequest {
11158 type Owned = Self;
11159
11160 #[inline(always)]
11161 fn inline_align(_context: fidl::encoding::Context) -> usize {
11162 8
11163 }
11164
11165 #[inline(always)]
11166 fn inline_size(_context: fidl::encoding::Context) -> usize {
11167 16
11168 }
11169 }
11170
11171 unsafe impl<D: fidl::encoding::ResourceDialect>
11172 fidl::encoding::Encode<WlanFullmacImplIfcStartConfRequest, D>
11173 for &WlanFullmacImplIfcStartConfRequest
11174 {
11175 unsafe fn encode(
11176 self,
11177 encoder: &mut fidl::encoding::Encoder<'_, D>,
11178 offset: usize,
11179 mut depth: fidl::encoding::Depth,
11180 ) -> fidl::Result<()> {
11181 encoder.debug_check_bounds::<WlanFullmacImplIfcStartConfRequest>(offset);
11182 let max_ordinal: u64 = self.max_ordinal_present();
11184 encoder.write_num(max_ordinal, offset);
11185 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11186 if max_ordinal == 0 {
11188 return Ok(());
11189 }
11190 depth.increment()?;
11191 let envelope_size = 8;
11192 let bytes_len = max_ordinal as usize * envelope_size;
11193 #[allow(unused_variables)]
11194 let offset = encoder.out_of_line_offset(bytes_len);
11195 let mut _prev_end_offset: usize = 0;
11196 if 1 > max_ordinal {
11197 return Ok(());
11198 }
11199
11200 let cur_offset: usize = (1 - 1) * envelope_size;
11203
11204 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11206
11207 fidl::encoding::encode_in_envelope_optional::<StartResult, D>(
11212 self.result_code
11213 .as_ref()
11214 .map(<StartResult as fidl::encoding::ValueTypeMarker>::borrow),
11215 encoder,
11216 offset + cur_offset,
11217 depth,
11218 )?;
11219
11220 _prev_end_offset = cur_offset + envelope_size;
11221
11222 Ok(())
11223 }
11224 }
11225
11226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11227 for WlanFullmacImplIfcStartConfRequest
11228 {
11229 #[inline(always)]
11230 fn new_empty() -> Self {
11231 Self::default()
11232 }
11233
11234 unsafe fn decode(
11235 &mut self,
11236 decoder: &mut fidl::encoding::Decoder<'_, D>,
11237 offset: usize,
11238 mut depth: fidl::encoding::Depth,
11239 ) -> fidl::Result<()> {
11240 decoder.debug_check_bounds::<Self>(offset);
11241 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11242 None => return Err(fidl::Error::NotNullable),
11243 Some(len) => len,
11244 };
11245 if len == 0 {
11247 return Ok(());
11248 };
11249 depth.increment()?;
11250 let envelope_size = 8;
11251 let bytes_len = len * envelope_size;
11252 let offset = decoder.out_of_line_offset(bytes_len)?;
11253 let mut _next_ordinal_to_read = 0;
11255 let mut next_offset = offset;
11256 let end_offset = offset + bytes_len;
11257 _next_ordinal_to_read += 1;
11258 if next_offset >= end_offset {
11259 return Ok(());
11260 }
11261
11262 while _next_ordinal_to_read < 1 {
11264 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11265 _next_ordinal_to_read += 1;
11266 next_offset += envelope_size;
11267 }
11268
11269 let next_out_of_line = decoder.next_out_of_line();
11270 let handles_before = decoder.remaining_handles();
11271 if let Some((inlined, num_bytes, num_handles)) =
11272 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11273 {
11274 let member_inline_size =
11275 <StartResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11276 if inlined != (member_inline_size <= 4) {
11277 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11278 }
11279 let inner_offset;
11280 let mut inner_depth = depth.clone();
11281 if inlined {
11282 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11283 inner_offset = next_offset;
11284 } else {
11285 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11286 inner_depth.increment()?;
11287 }
11288 let val_ref =
11289 self.result_code.get_or_insert_with(|| fidl::new_empty!(StartResult, D));
11290 fidl::decode!(StartResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11291 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11292 {
11293 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11294 }
11295 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11296 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11297 }
11298 }
11299
11300 next_offset += envelope_size;
11301
11302 while next_offset < end_offset {
11304 _next_ordinal_to_read += 1;
11305 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11306 next_offset += envelope_size;
11307 }
11308
11309 Ok(())
11310 }
11311 }
11312
11313 impl WlanFullmacImplIfcStopConfRequest {
11314 #[inline(always)]
11315 fn max_ordinal_present(&self) -> u64 {
11316 if let Some(_) = self.result_code {
11317 return 1;
11318 }
11319 0
11320 }
11321 }
11322
11323 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStopConfRequest {
11324 type Borrowed<'a> = &'a Self;
11325 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11326 value
11327 }
11328 }
11329
11330 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStopConfRequest {
11331 type Owned = Self;
11332
11333 #[inline(always)]
11334 fn inline_align(_context: fidl::encoding::Context) -> usize {
11335 8
11336 }
11337
11338 #[inline(always)]
11339 fn inline_size(_context: fidl::encoding::Context) -> usize {
11340 16
11341 }
11342 }
11343
11344 unsafe impl<D: fidl::encoding::ResourceDialect>
11345 fidl::encoding::Encode<WlanFullmacImplIfcStopConfRequest, D>
11346 for &WlanFullmacImplIfcStopConfRequest
11347 {
11348 unsafe fn encode(
11349 self,
11350 encoder: &mut fidl::encoding::Encoder<'_, D>,
11351 offset: usize,
11352 mut depth: fidl::encoding::Depth,
11353 ) -> fidl::Result<()> {
11354 encoder.debug_check_bounds::<WlanFullmacImplIfcStopConfRequest>(offset);
11355 let max_ordinal: u64 = self.max_ordinal_present();
11357 encoder.write_num(max_ordinal, offset);
11358 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11359 if max_ordinal == 0 {
11361 return Ok(());
11362 }
11363 depth.increment()?;
11364 let envelope_size = 8;
11365 let bytes_len = max_ordinal as usize * envelope_size;
11366 #[allow(unused_variables)]
11367 let offset = encoder.out_of_line_offset(bytes_len);
11368 let mut _prev_end_offset: usize = 0;
11369 if 1 > max_ordinal {
11370 return Ok(());
11371 }
11372
11373 let cur_offset: usize = (1 - 1) * envelope_size;
11376
11377 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11379
11380 fidl::encoding::encode_in_envelope_optional::<StopResult, D>(
11385 self.result_code
11386 .as_ref()
11387 .map(<StopResult as fidl::encoding::ValueTypeMarker>::borrow),
11388 encoder,
11389 offset + cur_offset,
11390 depth,
11391 )?;
11392
11393 _prev_end_offset = cur_offset + envelope_size;
11394
11395 Ok(())
11396 }
11397 }
11398
11399 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11400 for WlanFullmacImplIfcStopConfRequest
11401 {
11402 #[inline(always)]
11403 fn new_empty() -> Self {
11404 Self::default()
11405 }
11406
11407 unsafe fn decode(
11408 &mut self,
11409 decoder: &mut fidl::encoding::Decoder<'_, D>,
11410 offset: usize,
11411 mut depth: fidl::encoding::Depth,
11412 ) -> fidl::Result<()> {
11413 decoder.debug_check_bounds::<Self>(offset);
11414 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11415 None => return Err(fidl::Error::NotNullable),
11416 Some(len) => len,
11417 };
11418 if len == 0 {
11420 return Ok(());
11421 };
11422 depth.increment()?;
11423 let envelope_size = 8;
11424 let bytes_len = len * envelope_size;
11425 let offset = decoder.out_of_line_offset(bytes_len)?;
11426 let mut _next_ordinal_to_read = 0;
11428 let mut next_offset = offset;
11429 let end_offset = offset + bytes_len;
11430 _next_ordinal_to_read += 1;
11431 if next_offset >= end_offset {
11432 return Ok(());
11433 }
11434
11435 while _next_ordinal_to_read < 1 {
11437 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11438 _next_ordinal_to_read += 1;
11439 next_offset += envelope_size;
11440 }
11441
11442 let next_out_of_line = decoder.next_out_of_line();
11443 let handles_before = decoder.remaining_handles();
11444 if let Some((inlined, num_bytes, num_handles)) =
11445 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11446 {
11447 let member_inline_size =
11448 <StopResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11449 if inlined != (member_inline_size <= 4) {
11450 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11451 }
11452 let inner_offset;
11453 let mut inner_depth = depth.clone();
11454 if inlined {
11455 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11456 inner_offset = next_offset;
11457 } else {
11458 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11459 inner_depth.increment()?;
11460 }
11461 let val_ref =
11462 self.result_code.get_or_insert_with(|| fidl::new_empty!(StopResult, D));
11463 fidl::decode!(StopResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11464 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11465 {
11466 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11467 }
11468 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11469 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11470 }
11471 }
11472
11473 next_offset += envelope_size;
11474
11475 while next_offset < end_offset {
11477 _next_ordinal_to_read += 1;
11478 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11479 next_offset += envelope_size;
11480 }
11481
11482 Ok(())
11483 }
11484 }
11485
11486 impl WlanFullmacImplOnLinkStateChangedRequest {
11487 #[inline(always)]
11488 fn max_ordinal_present(&self) -> u64 {
11489 if let Some(_) = self.online {
11490 return 1;
11491 }
11492 0
11493 }
11494 }
11495
11496 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11497 type Borrowed<'a> = &'a Self;
11498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11499 value
11500 }
11501 }
11502
11503 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11504 type Owned = Self;
11505
11506 #[inline(always)]
11507 fn inline_align(_context: fidl::encoding::Context) -> usize {
11508 8
11509 }
11510
11511 #[inline(always)]
11512 fn inline_size(_context: fidl::encoding::Context) -> usize {
11513 16
11514 }
11515 }
11516
11517 unsafe impl<D: fidl::encoding::ResourceDialect>
11518 fidl::encoding::Encode<WlanFullmacImplOnLinkStateChangedRequest, D>
11519 for &WlanFullmacImplOnLinkStateChangedRequest
11520 {
11521 unsafe fn encode(
11522 self,
11523 encoder: &mut fidl::encoding::Encoder<'_, D>,
11524 offset: usize,
11525 mut depth: fidl::encoding::Depth,
11526 ) -> fidl::Result<()> {
11527 encoder.debug_check_bounds::<WlanFullmacImplOnLinkStateChangedRequest>(offset);
11528 let max_ordinal: u64 = self.max_ordinal_present();
11530 encoder.write_num(max_ordinal, offset);
11531 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11532 if max_ordinal == 0 {
11534 return Ok(());
11535 }
11536 depth.increment()?;
11537 let envelope_size = 8;
11538 let bytes_len = max_ordinal as usize * envelope_size;
11539 #[allow(unused_variables)]
11540 let offset = encoder.out_of_line_offset(bytes_len);
11541 let mut _prev_end_offset: usize = 0;
11542 if 1 > max_ordinal {
11543 return Ok(());
11544 }
11545
11546 let cur_offset: usize = (1 - 1) * envelope_size;
11549
11550 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11552
11553 fidl::encoding::encode_in_envelope_optional::<bool, D>(
11558 self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11559 encoder,
11560 offset + cur_offset,
11561 depth,
11562 )?;
11563
11564 _prev_end_offset = cur_offset + envelope_size;
11565
11566 Ok(())
11567 }
11568 }
11569
11570 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11571 for WlanFullmacImplOnLinkStateChangedRequest
11572 {
11573 #[inline(always)]
11574 fn new_empty() -> Self {
11575 Self::default()
11576 }
11577
11578 unsafe fn decode(
11579 &mut self,
11580 decoder: &mut fidl::encoding::Decoder<'_, D>,
11581 offset: usize,
11582 mut depth: fidl::encoding::Depth,
11583 ) -> fidl::Result<()> {
11584 decoder.debug_check_bounds::<Self>(offset);
11585 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11586 None => return Err(fidl::Error::NotNullable),
11587 Some(len) => len,
11588 };
11589 if len == 0 {
11591 return Ok(());
11592 };
11593 depth.increment()?;
11594 let envelope_size = 8;
11595 let bytes_len = len * envelope_size;
11596 let offset = decoder.out_of_line_offset(bytes_len)?;
11597 let mut _next_ordinal_to_read = 0;
11599 let mut next_offset = offset;
11600 let end_offset = offset + bytes_len;
11601 _next_ordinal_to_read += 1;
11602 if next_offset >= end_offset {
11603 return Ok(());
11604 }
11605
11606 while _next_ordinal_to_read < 1 {
11608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11609 _next_ordinal_to_read += 1;
11610 next_offset += envelope_size;
11611 }
11612
11613 let next_out_of_line = decoder.next_out_of_line();
11614 let handles_before = decoder.remaining_handles();
11615 if let Some((inlined, num_bytes, num_handles)) =
11616 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11617 {
11618 let member_inline_size =
11619 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11620 if inlined != (member_inline_size <= 4) {
11621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11622 }
11623 let inner_offset;
11624 let mut inner_depth = depth.clone();
11625 if inlined {
11626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11627 inner_offset = next_offset;
11628 } else {
11629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11630 inner_depth.increment()?;
11631 }
11632 let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
11633 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11634 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11635 {
11636 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11637 }
11638 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11639 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11640 }
11641 }
11642
11643 next_offset += envelope_size;
11644
11645 while next_offset < end_offset {
11647 _next_ordinal_to_read += 1;
11648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11649 next_offset += envelope_size;
11650 }
11651
11652 Ok(())
11653 }
11654 }
11655
11656 impl WlanFullmacImplReconnectRequest {
11657 #[inline(always)]
11658 fn max_ordinal_present(&self) -> u64 {
11659 if let Some(_) = self.peer_sta_address {
11660 return 1;
11661 }
11662 0
11663 }
11664 }
11665
11666 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplReconnectRequest {
11667 type Borrowed<'a> = &'a Self;
11668 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11669 value
11670 }
11671 }
11672
11673 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplReconnectRequest {
11674 type Owned = Self;
11675
11676 #[inline(always)]
11677 fn inline_align(_context: fidl::encoding::Context) -> usize {
11678 8
11679 }
11680
11681 #[inline(always)]
11682 fn inline_size(_context: fidl::encoding::Context) -> usize {
11683 16
11684 }
11685 }
11686
11687 unsafe impl<D: fidl::encoding::ResourceDialect>
11688 fidl::encoding::Encode<WlanFullmacImplReconnectRequest, D>
11689 for &WlanFullmacImplReconnectRequest
11690 {
11691 unsafe fn encode(
11692 self,
11693 encoder: &mut fidl::encoding::Encoder<'_, D>,
11694 offset: usize,
11695 mut depth: fidl::encoding::Depth,
11696 ) -> fidl::Result<()> {
11697 encoder.debug_check_bounds::<WlanFullmacImplReconnectRequest>(offset);
11698 let max_ordinal: u64 = self.max_ordinal_present();
11700 encoder.write_num(max_ordinal, offset);
11701 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11702 if max_ordinal == 0 {
11704 return Ok(());
11705 }
11706 depth.increment()?;
11707 let envelope_size = 8;
11708 let bytes_len = max_ordinal as usize * envelope_size;
11709 #[allow(unused_variables)]
11710 let offset = encoder.out_of_line_offset(bytes_len);
11711 let mut _prev_end_offset: usize = 0;
11712 if 1 > max_ordinal {
11713 return Ok(());
11714 }
11715
11716 let cur_offset: usize = (1 - 1) * envelope_size;
11719
11720 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11722
11723 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11728 self.peer_sta_address
11729 .as_ref()
11730 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11731 encoder,
11732 offset + cur_offset,
11733 depth,
11734 )?;
11735
11736 _prev_end_offset = cur_offset + envelope_size;
11737
11738 Ok(())
11739 }
11740 }
11741
11742 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11743 for WlanFullmacImplReconnectRequest
11744 {
11745 #[inline(always)]
11746 fn new_empty() -> Self {
11747 Self::default()
11748 }
11749
11750 unsafe fn decode(
11751 &mut self,
11752 decoder: &mut fidl::encoding::Decoder<'_, D>,
11753 offset: usize,
11754 mut depth: fidl::encoding::Depth,
11755 ) -> fidl::Result<()> {
11756 decoder.debug_check_bounds::<Self>(offset);
11757 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11758 None => return Err(fidl::Error::NotNullable),
11759 Some(len) => len,
11760 };
11761 if len == 0 {
11763 return Ok(());
11764 };
11765 depth.increment()?;
11766 let envelope_size = 8;
11767 let bytes_len = len * envelope_size;
11768 let offset = decoder.out_of_line_offset(bytes_len)?;
11769 let mut _next_ordinal_to_read = 0;
11771 let mut next_offset = offset;
11772 let end_offset = offset + bytes_len;
11773 _next_ordinal_to_read += 1;
11774 if next_offset >= end_offset {
11775 return Ok(());
11776 }
11777
11778 while _next_ordinal_to_read < 1 {
11780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11781 _next_ordinal_to_read += 1;
11782 next_offset += envelope_size;
11783 }
11784
11785 let next_out_of_line = decoder.next_out_of_line();
11786 let handles_before = decoder.remaining_handles();
11787 if let Some((inlined, num_bytes, num_handles)) =
11788 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11789 {
11790 let member_inline_size =
11791 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11792 decoder.context,
11793 );
11794 if inlined != (member_inline_size <= 4) {
11795 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11796 }
11797 let inner_offset;
11798 let mut inner_depth = depth.clone();
11799 if inlined {
11800 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11801 inner_offset = next_offset;
11802 } else {
11803 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11804 inner_depth.increment()?;
11805 }
11806 let val_ref = self
11807 .peer_sta_address
11808 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11809 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11810 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11811 {
11812 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11813 }
11814 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11815 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11816 }
11817 }
11818
11819 next_offset += envelope_size;
11820
11821 while next_offset < end_offset {
11823 _next_ordinal_to_read += 1;
11824 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11825 next_offset += envelope_size;
11826 }
11827
11828 Ok(())
11829 }
11830 }
11831
11832 impl WlanFullmacImplRoamRequest {
11833 #[inline(always)]
11834 fn max_ordinal_present(&self) -> u64 {
11835 if let Some(_) = self.selected_bss {
11836 return 1;
11837 }
11838 0
11839 }
11840 }
11841
11842 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplRoamRequest {
11843 type Borrowed<'a> = &'a Self;
11844 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11845 value
11846 }
11847 }
11848
11849 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplRoamRequest {
11850 type Owned = Self;
11851
11852 #[inline(always)]
11853 fn inline_align(_context: fidl::encoding::Context) -> usize {
11854 8
11855 }
11856
11857 #[inline(always)]
11858 fn inline_size(_context: fidl::encoding::Context) -> usize {
11859 16
11860 }
11861 }
11862
11863 unsafe impl<D: fidl::encoding::ResourceDialect>
11864 fidl::encoding::Encode<WlanFullmacImplRoamRequest, D> for &WlanFullmacImplRoamRequest
11865 {
11866 unsafe fn encode(
11867 self,
11868 encoder: &mut fidl::encoding::Encoder<'_, D>,
11869 offset: usize,
11870 mut depth: fidl::encoding::Depth,
11871 ) -> fidl::Result<()> {
11872 encoder.debug_check_bounds::<WlanFullmacImplRoamRequest>(offset);
11873 let max_ordinal: u64 = self.max_ordinal_present();
11875 encoder.write_num(max_ordinal, offset);
11876 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11877 if max_ordinal == 0 {
11879 return Ok(());
11880 }
11881 depth.increment()?;
11882 let envelope_size = 8;
11883 let bytes_len = max_ordinal as usize * envelope_size;
11884 #[allow(unused_variables)]
11885 let offset = encoder.out_of_line_offset(bytes_len);
11886 let mut _prev_end_offset: usize = 0;
11887 if 1 > max_ordinal {
11888 return Ok(());
11889 }
11890
11891 let cur_offset: usize = (1 - 1) * envelope_size;
11894
11895 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11897
11898 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
11903 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
11904 encoder, offset + cur_offset, depth
11905 )?;
11906
11907 _prev_end_offset = cur_offset + envelope_size;
11908
11909 Ok(())
11910 }
11911 }
11912
11913 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11914 for WlanFullmacImplRoamRequest
11915 {
11916 #[inline(always)]
11917 fn new_empty() -> Self {
11918 Self::default()
11919 }
11920
11921 unsafe fn decode(
11922 &mut self,
11923 decoder: &mut fidl::encoding::Decoder<'_, D>,
11924 offset: usize,
11925 mut depth: fidl::encoding::Depth,
11926 ) -> fidl::Result<()> {
11927 decoder.debug_check_bounds::<Self>(offset);
11928 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11929 None => return Err(fidl::Error::NotNullable),
11930 Some(len) => len,
11931 };
11932 if len == 0 {
11934 return Ok(());
11935 };
11936 depth.increment()?;
11937 let envelope_size = 8;
11938 let bytes_len = len * envelope_size;
11939 let offset = decoder.out_of_line_offset(bytes_len)?;
11940 let mut _next_ordinal_to_read = 0;
11942 let mut next_offset = offset;
11943 let end_offset = offset + bytes_len;
11944 _next_ordinal_to_read += 1;
11945 if next_offset >= end_offset {
11946 return Ok(());
11947 }
11948
11949 while _next_ordinal_to_read < 1 {
11951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11952 _next_ordinal_to_read += 1;
11953 next_offset += envelope_size;
11954 }
11955
11956 let next_out_of_line = decoder.next_out_of_line();
11957 let handles_before = decoder.remaining_handles();
11958 if let Some((inlined, num_bytes, num_handles)) =
11959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11960 {
11961 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11962 if inlined != (member_inline_size <= 4) {
11963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11964 }
11965 let inner_offset;
11966 let mut inner_depth = depth.clone();
11967 if inlined {
11968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11969 inner_offset = next_offset;
11970 } else {
11971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11972 inner_depth.increment()?;
11973 }
11974 let val_ref = self.selected_bss.get_or_insert_with(|| {
11975 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
11976 });
11977 fidl::decode!(
11978 fidl_fuchsia_wlan_common__common::BssDescription,
11979 D,
11980 val_ref,
11981 decoder,
11982 inner_offset,
11983 inner_depth
11984 )?;
11985 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11986 {
11987 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11988 }
11989 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11990 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11991 }
11992 }
11993
11994 next_offset += envelope_size;
11995
11996 while next_offset < end_offset {
11998 _next_ordinal_to_read += 1;
11999 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12000 next_offset += envelope_size;
12001 }
12002
12003 Ok(())
12004 }
12005 }
12006
12007 impl WlanFullmacImplSaeHandshakeRespRequest {
12008 #[inline(always)]
12009 fn max_ordinal_present(&self) -> u64 {
12010 if let Some(_) = self.status_code {
12011 return 2;
12012 }
12013 if let Some(_) = self.peer_sta_address {
12014 return 1;
12015 }
12016 0
12017 }
12018 }
12019
12020 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
12021 type Borrowed<'a> = &'a Self;
12022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12023 value
12024 }
12025 }
12026
12027 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
12028 type Owned = Self;
12029
12030 #[inline(always)]
12031 fn inline_align(_context: fidl::encoding::Context) -> usize {
12032 8
12033 }
12034
12035 #[inline(always)]
12036 fn inline_size(_context: fidl::encoding::Context) -> usize {
12037 16
12038 }
12039 }
12040
12041 unsafe impl<D: fidl::encoding::ResourceDialect>
12042 fidl::encoding::Encode<WlanFullmacImplSaeHandshakeRespRequest, D>
12043 for &WlanFullmacImplSaeHandshakeRespRequest
12044 {
12045 unsafe fn encode(
12046 self,
12047 encoder: &mut fidl::encoding::Encoder<'_, D>,
12048 offset: usize,
12049 mut depth: fidl::encoding::Depth,
12050 ) -> fidl::Result<()> {
12051 encoder.debug_check_bounds::<WlanFullmacImplSaeHandshakeRespRequest>(offset);
12052 let max_ordinal: u64 = self.max_ordinal_present();
12054 encoder.write_num(max_ordinal, offset);
12055 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12056 if max_ordinal == 0 {
12058 return Ok(());
12059 }
12060 depth.increment()?;
12061 let envelope_size = 8;
12062 let bytes_len = max_ordinal as usize * envelope_size;
12063 #[allow(unused_variables)]
12064 let offset = encoder.out_of_line_offset(bytes_len);
12065 let mut _prev_end_offset: usize = 0;
12066 if 1 > max_ordinal {
12067 return Ok(());
12068 }
12069
12070 let cur_offset: usize = (1 - 1) * envelope_size;
12073
12074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12076
12077 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
12082 self.peer_sta_address
12083 .as_ref()
12084 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
12085 encoder,
12086 offset + cur_offset,
12087 depth,
12088 )?;
12089
12090 _prev_end_offset = cur_offset + envelope_size;
12091 if 2 > max_ordinal {
12092 return Ok(());
12093 }
12094
12095 let cur_offset: usize = (2 - 1) * envelope_size;
12098
12099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12101
12102 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
12107 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
12108 encoder, offset + cur_offset, depth
12109 )?;
12110
12111 _prev_end_offset = cur_offset + envelope_size;
12112
12113 Ok(())
12114 }
12115 }
12116
12117 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12118 for WlanFullmacImplSaeHandshakeRespRequest
12119 {
12120 #[inline(always)]
12121 fn new_empty() -> Self {
12122 Self::default()
12123 }
12124
12125 unsafe fn decode(
12126 &mut self,
12127 decoder: &mut fidl::encoding::Decoder<'_, D>,
12128 offset: usize,
12129 mut depth: fidl::encoding::Depth,
12130 ) -> fidl::Result<()> {
12131 decoder.debug_check_bounds::<Self>(offset);
12132 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12133 None => return Err(fidl::Error::NotNullable),
12134 Some(len) => len,
12135 };
12136 if len == 0 {
12138 return Ok(());
12139 };
12140 depth.increment()?;
12141 let envelope_size = 8;
12142 let bytes_len = len * envelope_size;
12143 let offset = decoder.out_of_line_offset(bytes_len)?;
12144 let mut _next_ordinal_to_read = 0;
12146 let mut next_offset = offset;
12147 let end_offset = offset + bytes_len;
12148 _next_ordinal_to_read += 1;
12149 if next_offset >= end_offset {
12150 return Ok(());
12151 }
12152
12153 while _next_ordinal_to_read < 1 {
12155 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12156 _next_ordinal_to_read += 1;
12157 next_offset += envelope_size;
12158 }
12159
12160 let next_out_of_line = decoder.next_out_of_line();
12161 let handles_before = decoder.remaining_handles();
12162 if let Some((inlined, num_bytes, num_handles)) =
12163 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12164 {
12165 let member_inline_size =
12166 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
12167 decoder.context,
12168 );
12169 if inlined != (member_inline_size <= 4) {
12170 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12171 }
12172 let inner_offset;
12173 let mut inner_depth = depth.clone();
12174 if inlined {
12175 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12176 inner_offset = next_offset;
12177 } else {
12178 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12179 inner_depth.increment()?;
12180 }
12181 let val_ref = self
12182 .peer_sta_address
12183 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
12184 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
12196 if next_offset >= end_offset {
12197 return Ok(());
12198 }
12199
12200 while _next_ordinal_to_read < 2 {
12202 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12203 _next_ordinal_to_read += 1;
12204 next_offset += envelope_size;
12205 }
12206
12207 let next_out_of_line = decoder.next_out_of_line();
12208 let handles_before = decoder.remaining_handles();
12209 if let Some((inlined, num_bytes, num_handles)) =
12210 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12211 {
12212 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12213 if inlined != (member_inline_size <= 4) {
12214 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12215 }
12216 let inner_offset;
12217 let mut inner_depth = depth.clone();
12218 if inlined {
12219 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12220 inner_offset = next_offset;
12221 } else {
12222 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12223 inner_depth.increment()?;
12224 }
12225 let val_ref = self.status_code.get_or_insert_with(|| {
12226 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
12227 });
12228 fidl::decode!(
12229 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
12230 D,
12231 val_ref,
12232 decoder,
12233 inner_offset,
12234 inner_depth
12235 )?;
12236 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12237 {
12238 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12239 }
12240 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12241 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12242 }
12243 }
12244
12245 next_offset += envelope_size;
12246
12247 while next_offset < end_offset {
12249 _next_ordinal_to_read += 1;
12250 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12251 next_offset += envelope_size;
12252 }
12253
12254 Ok(())
12255 }
12256 }
12257
12258 impl WlanFullmacImplSetKeysRequest {
12259 #[inline(always)]
12260 fn max_ordinal_present(&self) -> u64 {
12261 if let Some(_) = self.key_descriptors {
12262 return 2;
12263 }
12264 if let Some(_) = self.keylist {
12265 return 1;
12266 }
12267 0
12268 }
12269 }
12270
12271 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysRequest {
12272 type Borrowed<'a> = &'a Self;
12273 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12274 value
12275 }
12276 }
12277
12278 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysRequest {
12279 type Owned = Self;
12280
12281 #[inline(always)]
12282 fn inline_align(_context: fidl::encoding::Context) -> usize {
12283 8
12284 }
12285
12286 #[inline(always)]
12287 fn inline_size(_context: fidl::encoding::Context) -> usize {
12288 16
12289 }
12290 }
12291
12292 unsafe impl<D: fidl::encoding::ResourceDialect>
12293 fidl::encoding::Encode<WlanFullmacImplSetKeysRequest, D>
12294 for &WlanFullmacImplSetKeysRequest
12295 {
12296 unsafe fn encode(
12297 self,
12298 encoder: &mut fidl::encoding::Encoder<'_, D>,
12299 offset: usize,
12300 mut depth: fidl::encoding::Depth,
12301 ) -> fidl::Result<()> {
12302 encoder.debug_check_bounds::<WlanFullmacImplSetKeysRequest>(offset);
12303 let max_ordinal: u64 = self.max_ordinal_present();
12305 encoder.write_num(max_ordinal, offset);
12306 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12307 if max_ordinal == 0 {
12309 return Ok(());
12310 }
12311 depth.increment()?;
12312 let envelope_size = 8;
12313 let bytes_len = max_ordinal as usize * envelope_size;
12314 #[allow(unused_variables)]
12315 let offset = encoder.out_of_line_offset(bytes_len);
12316 let mut _prev_end_offset: usize = 0;
12317 if 1 > max_ordinal {
12318 return Ok(());
12319 }
12320
12321 let cur_offset: usize = (1 - 1) * envelope_size;
12324
12325 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12327
12328 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D>(
12333 self.keylist.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4> as fidl::encoding::ValueTypeMarker>::borrow),
12334 encoder, offset + cur_offset, depth
12335 )?;
12336
12337 _prev_end_offset = cur_offset + envelope_size;
12338 if 2 > max_ordinal {
12339 return Ok(());
12340 }
12341
12342 let cur_offset: usize = (2 - 1) * envelope_size;
12345
12346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12348
12349 fidl::encoding::encode_in_envelope_optional::<
12354 fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>,
12355 D,
12356 >(
12357 self.key_descriptors.as_ref().map(
12358 <fidl::encoding::Vector<
12359 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12360 4,
12361 > as fidl::encoding::ValueTypeMarker>::borrow,
12362 ),
12363 encoder,
12364 offset + cur_offset,
12365 depth,
12366 )?;
12367
12368 _prev_end_offset = cur_offset + envelope_size;
12369
12370 Ok(())
12371 }
12372 }
12373
12374 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12375 for WlanFullmacImplSetKeysRequest
12376 {
12377 #[inline(always)]
12378 fn new_empty() -> Self {
12379 Self::default()
12380 }
12381
12382 unsafe fn decode(
12383 &mut self,
12384 decoder: &mut fidl::encoding::Decoder<'_, D>,
12385 offset: usize,
12386 mut depth: fidl::encoding::Depth,
12387 ) -> fidl::Result<()> {
12388 decoder.debug_check_bounds::<Self>(offset);
12389 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12390 None => return Err(fidl::Error::NotNullable),
12391 Some(len) => len,
12392 };
12393 if len == 0 {
12395 return Ok(());
12396 };
12397 depth.increment()?;
12398 let envelope_size = 8;
12399 let bytes_len = len * envelope_size;
12400 let offset = decoder.out_of_line_offset(bytes_len)?;
12401 let mut _next_ordinal_to_read = 0;
12403 let mut next_offset = offset;
12404 let end_offset = offset + bytes_len;
12405 _next_ordinal_to_read += 1;
12406 if next_offset >= end_offset {
12407 return Ok(());
12408 }
12409
12410 while _next_ordinal_to_read < 1 {
12412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12413 _next_ordinal_to_read += 1;
12414 next_offset += envelope_size;
12415 }
12416
12417 let next_out_of_line = decoder.next_out_of_line();
12418 let handles_before = decoder.remaining_handles();
12419 if let Some((inlined, num_bytes, num_handles)) =
12420 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12421 {
12422 let member_inline_size = <fidl::encoding::Vector<
12423 fidl_fuchsia_wlan_common__common::WlanKeyConfig,
12424 4,
12425 > as fidl::encoding::TypeMarker>::inline_size(
12426 decoder.context
12427 );
12428 if inlined != (member_inline_size <= 4) {
12429 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12430 }
12431 let inner_offset;
12432 let mut inner_depth = depth.clone();
12433 if inlined {
12434 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12435 inner_offset = next_offset;
12436 } else {
12437 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12438 inner_depth.increment()?;
12439 }
12440 let val_ref =
12441 self.keylist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D));
12442 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12443 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12444 {
12445 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12446 }
12447 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12448 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12449 }
12450 }
12451
12452 next_offset += envelope_size;
12453 _next_ordinal_to_read += 1;
12454 if next_offset >= end_offset {
12455 return Ok(());
12456 }
12457
12458 while _next_ordinal_to_read < 2 {
12460 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12461 _next_ordinal_to_read += 1;
12462 next_offset += envelope_size;
12463 }
12464
12465 let next_out_of_line = decoder.next_out_of_line();
12466 let handles_before = decoder.remaining_handles();
12467 if let Some((inlined, num_bytes, num_handles)) =
12468 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12469 {
12470 let member_inline_size = <fidl::encoding::Vector<
12471 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12472 4,
12473 > as fidl::encoding::TypeMarker>::inline_size(
12474 decoder.context
12475 );
12476 if inlined != (member_inline_size <= 4) {
12477 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12478 }
12479 let inner_offset;
12480 let mut inner_depth = depth.clone();
12481 if inlined {
12482 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12483 inner_offset = next_offset;
12484 } else {
12485 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12486 inner_depth.increment()?;
12487 }
12488 let val_ref =
12489 self.key_descriptors.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D));
12490 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12491 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12492 {
12493 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12494 }
12495 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12496 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12497 }
12498 }
12499
12500 next_offset += envelope_size;
12501
12502 while next_offset < end_offset {
12504 _next_ordinal_to_read += 1;
12505 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12506 next_offset += envelope_size;
12507 }
12508
12509 Ok(())
12510 }
12511 }
12512
12513 impl WlanFullmacImplStartBssRequest {
12514 #[inline(always)]
12515 fn max_ordinal_present(&self) -> u64 {
12516 if let Some(_) = self.vendor_ie {
12517 return 7;
12518 }
12519 if let Some(_) = self.rsne {
12520 return 6;
12521 }
12522 if let Some(_) = self.channel {
12523 return 5;
12524 }
12525 if let Some(_) = self.dtim_period {
12526 return 4;
12527 }
12528 if let Some(_) = self.beacon_period {
12529 return 3;
12530 }
12531 if let Some(_) = self.bss_type {
12532 return 2;
12533 }
12534 if let Some(_) = self.ssid {
12535 return 1;
12536 }
12537 0
12538 }
12539 }
12540
12541 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartBssRequest {
12542 type Borrowed<'a> = &'a Self;
12543 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12544 value
12545 }
12546 }
12547
12548 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartBssRequest {
12549 type Owned = Self;
12550
12551 #[inline(always)]
12552 fn inline_align(_context: fidl::encoding::Context) -> usize {
12553 8
12554 }
12555
12556 #[inline(always)]
12557 fn inline_size(_context: fidl::encoding::Context) -> usize {
12558 16
12559 }
12560 }
12561
12562 unsafe impl<D: fidl::encoding::ResourceDialect>
12563 fidl::encoding::Encode<WlanFullmacImplStartBssRequest, D>
12564 for &WlanFullmacImplStartBssRequest
12565 {
12566 unsafe fn encode(
12567 self,
12568 encoder: &mut fidl::encoding::Encoder<'_, D>,
12569 offset: usize,
12570 mut depth: fidl::encoding::Depth,
12571 ) -> fidl::Result<()> {
12572 encoder.debug_check_bounds::<WlanFullmacImplStartBssRequest>(offset);
12573 let max_ordinal: u64 = self.max_ordinal_present();
12575 encoder.write_num(max_ordinal, offset);
12576 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12577 if max_ordinal == 0 {
12579 return Ok(());
12580 }
12581 depth.increment()?;
12582 let envelope_size = 8;
12583 let bytes_len = max_ordinal as usize * envelope_size;
12584 #[allow(unused_variables)]
12585 let offset = encoder.out_of_line_offset(bytes_len);
12586 let mut _prev_end_offset: usize = 0;
12587 if 1 > max_ordinal {
12588 return Ok(());
12589 }
12590
12591 let cur_offset: usize = (1 - 1) * envelope_size;
12594
12595 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12597
12598 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
12603 self.ssid.as_ref().map(
12604 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
12605 ),
12606 encoder,
12607 offset + cur_offset,
12608 depth,
12609 )?;
12610
12611 _prev_end_offset = cur_offset + envelope_size;
12612 if 2 > max_ordinal {
12613 return Ok(());
12614 }
12615
12616 let cur_offset: usize = (2 - 1) * envelope_size;
12619
12620 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12622
12623 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssType, D>(
12628 self.bss_type.as_ref().map(<fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::ValueTypeMarker>::borrow),
12629 encoder, offset + cur_offset, depth
12630 )?;
12631
12632 _prev_end_offset = cur_offset + envelope_size;
12633 if 3 > max_ordinal {
12634 return Ok(());
12635 }
12636
12637 let cur_offset: usize = (3 - 1) * envelope_size;
12640
12641 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12643
12644 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12649 self.beacon_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12650 encoder,
12651 offset + cur_offset,
12652 depth,
12653 )?;
12654
12655 _prev_end_offset = cur_offset + envelope_size;
12656 if 4 > max_ordinal {
12657 return Ok(());
12658 }
12659
12660 let cur_offset: usize = (4 - 1) * envelope_size;
12663
12664 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12666
12667 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12672 self.dtim_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12673 encoder,
12674 offset + cur_offset,
12675 depth,
12676 )?;
12677
12678 _prev_end_offset = cur_offset + envelope_size;
12679 if 5 > max_ordinal {
12680 return Ok(());
12681 }
12682
12683 let cur_offset: usize = (5 - 1) * envelope_size;
12686
12687 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12689
12690 fidl::encoding::encode_in_envelope_optional::<u8, D>(
12695 self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
12696 encoder,
12697 offset + cur_offset,
12698 depth,
12699 )?;
12700
12701 _prev_end_offset = cur_offset + envelope_size;
12702 if 6 > max_ordinal {
12703 return Ok(());
12704 }
12705
12706 let cur_offset: usize = (6 - 1) * envelope_size;
12709
12710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12712
12713 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
12718 self.rsne.as_ref().map(
12719 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
12720 ),
12721 encoder,
12722 offset + cur_offset,
12723 depth,
12724 )?;
12725
12726 _prev_end_offset = cur_offset + envelope_size;
12727 if 7 > max_ordinal {
12728 return Ok(());
12729 }
12730
12731 let cur_offset: usize = (7 - 1) * envelope_size;
12734
12735 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12737
12738 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
12743 self.vendor_ie.as_ref().map(
12744 <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
12745 ),
12746 encoder,
12747 offset + cur_offset,
12748 depth,
12749 )?;
12750
12751 _prev_end_offset = cur_offset + envelope_size;
12752
12753 Ok(())
12754 }
12755 }
12756
12757 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12758 for WlanFullmacImplStartBssRequest
12759 {
12760 #[inline(always)]
12761 fn new_empty() -> Self {
12762 Self::default()
12763 }
12764
12765 unsafe fn decode(
12766 &mut self,
12767 decoder: &mut fidl::encoding::Decoder<'_, D>,
12768 offset: usize,
12769 mut depth: fidl::encoding::Depth,
12770 ) -> fidl::Result<()> {
12771 decoder.debug_check_bounds::<Self>(offset);
12772 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12773 None => return Err(fidl::Error::NotNullable),
12774 Some(len) => len,
12775 };
12776 if len == 0 {
12778 return Ok(());
12779 };
12780 depth.increment()?;
12781 let envelope_size = 8;
12782 let bytes_len = len * envelope_size;
12783 let offset = decoder.out_of_line_offset(bytes_len)?;
12784 let mut _next_ordinal_to_read = 0;
12786 let mut next_offset = offset;
12787 let end_offset = offset + bytes_len;
12788 _next_ordinal_to_read += 1;
12789 if next_offset >= end_offset {
12790 return Ok(());
12791 }
12792
12793 while _next_ordinal_to_read < 1 {
12795 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12796 _next_ordinal_to_read += 1;
12797 next_offset += envelope_size;
12798 }
12799
12800 let next_out_of_line = decoder.next_out_of_line();
12801 let handles_before = decoder.remaining_handles();
12802 if let Some((inlined, num_bytes, num_handles)) =
12803 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12804 {
12805 let member_inline_size =
12806 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
12807 decoder.context,
12808 );
12809 if inlined != (member_inline_size <= 4) {
12810 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12811 }
12812 let inner_offset;
12813 let mut inner_depth = depth.clone();
12814 if inlined {
12815 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12816 inner_offset = next_offset;
12817 } else {
12818 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12819 inner_depth.increment()?;
12820 }
12821 let val_ref = self
12822 .ssid
12823 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
12824 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12853 if inlined != (member_inline_size <= 4) {
12854 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12855 }
12856 let inner_offset;
12857 let mut inner_depth = depth.clone();
12858 if inlined {
12859 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12860 inner_offset = next_offset;
12861 } else {
12862 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12863 inner_depth.increment()?;
12864 }
12865 let val_ref = self.bss_type.get_or_insert_with(|| {
12866 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssType, D)
12867 });
12868 fidl::decode!(
12869 fidl_fuchsia_wlan_common__common::BssType,
12870 D,
12871 val_ref,
12872 decoder,
12873 inner_offset,
12874 inner_depth
12875 )?;
12876 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12877 {
12878 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12879 }
12880 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12881 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12882 }
12883 }
12884
12885 next_offset += envelope_size;
12886 _next_ordinal_to_read += 1;
12887 if next_offset >= end_offset {
12888 return Ok(());
12889 }
12890
12891 while _next_ordinal_to_read < 3 {
12893 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12894 _next_ordinal_to_read += 1;
12895 next_offset += envelope_size;
12896 }
12897
12898 let next_out_of_line = decoder.next_out_of_line();
12899 let handles_before = decoder.remaining_handles();
12900 if let Some((inlined, num_bytes, num_handles)) =
12901 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12902 {
12903 let member_inline_size =
12904 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12905 if inlined != (member_inline_size <= 4) {
12906 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12907 }
12908 let inner_offset;
12909 let mut inner_depth = depth.clone();
12910 if inlined {
12911 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12912 inner_offset = next_offset;
12913 } else {
12914 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12915 inner_depth.increment()?;
12916 }
12917 let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12918 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12919 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12920 {
12921 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12922 }
12923 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12924 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12925 }
12926 }
12927
12928 next_offset += envelope_size;
12929 _next_ordinal_to_read += 1;
12930 if next_offset >= end_offset {
12931 return Ok(());
12932 }
12933
12934 while _next_ordinal_to_read < 4 {
12936 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12937 _next_ordinal_to_read += 1;
12938 next_offset += envelope_size;
12939 }
12940
12941 let next_out_of_line = decoder.next_out_of_line();
12942 let handles_before = decoder.remaining_handles();
12943 if let Some((inlined, num_bytes, num_handles)) =
12944 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12945 {
12946 let member_inline_size =
12947 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12948 if inlined != (member_inline_size <= 4) {
12949 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12950 }
12951 let inner_offset;
12952 let mut inner_depth = depth.clone();
12953 if inlined {
12954 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12955 inner_offset = next_offset;
12956 } else {
12957 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12958 inner_depth.increment()?;
12959 }
12960 let val_ref = self.dtim_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12961 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12963 {
12964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12965 }
12966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12968 }
12969 }
12970
12971 next_offset += envelope_size;
12972 _next_ordinal_to_read += 1;
12973 if next_offset >= end_offset {
12974 return Ok(());
12975 }
12976
12977 while _next_ordinal_to_read < 5 {
12979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12980 _next_ordinal_to_read += 1;
12981 next_offset += envelope_size;
12982 }
12983
12984 let next_out_of_line = decoder.next_out_of_line();
12985 let handles_before = decoder.remaining_handles();
12986 if let Some((inlined, num_bytes, num_handles)) =
12987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12988 {
12989 let member_inline_size =
12990 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12991 if inlined != (member_inline_size <= 4) {
12992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12993 }
12994 let inner_offset;
12995 let mut inner_depth = depth.clone();
12996 if inlined {
12997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12998 inner_offset = next_offset;
12999 } else {
13000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13001 inner_depth.increment()?;
13002 }
13003 let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
13004 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
13005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13006 {
13007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13008 }
13009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13011 }
13012 }
13013
13014 next_offset += envelope_size;
13015 _next_ordinal_to_read += 1;
13016 if next_offset >= end_offset {
13017 return Ok(());
13018 }
13019
13020 while _next_ordinal_to_read < 6 {
13022 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13023 _next_ordinal_to_read += 1;
13024 next_offset += envelope_size;
13025 }
13026
13027 let next_out_of_line = decoder.next_out_of_line();
13028 let handles_before = decoder.remaining_handles();
13029 if let Some((inlined, num_bytes, num_handles)) =
13030 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13031 {
13032 let member_inline_size =
13033 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
13034 decoder.context,
13035 );
13036 if inlined != (member_inline_size <= 4) {
13037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13038 }
13039 let inner_offset;
13040 let mut inner_depth = depth.clone();
13041 if inlined {
13042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13043 inner_offset = next_offset;
13044 } else {
13045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13046 inner_depth.increment()?;
13047 }
13048 let val_ref = self
13049 .rsne
13050 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
13051 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
13052 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13053 {
13054 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13055 }
13056 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13057 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13058 }
13059 }
13060
13061 next_offset += envelope_size;
13062 _next_ordinal_to_read += 1;
13063 if next_offset >= end_offset {
13064 return Ok(());
13065 }
13066
13067 while _next_ordinal_to_read < 7 {
13069 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13070 _next_ordinal_to_read += 1;
13071 next_offset += envelope_size;
13072 }
13073
13074 let next_out_of_line = decoder.next_out_of_line();
13075 let handles_before = decoder.remaining_handles();
13076 if let Some((inlined, num_bytes, num_handles)) =
13077 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13078 {
13079 let member_inline_size =
13080 <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
13081 decoder.context,
13082 );
13083 if inlined != (member_inline_size <= 4) {
13084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13085 }
13086 let inner_offset;
13087 let mut inner_depth = depth.clone();
13088 if inlined {
13089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13090 inner_offset = next_offset;
13091 } else {
13092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13093 inner_depth.increment()?;
13094 }
13095 let val_ref = self
13096 .vendor_ie
13097 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
13098 fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
13099 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13100 {
13101 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13102 }
13103 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13104 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13105 }
13106 }
13107
13108 next_offset += envelope_size;
13109
13110 while next_offset < end_offset {
13112 _next_ordinal_to_read += 1;
13113 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13114 next_offset += envelope_size;
13115 }
13116
13117 Ok(())
13118 }
13119 }
13120
13121 impl WlanFullmacImplStartScanRequest {
13122 #[inline(always)]
13123 fn max_ordinal_present(&self) -> u64 {
13124 if let Some(_) = self.max_channel_time {
13125 return 6;
13126 }
13127 if let Some(_) = self.min_channel_time {
13128 return 5;
13129 }
13130 if let Some(_) = self.ssids {
13131 return 4;
13132 }
13133 if let Some(_) = self.channels {
13134 return 3;
13135 }
13136 if let Some(_) = self.scan_type {
13137 return 2;
13138 }
13139 if let Some(_) = self.txn_id {
13140 return 1;
13141 }
13142 0
13143 }
13144 }
13145
13146 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartScanRequest {
13147 type Borrowed<'a> = &'a Self;
13148 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13149 value
13150 }
13151 }
13152
13153 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartScanRequest {
13154 type Owned = Self;
13155
13156 #[inline(always)]
13157 fn inline_align(_context: fidl::encoding::Context) -> usize {
13158 8
13159 }
13160
13161 #[inline(always)]
13162 fn inline_size(_context: fidl::encoding::Context) -> usize {
13163 16
13164 }
13165 }
13166
13167 unsafe impl<D: fidl::encoding::ResourceDialect>
13168 fidl::encoding::Encode<WlanFullmacImplStartScanRequest, D>
13169 for &WlanFullmacImplStartScanRequest
13170 {
13171 unsafe fn encode(
13172 self,
13173 encoder: &mut fidl::encoding::Encoder<'_, D>,
13174 offset: usize,
13175 mut depth: fidl::encoding::Depth,
13176 ) -> fidl::Result<()> {
13177 encoder.debug_check_bounds::<WlanFullmacImplStartScanRequest>(offset);
13178 let max_ordinal: u64 = self.max_ordinal_present();
13180 encoder.write_num(max_ordinal, offset);
13181 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13182 if max_ordinal == 0 {
13184 return Ok(());
13185 }
13186 depth.increment()?;
13187 let envelope_size = 8;
13188 let bytes_len = max_ordinal as usize * envelope_size;
13189 #[allow(unused_variables)]
13190 let offset = encoder.out_of_line_offset(bytes_len);
13191 let mut _prev_end_offset: usize = 0;
13192 if 1 > max_ordinal {
13193 return Ok(());
13194 }
13195
13196 let cur_offset: usize = (1 - 1) * envelope_size;
13199
13200 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13202
13203 fidl::encoding::encode_in_envelope_optional::<u64, D>(
13208 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
13209 encoder,
13210 offset + cur_offset,
13211 depth,
13212 )?;
13213
13214 _prev_end_offset = cur_offset + envelope_size;
13215 if 2 > max_ordinal {
13216 return Ok(());
13217 }
13218
13219 let cur_offset: usize = (2 - 1) * envelope_size;
13222
13223 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13225
13226 fidl::encoding::encode_in_envelope_optional::<WlanScanType, D>(
13231 self.scan_type
13232 .as_ref()
13233 .map(<WlanScanType as fidl::encoding::ValueTypeMarker>::borrow),
13234 encoder,
13235 offset + cur_offset,
13236 depth,
13237 )?;
13238
13239 _prev_end_offset = cur_offset + envelope_size;
13240 if 3 > max_ordinal {
13241 return Ok(());
13242 }
13243
13244 let cur_offset: usize = (3 - 1) * envelope_size;
13247
13248 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13250
13251 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
13256 self.channels.as_ref().map(
13257 <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
13258 ),
13259 encoder,
13260 offset + cur_offset,
13261 depth,
13262 )?;
13263
13264 _prev_end_offset = cur_offset + envelope_size;
13265 if 4 > max_ordinal {
13266 return Ok(());
13267 }
13268
13269 let cur_offset: usize = (4 - 1) * envelope_size;
13272
13273 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13275
13276 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>(
13281 self.ssids.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow),
13282 encoder, offset + cur_offset, depth
13283 )?;
13284
13285 _prev_end_offset = cur_offset + envelope_size;
13286 if 5 > max_ordinal {
13287 return Ok(());
13288 }
13289
13290 let cur_offset: usize = (5 - 1) * envelope_size;
13293
13294 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13296
13297 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13302 self.min_channel_time
13303 .as_ref()
13304 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13305 encoder,
13306 offset + cur_offset,
13307 depth,
13308 )?;
13309
13310 _prev_end_offset = cur_offset + envelope_size;
13311 if 6 > max_ordinal {
13312 return Ok(());
13313 }
13314
13315 let cur_offset: usize = (6 - 1) * envelope_size;
13318
13319 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13321
13322 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13327 self.max_channel_time
13328 .as_ref()
13329 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13330 encoder,
13331 offset + cur_offset,
13332 depth,
13333 )?;
13334
13335 _prev_end_offset = cur_offset + envelope_size;
13336
13337 Ok(())
13338 }
13339 }
13340
13341 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13342 for WlanFullmacImplStartScanRequest
13343 {
13344 #[inline(always)]
13345 fn new_empty() -> Self {
13346 Self::default()
13347 }
13348
13349 unsafe fn decode(
13350 &mut self,
13351 decoder: &mut fidl::encoding::Decoder<'_, D>,
13352 offset: usize,
13353 mut depth: fidl::encoding::Depth,
13354 ) -> fidl::Result<()> {
13355 decoder.debug_check_bounds::<Self>(offset);
13356 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13357 None => return Err(fidl::Error::NotNullable),
13358 Some(len) => len,
13359 };
13360 if len == 0 {
13362 return Ok(());
13363 };
13364 depth.increment()?;
13365 let envelope_size = 8;
13366 let bytes_len = len * envelope_size;
13367 let offset = decoder.out_of_line_offset(bytes_len)?;
13368 let mut _next_ordinal_to_read = 0;
13370 let mut next_offset = offset;
13371 let end_offset = offset + bytes_len;
13372 _next_ordinal_to_read += 1;
13373 if next_offset >= end_offset {
13374 return Ok(());
13375 }
13376
13377 while _next_ordinal_to_read < 1 {
13379 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13380 _next_ordinal_to_read += 1;
13381 next_offset += envelope_size;
13382 }
13383
13384 let next_out_of_line = decoder.next_out_of_line();
13385 let handles_before = decoder.remaining_handles();
13386 if let Some((inlined, num_bytes, num_handles)) =
13387 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13388 {
13389 let member_inline_size =
13390 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13391 if inlined != (member_inline_size <= 4) {
13392 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13393 }
13394 let inner_offset;
13395 let mut inner_depth = depth.clone();
13396 if inlined {
13397 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13398 inner_offset = next_offset;
13399 } else {
13400 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13401 inner_depth.increment()?;
13402 }
13403 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
13404 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
13405 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13406 {
13407 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13408 }
13409 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13410 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13411 }
13412 }
13413
13414 next_offset += envelope_size;
13415 _next_ordinal_to_read += 1;
13416 if next_offset >= end_offset {
13417 return Ok(());
13418 }
13419
13420 while _next_ordinal_to_read < 2 {
13422 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13423 _next_ordinal_to_read += 1;
13424 next_offset += envelope_size;
13425 }
13426
13427 let next_out_of_line = decoder.next_out_of_line();
13428 let handles_before = decoder.remaining_handles();
13429 if let Some((inlined, num_bytes, num_handles)) =
13430 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13431 {
13432 let member_inline_size =
13433 <WlanScanType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13434 if inlined != (member_inline_size <= 4) {
13435 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13436 }
13437 let inner_offset;
13438 let mut inner_depth = depth.clone();
13439 if inlined {
13440 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13441 inner_offset = next_offset;
13442 } else {
13443 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13444 inner_depth.increment()?;
13445 }
13446 let val_ref =
13447 self.scan_type.get_or_insert_with(|| fidl::new_empty!(WlanScanType, D));
13448 fidl::decode!(WlanScanType, D, val_ref, decoder, inner_offset, inner_depth)?;
13449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13450 {
13451 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13452 }
13453 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13454 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13455 }
13456 }
13457
13458 next_offset += envelope_size;
13459 _next_ordinal_to_read += 1;
13460 if next_offset >= end_offset {
13461 return Ok(());
13462 }
13463
13464 while _next_ordinal_to_read < 3 {
13466 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13467 _next_ordinal_to_read += 1;
13468 next_offset += envelope_size;
13469 }
13470
13471 let next_out_of_line = decoder.next_out_of_line();
13472 let handles_before = decoder.remaining_handles();
13473 if let Some((inlined, num_bytes, num_handles)) =
13474 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13475 {
13476 let member_inline_size =
13477 <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
13478 decoder.context,
13479 );
13480 if inlined != (member_inline_size <= 4) {
13481 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13482 }
13483 let inner_offset;
13484 let mut inner_depth = depth.clone();
13485 if inlined {
13486 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13487 inner_offset = next_offset;
13488 } else {
13489 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13490 inner_depth.increment()?;
13491 }
13492 let val_ref = self
13493 .channels
13494 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
13495 fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
13496 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13497 {
13498 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13499 }
13500 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13501 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13502 }
13503 }
13504
13505 next_offset += envelope_size;
13506 _next_ordinal_to_read += 1;
13507 if next_offset >= end_offset {
13508 return Ok(());
13509 }
13510
13511 while _next_ordinal_to_read < 4 {
13513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13514 _next_ordinal_to_read += 1;
13515 next_offset += envelope_size;
13516 }
13517
13518 let next_out_of_line = decoder.next_out_of_line();
13519 let handles_before = decoder.remaining_handles();
13520 if let Some((inlined, num_bytes, num_handles)) =
13521 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13522 {
13523 let member_inline_size = <fidl::encoding::UnboundedVector<
13524 fidl::encoding::Vector<u8, 32>,
13525 > as fidl::encoding::TypeMarker>::inline_size(
13526 decoder.context
13527 );
13528 if inlined != (member_inline_size <= 4) {
13529 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13530 }
13531 let inner_offset;
13532 let mut inner_depth = depth.clone();
13533 if inlined {
13534 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13535 inner_offset = next_offset;
13536 } else {
13537 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13538 inner_depth.increment()?;
13539 }
13540 let val_ref = self.ssids.get_or_insert_with(|| {
13541 fidl::new_empty!(
13542 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13543 D
13544 )
13545 });
13546 fidl::decode!(
13547 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13548 D,
13549 val_ref,
13550 decoder,
13551 inner_offset,
13552 inner_depth
13553 )?;
13554 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13555 {
13556 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13557 }
13558 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13559 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13560 }
13561 }
13562
13563 next_offset += envelope_size;
13564 _next_ordinal_to_read += 1;
13565 if next_offset >= end_offset {
13566 return Ok(());
13567 }
13568
13569 while _next_ordinal_to_read < 5 {
13571 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13572 _next_ordinal_to_read += 1;
13573 next_offset += envelope_size;
13574 }
13575
13576 let next_out_of_line = decoder.next_out_of_line();
13577 let handles_before = decoder.remaining_handles();
13578 if let Some((inlined, num_bytes, num_handles)) =
13579 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13580 {
13581 let member_inline_size =
13582 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13583 if inlined != (member_inline_size <= 4) {
13584 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13585 }
13586 let inner_offset;
13587 let mut inner_depth = depth.clone();
13588 if inlined {
13589 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13590 inner_offset = next_offset;
13591 } else {
13592 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13593 inner_depth.increment()?;
13594 }
13595 let val_ref = self.min_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13596 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13597 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13598 {
13599 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13600 }
13601 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13602 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13603 }
13604 }
13605
13606 next_offset += envelope_size;
13607 _next_ordinal_to_read += 1;
13608 if next_offset >= end_offset {
13609 return Ok(());
13610 }
13611
13612 while _next_ordinal_to_read < 6 {
13614 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13615 _next_ordinal_to_read += 1;
13616 next_offset += envelope_size;
13617 }
13618
13619 let next_out_of_line = decoder.next_out_of_line();
13620 let handles_before = decoder.remaining_handles();
13621 if let Some((inlined, num_bytes, num_handles)) =
13622 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13623 {
13624 let member_inline_size =
13625 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13626 if inlined != (member_inline_size <= 4) {
13627 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13628 }
13629 let inner_offset;
13630 let mut inner_depth = depth.clone();
13631 if inlined {
13632 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13633 inner_offset = next_offset;
13634 } else {
13635 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13636 inner_depth.increment()?;
13637 }
13638 let val_ref = self.max_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13639 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13640 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13641 {
13642 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13643 }
13644 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13645 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13646 }
13647 }
13648
13649 next_offset += envelope_size;
13650
13651 while next_offset < end_offset {
13653 _next_ordinal_to_read += 1;
13654 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13655 next_offset += envelope_size;
13656 }
13657
13658 Ok(())
13659 }
13660 }
13661
13662 impl WlanFullmacImplStopBssRequest {
13663 #[inline(always)]
13664 fn max_ordinal_present(&self) -> u64 {
13665 if let Some(_) = self.ssid {
13666 return 1;
13667 }
13668 0
13669 }
13670 }
13671
13672 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStopBssRequest {
13673 type Borrowed<'a> = &'a Self;
13674 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13675 value
13676 }
13677 }
13678
13679 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStopBssRequest {
13680 type Owned = Self;
13681
13682 #[inline(always)]
13683 fn inline_align(_context: fidl::encoding::Context) -> usize {
13684 8
13685 }
13686
13687 #[inline(always)]
13688 fn inline_size(_context: fidl::encoding::Context) -> usize {
13689 16
13690 }
13691 }
13692
13693 unsafe impl<D: fidl::encoding::ResourceDialect>
13694 fidl::encoding::Encode<WlanFullmacImplStopBssRequest, D>
13695 for &WlanFullmacImplStopBssRequest
13696 {
13697 unsafe fn encode(
13698 self,
13699 encoder: &mut fidl::encoding::Encoder<'_, D>,
13700 offset: usize,
13701 mut depth: fidl::encoding::Depth,
13702 ) -> fidl::Result<()> {
13703 encoder.debug_check_bounds::<WlanFullmacImplStopBssRequest>(offset);
13704 let max_ordinal: u64 = self.max_ordinal_present();
13706 encoder.write_num(max_ordinal, offset);
13707 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13708 if max_ordinal == 0 {
13710 return Ok(());
13711 }
13712 depth.increment()?;
13713 let envelope_size = 8;
13714 let bytes_len = max_ordinal as usize * envelope_size;
13715 #[allow(unused_variables)]
13716 let offset = encoder.out_of_line_offset(bytes_len);
13717 let mut _prev_end_offset: usize = 0;
13718 if 1 > max_ordinal {
13719 return Ok(());
13720 }
13721
13722 let cur_offset: usize = (1 - 1) * envelope_size;
13725
13726 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13728
13729 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
13734 self.ssid.as_ref().map(
13735 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
13736 ),
13737 encoder,
13738 offset + cur_offset,
13739 depth,
13740 )?;
13741
13742 _prev_end_offset = cur_offset + envelope_size;
13743
13744 Ok(())
13745 }
13746 }
13747
13748 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13749 for WlanFullmacImplStopBssRequest
13750 {
13751 #[inline(always)]
13752 fn new_empty() -> Self {
13753 Self::default()
13754 }
13755
13756 unsafe fn decode(
13757 &mut self,
13758 decoder: &mut fidl::encoding::Decoder<'_, D>,
13759 offset: usize,
13760 mut depth: fidl::encoding::Depth,
13761 ) -> fidl::Result<()> {
13762 decoder.debug_check_bounds::<Self>(offset);
13763 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13764 None => return Err(fidl::Error::NotNullable),
13765 Some(len) => len,
13766 };
13767 if len == 0 {
13769 return Ok(());
13770 };
13771 depth.increment()?;
13772 let envelope_size = 8;
13773 let bytes_len = len * envelope_size;
13774 let offset = decoder.out_of_line_offset(bytes_len)?;
13775 let mut _next_ordinal_to_read = 0;
13777 let mut next_offset = offset;
13778 let end_offset = offset + bytes_len;
13779 _next_ordinal_to_read += 1;
13780 if next_offset >= end_offset {
13781 return Ok(());
13782 }
13783
13784 while _next_ordinal_to_read < 1 {
13786 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13787 _next_ordinal_to_read += 1;
13788 next_offset += envelope_size;
13789 }
13790
13791 let next_out_of_line = decoder.next_out_of_line();
13792 let handles_before = decoder.remaining_handles();
13793 if let Some((inlined, num_bytes, num_handles)) =
13794 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13795 {
13796 let member_inline_size =
13797 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
13798 decoder.context,
13799 );
13800 if inlined != (member_inline_size <= 4) {
13801 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13802 }
13803 let inner_offset;
13804 let mut inner_depth = depth.clone();
13805 if inlined {
13806 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13807 inner_offset = next_offset;
13808 } else {
13809 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13810 inner_depth.increment()?;
13811 }
13812 let val_ref = self
13813 .ssid
13814 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
13815 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
13816 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13817 {
13818 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13819 }
13820 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13821 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13822 }
13823 }
13824
13825 next_offset += envelope_size;
13826
13827 while next_offset < end_offset {
13829 _next_ordinal_to_read += 1;
13830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13831 next_offset += envelope_size;
13832 }
13833
13834 Ok(())
13835 }
13836 }
13837
13838 impl WlanFullmacImplQueryResponse {
13839 #[inline(always)]
13840 fn max_ordinal_present(&self) -> u64 {
13841 if let Some(_) = self.band_caps {
13842 return 3;
13843 }
13844 if let Some(_) = self.role {
13845 return 2;
13846 }
13847 if let Some(_) = self.sta_addr {
13848 return 1;
13849 }
13850 0
13851 }
13852 }
13853
13854 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryResponse {
13855 type Borrowed<'a> = &'a Self;
13856 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13857 value
13858 }
13859 }
13860
13861 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryResponse {
13862 type Owned = Self;
13863
13864 #[inline(always)]
13865 fn inline_align(_context: fidl::encoding::Context) -> usize {
13866 8
13867 }
13868
13869 #[inline(always)]
13870 fn inline_size(_context: fidl::encoding::Context) -> usize {
13871 16
13872 }
13873 }
13874
13875 unsafe impl<D: fidl::encoding::ResourceDialect>
13876 fidl::encoding::Encode<WlanFullmacImplQueryResponse, D> for &WlanFullmacImplQueryResponse
13877 {
13878 unsafe fn encode(
13879 self,
13880 encoder: &mut fidl::encoding::Encoder<'_, D>,
13881 offset: usize,
13882 mut depth: fidl::encoding::Depth,
13883 ) -> fidl::Result<()> {
13884 encoder.debug_check_bounds::<WlanFullmacImplQueryResponse>(offset);
13885 let max_ordinal: u64 = self.max_ordinal_present();
13887 encoder.write_num(max_ordinal, offset);
13888 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13889 if max_ordinal == 0 {
13891 return Ok(());
13892 }
13893 depth.increment()?;
13894 let envelope_size = 8;
13895 let bytes_len = max_ordinal as usize * envelope_size;
13896 #[allow(unused_variables)]
13897 let offset = encoder.out_of_line_offset(bytes_len);
13898 let mut _prev_end_offset: usize = 0;
13899 if 1 > max_ordinal {
13900 return Ok(());
13901 }
13902
13903 let cur_offset: usize = (1 - 1) * envelope_size;
13906
13907 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13909
13910 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
13915 self.sta_addr
13916 .as_ref()
13917 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
13918 encoder,
13919 offset + cur_offset,
13920 depth,
13921 )?;
13922
13923 _prev_end_offset = cur_offset + envelope_size;
13924 if 2 > max_ordinal {
13925 return Ok(());
13926 }
13927
13928 let cur_offset: usize = (2 - 1) * envelope_size;
13931
13932 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13934
13935 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
13940 self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
13941 encoder, offset + cur_offset, depth
13942 )?;
13943
13944 _prev_end_offset = cur_offset + envelope_size;
13945 if 3 > max_ordinal {
13946 return Ok(());
13947 }
13948
13949 let cur_offset: usize = (3 - 1) * envelope_size;
13952
13953 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13955
13956 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<BandCapability, 16>, D>(
13961 self.band_caps.as_ref().map(<fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow),
13962 encoder, offset + cur_offset, depth
13963 )?;
13964
13965 _prev_end_offset = cur_offset + envelope_size;
13966
13967 Ok(())
13968 }
13969 }
13970
13971 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13972 for WlanFullmacImplQueryResponse
13973 {
13974 #[inline(always)]
13975 fn new_empty() -> Self {
13976 Self::default()
13977 }
13978
13979 unsafe fn decode(
13980 &mut self,
13981 decoder: &mut fidl::encoding::Decoder<'_, D>,
13982 offset: usize,
13983 mut depth: fidl::encoding::Depth,
13984 ) -> fidl::Result<()> {
13985 decoder.debug_check_bounds::<Self>(offset);
13986 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13987 None => return Err(fidl::Error::NotNullable),
13988 Some(len) => len,
13989 };
13990 if len == 0 {
13992 return Ok(());
13993 };
13994 depth.increment()?;
13995 let envelope_size = 8;
13996 let bytes_len = len * envelope_size;
13997 let offset = decoder.out_of_line_offset(bytes_len)?;
13998 let mut _next_ordinal_to_read = 0;
14000 let mut next_offset = offset;
14001 let end_offset = offset + bytes_len;
14002 _next_ordinal_to_read += 1;
14003 if next_offset >= end_offset {
14004 return Ok(());
14005 }
14006
14007 while _next_ordinal_to_read < 1 {
14009 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14010 _next_ordinal_to_read += 1;
14011 next_offset += envelope_size;
14012 }
14013
14014 let next_out_of_line = decoder.next_out_of_line();
14015 let handles_before = decoder.remaining_handles();
14016 if let Some((inlined, num_bytes, num_handles)) =
14017 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14018 {
14019 let member_inline_size =
14020 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
14021 decoder.context,
14022 );
14023 if inlined != (member_inline_size <= 4) {
14024 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14025 }
14026 let inner_offset;
14027 let mut inner_depth = depth.clone();
14028 if inlined {
14029 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14030 inner_offset = next_offset;
14031 } else {
14032 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14033 inner_depth.increment()?;
14034 }
14035 let val_ref = self
14036 .sta_addr
14037 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
14038 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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_fuchsia_wlan_common__common::WlanMacRole 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.role.get_or_insert_with(|| {
14080 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
14081 });
14082 fidl::decode!(
14083 fidl_fuchsia_wlan_common__common::WlanMacRole,
14084 D,
14085 val_ref,
14086 decoder,
14087 inner_offset,
14088 inner_depth
14089 )?;
14090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14091 {
14092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14093 }
14094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14096 }
14097 }
14098
14099 next_offset += envelope_size;
14100 _next_ordinal_to_read += 1;
14101 if next_offset >= end_offset {
14102 return Ok(());
14103 }
14104
14105 while _next_ordinal_to_read < 3 {
14107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14108 _next_ordinal_to_read += 1;
14109 next_offset += envelope_size;
14110 }
14111
14112 let next_out_of_line = decoder.next_out_of_line();
14113 let handles_before = decoder.remaining_handles();
14114 if let Some((inlined, num_bytes, num_handles)) =
14115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14116 {
14117 let member_inline_size = <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14118 if inlined != (member_inline_size <= 4) {
14119 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14120 }
14121 let inner_offset;
14122 let mut inner_depth = depth.clone();
14123 if inlined {
14124 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14125 inner_offset = next_offset;
14126 } else {
14127 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14128 inner_depth.increment()?;
14129 }
14130 let val_ref = self.band_caps.get_or_insert_with(
14131 || fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
14132 );
14133 fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
14134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14135 {
14136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14137 }
14138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14140 }
14141 }
14142
14143 next_offset += envelope_size;
14144
14145 while next_offset < end_offset {
14147 _next_ordinal_to_read += 1;
14148 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14149 next_offset += envelope_size;
14150 }
14151
14152 Ok(())
14153 }
14154 }
14155}