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
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12pub enum IfaceConcurrencyType {
13 Sta,
14 Ap,
15 ApBridged,
16 P2P,
17 NanIface,
18 #[doc(hidden)]
19 __SourceBreaking {
20 unknown_ordinal: u32,
21 },
22}
23
24#[macro_export]
26macro_rules! IfaceConcurrencyTypeUnknown {
27 () => {
28 _
29 };
30}
31
32impl IfaceConcurrencyType {
33 #[inline]
34 pub fn from_primitive(prim: u32) -> Option<Self> {
35 match prim {
36 1 => Some(Self::Sta),
37 2 => Some(Self::Ap),
38 3 => Some(Self::ApBridged),
39 4 => Some(Self::P2P),
40 5 => Some(Self::NanIface),
41 _ => None,
42 }
43 }
44
45 #[inline]
46 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
47 match prim {
48 1 => Self::Sta,
49 2 => Self::Ap,
50 3 => Self::ApBridged,
51 4 => Self::P2P,
52 5 => Self::NanIface,
53 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
54 }
55 }
56
57 #[inline]
58 pub fn unknown() -> Self {
59 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
60 }
61
62 #[inline]
63 pub const fn into_primitive(self) -> u32 {
64 match self {
65 Self::Sta => 1,
66 Self::Ap => 2,
67 Self::ApBridged => 3,
68 Self::P2P => 4,
69 Self::NanIface => 5,
70 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
71 }
72 }
73
74 #[inline]
75 pub fn is_unknown(&self) -> bool {
76 match self {
77 Self::__SourceBreaking { unknown_ordinal: _ } => true,
78 _ => false,
79 }
80 }
81}
82
83#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
84pub enum Nl80211MessageType {
85 Done,
86 Error,
87 Ack,
88 NoOp,
89 Overrun,
90 Message,
91 #[doc(hidden)]
92 __SourceBreaking {
93 unknown_ordinal: u32,
94 },
95}
96
97#[macro_export]
99macro_rules! Nl80211MessageTypeUnknown {
100 () => {
101 _
102 };
103}
104
105impl Nl80211MessageType {
106 #[inline]
107 pub fn from_primitive(prim: u32) -> Option<Self> {
108 match prim {
109 1 => Some(Self::Done),
110 2 => Some(Self::Error),
111 3 => Some(Self::Ack),
112 4 => Some(Self::NoOp),
113 5 => Some(Self::Overrun),
114 6 => Some(Self::Message),
115 _ => None,
116 }
117 }
118
119 #[inline]
120 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
121 match prim {
122 1 => Self::Done,
123 2 => Self::Error,
124 3 => Self::Ack,
125 4 => Self::NoOp,
126 5 => Self::Overrun,
127 6 => Self::Message,
128 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
129 }
130 }
131
132 #[inline]
133 pub fn unknown() -> Self {
134 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
135 }
136
137 #[inline]
138 pub const fn into_primitive(self) -> u32 {
139 match self {
140 Self::Done => 1,
141 Self::Error => 2,
142 Self::Ack => 3,
143 Self::NoOp => 4,
144 Self::Overrun => 5,
145 Self::Message => 6,
146 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
147 }
148 }
149
150 #[inline]
151 pub fn is_unknown(&self) -> bool {
152 match self {
153 Self::__SourceBreaking { unknown_ordinal: _ } => true,
154 _ => false,
155 }
156 }
157}
158
159#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
160pub enum StaIfaceCallbackState {
161 Disconnected,
162 IfaceDisabled,
163 Inactive,
164 Scanning,
165 Authenticating,
166 Associating,
167 Associated,
168 FourwayHandshake,
169 GroupHandshake,
170 Completed,
171 #[doc(hidden)]
172 __SourceBreaking {
173 unknown_ordinal: u32,
174 },
175}
176
177#[macro_export]
179macro_rules! StaIfaceCallbackStateUnknown {
180 () => {
181 _
182 };
183}
184
185impl StaIfaceCallbackState {
186 #[inline]
187 pub fn from_primitive(prim: u32) -> Option<Self> {
188 match prim {
189 0 => Some(Self::Disconnected),
190 1 => Some(Self::IfaceDisabled),
191 2 => Some(Self::Inactive),
192 3 => Some(Self::Scanning),
193 4 => Some(Self::Authenticating),
194 5 => Some(Self::Associating),
195 6 => Some(Self::Associated),
196 7 => Some(Self::FourwayHandshake),
197 8 => Some(Self::GroupHandshake),
198 9 => Some(Self::Completed),
199 _ => None,
200 }
201 }
202
203 #[inline]
204 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
205 match prim {
206 0 => Self::Disconnected,
207 1 => Self::IfaceDisabled,
208 2 => Self::Inactive,
209 3 => Self::Scanning,
210 4 => Self::Authenticating,
211 5 => Self::Associating,
212 6 => Self::Associated,
213 7 => Self::FourwayHandshake,
214 8 => Self::GroupHandshake,
215 9 => Self::Completed,
216 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
217 }
218 }
219
220 #[inline]
221 pub fn unknown() -> Self {
222 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
223 }
224
225 #[inline]
226 pub const fn into_primitive(self) -> u32 {
227 match self {
228 Self::Disconnected => 0,
229 Self::IfaceDisabled => 1,
230 Self::Inactive => 2,
231 Self::Scanning => 3,
232 Self::Authenticating => 4,
233 Self::Associating => 5,
234 Self::Associated => 6,
235 Self::FourwayHandshake => 7,
236 Self::GroupHandshake => 8,
237 Self::Completed => 9,
238 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
239 }
240 }
241
242 #[inline]
243 pub fn is_unknown(&self) -> bool {
244 match self {
245 Self::__SourceBreaking { unknown_ordinal: _ } => true,
246 _ => false,
247 }
248 }
249}
250
251#[derive(Clone, Debug, PartialEq)]
252pub struct Nl80211MessageArray {
253 pub messages: Vec<Nl80211Message>,
254}
255
256impl fidl::Persistable for Nl80211MessageArray {}
257
258#[derive(Clone, Debug, Default, PartialEq)]
259pub struct ChipConcurrencyCombination {
260 pub limits: Option<Vec<ChipConcurrencyCombinationLimit>>,
261 #[doc(hidden)]
262 pub __source_breaking: fidl::marker::SourceBreaking,
263}
264
265impl fidl::Persistable for ChipConcurrencyCombination {}
266
267#[derive(Clone, Debug, Default, PartialEq)]
268pub struct ChipConcurrencyCombinationLimit {
269 pub types: Option<Vec<IfaceConcurrencyType>>,
270 pub max_ifaces: Option<u32>,
271 #[doc(hidden)]
272 pub __source_breaking: fidl::marker::SourceBreaking,
273}
274
275impl fidl::Persistable for ChipConcurrencyCombinationLimit {}
276
277#[derive(Clone, Debug, Default, PartialEq)]
278pub struct ChipMode {
279 pub id: Option<u32>,
280 pub available_combinations: Option<Vec<ChipConcurrencyCombination>>,
281 #[doc(hidden)]
282 pub __source_breaking: fidl::marker::SourceBreaking,
283}
284
285impl fidl::Persistable for ChipMode {}
286
287#[derive(Clone, Debug, Default, PartialEq)]
288pub struct Nl80211Message {
289 pub message_type: Option<Nl80211MessageType>,
290 pub payload: Option<Vec<u8>>,
291 #[doc(hidden)]
292 pub __source_breaking: fidl::marker::SourceBreaking,
293}
294
295impl fidl::Persistable for Nl80211Message {}
296
297#[derive(Clone, Debug, Default, PartialEq)]
298pub struct SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
299 pub ssid: Option<Vec<u8>>,
300 pub bssid: Option<[u8; 6]>,
301 pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
302 pub timed_out: Option<bool>,
303 #[doc(hidden)]
304 pub __source_breaking: fidl::marker::SourceBreaking,
305}
306
307impl fidl::Persistable for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {}
308
309#[derive(Clone, Debug, Default, PartialEq)]
310pub struct SupplicantStaIfaceCallbackOnDisconnectedRequest {
311 pub bssid: Option<[u8; 6]>,
312 pub locally_generated: Option<bool>,
313 pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
314 #[doc(hidden)]
315 pub __source_breaking: fidl::marker::SourceBreaking,
316}
317
318impl fidl::Persistable for SupplicantStaIfaceCallbackOnDisconnectedRequest {}
319
320#[derive(Clone, Debug, Default, PartialEq)]
321pub struct SupplicantStaIfaceCallbackOnStateChangedRequest {
322 pub new_state: Option<StaIfaceCallbackState>,
323 pub bssid: Option<[u8; 6]>,
324 pub id: Option<u32>,
325 pub ssid: Option<Vec<u8>>,
326 #[doc(hidden)]
327 pub __source_breaking: fidl::marker::SourceBreaking,
328}
329
330impl fidl::Persistable for SupplicantStaIfaceCallbackOnStateChangedRequest {}
331
332#[derive(Clone, Debug, Default, PartialEq)]
333pub struct SupplicantStaIfaceGetMacAddressResponse {
334 pub mac_addr: Option<[u8; 6]>,
335 #[doc(hidden)]
336 pub __source_breaking: fidl::marker::SourceBreaking,
337}
338
339impl fidl::Persistable for SupplicantStaIfaceGetMacAddressResponse {}
340
341#[derive(Clone, Debug, Default, PartialEq)]
342pub struct SupplicantStaNetworkSetBssidRequest {
343 pub bssid: Option<[u8; 6]>,
344 #[doc(hidden)]
345 pub __source_breaking: fidl::marker::SourceBreaking,
346}
347
348impl fidl::Persistable for SupplicantStaNetworkSetBssidRequest {}
349
350#[derive(Clone, Debug, Default, PartialEq)]
351pub struct SupplicantStaNetworkSetPskPassphraseRequest {
352 pub passphrase: Option<Vec<u8>>,
353 #[doc(hidden)]
354 pub __source_breaking: fidl::marker::SourceBreaking,
355}
356
357impl fidl::Persistable for SupplicantStaNetworkSetPskPassphraseRequest {}
358
359#[derive(Clone, Debug, Default, PartialEq)]
360pub struct SupplicantStaNetworkSetSsidRequest {
361 pub ssid: Option<Vec<u8>>,
362 #[doc(hidden)]
363 pub __source_breaking: fidl::marker::SourceBreaking,
364}
365
366impl fidl::Persistable for SupplicantStaNetworkSetSsidRequest {}
367
368#[derive(Clone, Debug, Default, PartialEq)]
369pub struct WifiChipGetAvailableModesResponse {
370 pub chip_modes: Option<Vec<ChipMode>>,
371 #[doc(hidden)]
372 pub __source_breaking: fidl::marker::SourceBreaking,
373}
374
375impl fidl::Persistable for WifiChipGetAvailableModesResponse {}
376
377#[derive(Clone, Debug, Default, PartialEq)]
378pub struct WifiChipGetCapabilitiesResponse {
379 pub capabilities_mask: Option<u32>,
380 #[doc(hidden)]
381 pub __source_breaking: fidl::marker::SourceBreaking,
382}
383
384impl fidl::Persistable for WifiChipGetCapabilitiesResponse {}
385
386#[derive(Clone, Debug, Default, PartialEq)]
387pub struct WifiChipGetIdResponse {
388 pub id: Option<u32>,
389 #[doc(hidden)]
390 pub __source_breaking: fidl::marker::SourceBreaking,
391}
392
393impl fidl::Persistable for WifiChipGetIdResponse {}
394
395#[derive(Clone, Debug, Default, PartialEq)]
396pub struct WifiChipGetModeResponse {
397 pub mode: Option<u32>,
398 #[doc(hidden)]
399 pub __source_breaking: fidl::marker::SourceBreaking,
400}
401
402impl fidl::Persistable for WifiChipGetModeResponse {}
403
404#[derive(Clone, Debug, Default, PartialEq)]
405pub struct WifiChipGetStaIfaceNamesResponse {
406 pub iface_names: Option<Vec<String>>,
407 #[doc(hidden)]
408 pub __source_breaking: fidl::marker::SourceBreaking,
409}
410
411impl fidl::Persistable for WifiChipGetStaIfaceNamesResponse {}
412
413#[derive(Clone, Debug, Default, PartialEq)]
414pub struct WifiStaIfaceGetNameResponse {
415 pub iface_name: Option<String>,
416 #[doc(hidden)]
417 pub __source_breaking: fidl::marker::SourceBreaking,
418}
419
420impl fidl::Persistable for WifiStaIfaceGetNameResponse {}
421
422#[derive(Clone, Debug, Default, PartialEq)]
423pub struct WifiGetChipIdsResponse {
424 pub chip_ids: Option<Vec<u32>>,
425 #[doc(hidden)]
426 pub __source_breaking: fidl::marker::SourceBreaking,
427}
428
429impl fidl::Persistable for WifiGetChipIdsResponse {}
430
431#[derive(Clone, Debug, Default, PartialEq)]
432pub struct WifiGetStateResponse {
433 pub is_started: Option<bool>,
434 #[doc(hidden)]
435 pub __source_breaking: fidl::marker::SourceBreaking,
436}
437
438impl fidl::Persistable for WifiGetStateResponse {}
439
440pub mod nl80211_ordinals {
441 pub const GET_MULTICAST: u64 = 0x58b73dd089681dc2;
442 pub const MESSAGE: u64 = 0x6336259e15bb3795;
443 pub const MESSAGE_V2: u64 = 0x4626796aba1e2987;
444}
445
446pub mod nl80211_multicast_ordinals {
447 pub const MESSAGE: u64 = 0x4cc9241f302f16c0;
448}
449
450pub mod supplicant_ordinals {
451 pub const ADD_STA_INTERFACE: u64 = 0x73194b2afe9b367e;
452 pub const REMOVE_INTERFACE: u64 = 0x7f83e5b75b27d242;
453}
454
455pub mod supplicant_sta_iface_ordinals {
456 pub const REGISTER_CALLBACK: u64 = 0x1be680e863a8e71;
457 pub const ADD_NETWORK: u64 = 0xa77cf60628766dc;
458 pub const DISCONNECT: u64 = 0x52a1d38e0b4871fa;
459 pub const GET_MAC_ADDRESS: u64 = 0x60591d204a3f537f;
460 pub const SET_POWER_SAVE: u64 = 0x5a04c29320085298;
461 pub const SET_SUSPEND_MODE_ENABLED: u64 = 0xaf10de85bb7023a;
462 pub const SET_STA_COUNTRY_CODE: u64 = 0x977e22f9b79b26e;
463}
464
465pub mod supplicant_sta_iface_callback_ordinals {
466 pub const ON_STATE_CHANGED: u64 = 0x27e086d26c49eb6c;
467 pub const ON_DISCONNECTED: u64 = 0x69546475f4dee0cc;
468 pub const ON_ASSOCIATION_REJECTED: u64 = 0x7ef3961518bed988;
469}
470
471pub mod supplicant_sta_network_ordinals {
472 pub const SET_BSSID: u64 = 0x10a91d044ee6374d;
473 pub const CLEAR_BSSID: u64 = 0xbc7ad82f541b267;
474 pub const SET_SSID: u64 = 0x6b598a7a802e3083;
475 pub const SET_PSK_PASSPHRASE: u64 = 0xf6d438225979307;
476 pub const SELECT: u64 = 0x354bc361a0c77b45;
477}
478
479pub mod wifi_ordinals {
480 pub const REGISTER_EVENT_CALLBACK: u64 = 0x12abbdea948dd67b;
481 pub const START: u64 = 0x427030e4dc6ec07a;
482 pub const STOP: u64 = 0x67c9bdf61b2888d;
483 pub const GET_STATE: u64 = 0x4616114a937d1fb0;
484 pub const GET_CHIP_IDS: u64 = 0x2fb4f92351d802b5;
485 pub const GET_CHIP: u64 = 0xef95d8246612540;
486}
487
488pub mod wifi_chip_ordinals {
489 pub const CREATE_STA_IFACE: u64 = 0x6fb2d5892face7af;
490 pub const GET_STA_IFACE_NAMES: u64 = 0x349257482df6a000;
491 pub const GET_STA_IFACE: u64 = 0x6d9704eeb36f28a2;
492 pub const REMOVE_STA_IFACE: u64 = 0x4cd8eee466f8b04c;
493 pub const SET_COUNTRY_CODE: u64 = 0x1dfe372d1d61a490;
494 pub const GET_AVAILABLE_MODES: u64 = 0x1701095b452a3acd;
495 pub const GET_ID: u64 = 0x37d5197325bb3370;
496 pub const GET_MODE: u64 = 0x4d209e0f3ac84d6f;
497 pub const GET_CAPABILITIES: u64 = 0x1b253f396dcaa2e0;
498 pub const TRIGGER_SUBSYSTEM_RESTART: u64 = 0x42ffcae5aad196f9;
499}
500
501pub mod wifi_event_callback_ordinals {
502 pub const ON_START: u64 = 0x61189ff44f9d35f3;
503 pub const ON_STOP: u64 = 0x58b697bcd475e0f9;
504}
505
506pub mod wifi_sta_iface_ordinals {
507 pub const GET_NAME: u64 = 0x5c150b91c80c5789;
508}
509
510pub mod wlanix_ordinals {
511 pub const GET_WIFI: u64 = 0x142511f44b2c338c;
512 pub const GET_SUPPLICANT: u64 = 0x55554b37c4021d3d;
513 pub const GET_NL80211: u64 = 0x48028a25bd855ef9;
514}
515
516mod internal {
517 use super::*;
518 unsafe impl fidl::encoding::TypeMarker for IfaceConcurrencyType {
519 type Owned = Self;
520
521 #[inline(always)]
522 fn inline_align(_context: fidl::encoding::Context) -> usize {
523 std::mem::align_of::<u32>()
524 }
525
526 #[inline(always)]
527 fn inline_size(_context: fidl::encoding::Context) -> usize {
528 std::mem::size_of::<u32>()
529 }
530
531 #[inline(always)]
532 fn encode_is_copy() -> bool {
533 false
534 }
535
536 #[inline(always)]
537 fn decode_is_copy() -> bool {
538 false
539 }
540 }
541
542 impl fidl::encoding::ValueTypeMarker for IfaceConcurrencyType {
543 type Borrowed<'a> = Self;
544 #[inline(always)]
545 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
546 *value
547 }
548 }
549
550 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
551 for IfaceConcurrencyType
552 {
553 #[inline]
554 unsafe fn encode(
555 self,
556 encoder: &mut fidl::encoding::Encoder<'_, D>,
557 offset: usize,
558 _depth: fidl::encoding::Depth,
559 ) -> fidl::Result<()> {
560 encoder.debug_check_bounds::<Self>(offset);
561 encoder.write_num(self.into_primitive(), offset);
562 Ok(())
563 }
564 }
565
566 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceConcurrencyType {
567 #[inline(always)]
568 fn new_empty() -> Self {
569 Self::unknown()
570 }
571
572 #[inline]
573 unsafe fn decode(
574 &mut self,
575 decoder: &mut fidl::encoding::Decoder<'_, D>,
576 offset: usize,
577 _depth: fidl::encoding::Depth,
578 ) -> fidl::Result<()> {
579 decoder.debug_check_bounds::<Self>(offset);
580 let prim = decoder.read_num::<u32>(offset);
581
582 *self = Self::from_primitive_allow_unknown(prim);
583 Ok(())
584 }
585 }
586 unsafe impl fidl::encoding::TypeMarker for Nl80211MessageType {
587 type Owned = Self;
588
589 #[inline(always)]
590 fn inline_align(_context: fidl::encoding::Context) -> usize {
591 std::mem::align_of::<u32>()
592 }
593
594 #[inline(always)]
595 fn inline_size(_context: fidl::encoding::Context) -> usize {
596 std::mem::size_of::<u32>()
597 }
598
599 #[inline(always)]
600 fn encode_is_copy() -> bool {
601 false
602 }
603
604 #[inline(always)]
605 fn decode_is_copy() -> bool {
606 false
607 }
608 }
609
610 impl fidl::encoding::ValueTypeMarker for Nl80211MessageType {
611 type Borrowed<'a> = Self;
612 #[inline(always)]
613 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
614 *value
615 }
616 }
617
618 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
619 for Nl80211MessageType
620 {
621 #[inline]
622 unsafe fn encode(
623 self,
624 encoder: &mut fidl::encoding::Encoder<'_, D>,
625 offset: usize,
626 _depth: fidl::encoding::Depth,
627 ) -> fidl::Result<()> {
628 encoder.debug_check_bounds::<Self>(offset);
629 encoder.write_num(self.into_primitive(), offset);
630 Ok(())
631 }
632 }
633
634 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nl80211MessageType {
635 #[inline(always)]
636 fn new_empty() -> Self {
637 Self::unknown()
638 }
639
640 #[inline]
641 unsafe fn decode(
642 &mut self,
643 decoder: &mut fidl::encoding::Decoder<'_, D>,
644 offset: usize,
645 _depth: fidl::encoding::Depth,
646 ) -> fidl::Result<()> {
647 decoder.debug_check_bounds::<Self>(offset);
648 let prim = decoder.read_num::<u32>(offset);
649
650 *self = Self::from_primitive_allow_unknown(prim);
651 Ok(())
652 }
653 }
654 unsafe impl fidl::encoding::TypeMarker for StaIfaceCallbackState {
655 type Owned = Self;
656
657 #[inline(always)]
658 fn inline_align(_context: fidl::encoding::Context) -> usize {
659 std::mem::align_of::<u32>()
660 }
661
662 #[inline(always)]
663 fn inline_size(_context: fidl::encoding::Context) -> usize {
664 std::mem::size_of::<u32>()
665 }
666
667 #[inline(always)]
668 fn encode_is_copy() -> bool {
669 false
670 }
671
672 #[inline(always)]
673 fn decode_is_copy() -> bool {
674 false
675 }
676 }
677
678 impl fidl::encoding::ValueTypeMarker for StaIfaceCallbackState {
679 type Borrowed<'a> = Self;
680 #[inline(always)]
681 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
682 *value
683 }
684 }
685
686 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
687 for StaIfaceCallbackState
688 {
689 #[inline]
690 unsafe fn encode(
691 self,
692 encoder: &mut fidl::encoding::Encoder<'_, D>,
693 offset: usize,
694 _depth: fidl::encoding::Depth,
695 ) -> fidl::Result<()> {
696 encoder.debug_check_bounds::<Self>(offset);
697 encoder.write_num(self.into_primitive(), offset);
698 Ok(())
699 }
700 }
701
702 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaIfaceCallbackState {
703 #[inline(always)]
704 fn new_empty() -> Self {
705 Self::unknown()
706 }
707
708 #[inline]
709 unsafe fn decode(
710 &mut self,
711 decoder: &mut fidl::encoding::Decoder<'_, D>,
712 offset: usize,
713 _depth: fidl::encoding::Depth,
714 ) -> fidl::Result<()> {
715 decoder.debug_check_bounds::<Self>(offset);
716 let prim = decoder.read_num::<u32>(offset);
717
718 *self = Self::from_primitive_allow_unknown(prim);
719 Ok(())
720 }
721 }
722
723 impl fidl::encoding::ValueTypeMarker for Nl80211MessageArray {
724 type Borrowed<'a> = &'a Self;
725 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
726 value
727 }
728 }
729
730 unsafe impl fidl::encoding::TypeMarker for Nl80211MessageArray {
731 type Owned = Self;
732
733 #[inline(always)]
734 fn inline_align(_context: fidl::encoding::Context) -> usize {
735 8
736 }
737
738 #[inline(always)]
739 fn inline_size(_context: fidl::encoding::Context) -> usize {
740 16
741 }
742 }
743
744 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nl80211MessageArray, D>
745 for &Nl80211MessageArray
746 {
747 #[inline]
748 unsafe fn encode(
749 self,
750 encoder: &mut fidl::encoding::Encoder<'_, D>,
751 offset: usize,
752 _depth: fidl::encoding::Depth,
753 ) -> fidl::Result<()> {
754 encoder.debug_check_bounds::<Nl80211MessageArray>(offset);
755 fidl::encoding::Encode::<Nl80211MessageArray, D>::encode(
757 (
758 <fidl::encoding::UnboundedVector<Nl80211Message> as fidl::encoding::ValueTypeMarker>::borrow(&self.messages),
759 ),
760 encoder, offset, _depth
761 )
762 }
763 }
764 unsafe impl<
765 D: fidl::encoding::ResourceDialect,
766 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Nl80211Message>, D>,
767 > fidl::encoding::Encode<Nl80211MessageArray, D> for (T0,)
768 {
769 #[inline]
770 unsafe fn encode(
771 self,
772 encoder: &mut fidl::encoding::Encoder<'_, D>,
773 offset: usize,
774 depth: fidl::encoding::Depth,
775 ) -> fidl::Result<()> {
776 encoder.debug_check_bounds::<Nl80211MessageArray>(offset);
777 self.0.encode(encoder, offset + 0, depth)?;
781 Ok(())
782 }
783 }
784
785 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nl80211MessageArray {
786 #[inline(always)]
787 fn new_empty() -> Self {
788 Self { messages: fidl::new_empty!(fidl::encoding::UnboundedVector<Nl80211Message>, D) }
789 }
790
791 #[inline]
792 unsafe fn decode(
793 &mut self,
794 decoder: &mut fidl::encoding::Decoder<'_, D>,
795 offset: usize,
796 _depth: fidl::encoding::Depth,
797 ) -> fidl::Result<()> {
798 decoder.debug_check_bounds::<Self>(offset);
799 fidl::decode!(
801 fidl::encoding::UnboundedVector<Nl80211Message>,
802 D,
803 &mut self.messages,
804 decoder,
805 offset + 0,
806 _depth
807 )?;
808 Ok(())
809 }
810 }
811
812 impl ChipConcurrencyCombination {
813 #[inline(always)]
814 fn max_ordinal_present(&self) -> u64 {
815 if let Some(_) = self.limits {
816 return 1;
817 }
818 0
819 }
820 }
821
822 impl fidl::encoding::ValueTypeMarker for ChipConcurrencyCombination {
823 type Borrowed<'a> = &'a Self;
824 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
825 value
826 }
827 }
828
829 unsafe impl fidl::encoding::TypeMarker for ChipConcurrencyCombination {
830 type Owned = Self;
831
832 #[inline(always)]
833 fn inline_align(_context: fidl::encoding::Context) -> usize {
834 8
835 }
836
837 #[inline(always)]
838 fn inline_size(_context: fidl::encoding::Context) -> usize {
839 16
840 }
841 }
842
843 unsafe impl<D: fidl::encoding::ResourceDialect>
844 fidl::encoding::Encode<ChipConcurrencyCombination, D> for &ChipConcurrencyCombination
845 {
846 unsafe fn encode(
847 self,
848 encoder: &mut fidl::encoding::Encoder<'_, D>,
849 offset: usize,
850 mut depth: fidl::encoding::Depth,
851 ) -> fidl::Result<()> {
852 encoder.debug_check_bounds::<ChipConcurrencyCombination>(offset);
853 let max_ordinal: u64 = self.max_ordinal_present();
855 encoder.write_num(max_ordinal, offset);
856 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
857 if max_ordinal == 0 {
859 return Ok(());
860 }
861 depth.increment()?;
862 let envelope_size = 8;
863 let bytes_len = max_ordinal as usize * envelope_size;
864 #[allow(unused_variables)]
865 let offset = encoder.out_of_line_offset(bytes_len);
866 let mut _prev_end_offset: usize = 0;
867 if 1 > max_ordinal {
868 return Ok(());
869 }
870
871 let cur_offset: usize = (1 - 1) * envelope_size;
874
875 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
877
878 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>, D>(
883 self.limits.as_ref().map(<fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit> as fidl::encoding::ValueTypeMarker>::borrow),
884 encoder, offset + cur_offset, depth
885 )?;
886
887 _prev_end_offset = cur_offset + envelope_size;
888
889 Ok(())
890 }
891 }
892
893 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
894 for ChipConcurrencyCombination
895 {
896 #[inline(always)]
897 fn new_empty() -> Self {
898 Self::default()
899 }
900
901 unsafe fn decode(
902 &mut self,
903 decoder: &mut fidl::encoding::Decoder<'_, D>,
904 offset: usize,
905 mut depth: fidl::encoding::Depth,
906 ) -> fidl::Result<()> {
907 decoder.debug_check_bounds::<Self>(offset);
908 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
909 None => return Err(fidl::Error::NotNullable),
910 Some(len) => len,
911 };
912 if len == 0 {
914 return Ok(());
915 };
916 depth.increment()?;
917 let envelope_size = 8;
918 let bytes_len = len * envelope_size;
919 let offset = decoder.out_of_line_offset(bytes_len)?;
920 let mut _next_ordinal_to_read = 0;
922 let mut next_offset = offset;
923 let end_offset = offset + bytes_len;
924 _next_ordinal_to_read += 1;
925 if next_offset >= end_offset {
926 return Ok(());
927 }
928
929 while _next_ordinal_to_read < 1 {
931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
932 _next_ordinal_to_read += 1;
933 next_offset += envelope_size;
934 }
935
936 let next_out_of_line = decoder.next_out_of_line();
937 let handles_before = decoder.remaining_handles();
938 if let Some((inlined, num_bytes, num_handles)) =
939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
940 {
941 let member_inline_size = <fidl::encoding::UnboundedVector<
942 ChipConcurrencyCombinationLimit,
943 > as fidl::encoding::TypeMarker>::inline_size(
944 decoder.context
945 );
946 if inlined != (member_inline_size <= 4) {
947 return Err(fidl::Error::InvalidInlineBitInEnvelope);
948 }
949 let inner_offset;
950 let mut inner_depth = depth.clone();
951 if inlined {
952 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
953 inner_offset = next_offset;
954 } else {
955 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
956 inner_depth.increment()?;
957 }
958 let val_ref = self.limits.get_or_insert_with(|| {
959 fidl::new_empty!(
960 fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>,
961 D
962 )
963 });
964 fidl::decode!(
965 fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>,
966 D,
967 val_ref,
968 decoder,
969 inner_offset,
970 inner_depth
971 )?;
972 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
973 {
974 return Err(fidl::Error::InvalidNumBytesInEnvelope);
975 }
976 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
977 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
978 }
979 }
980
981 next_offset += envelope_size;
982
983 while next_offset < end_offset {
985 _next_ordinal_to_read += 1;
986 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
987 next_offset += envelope_size;
988 }
989
990 Ok(())
991 }
992 }
993
994 impl ChipConcurrencyCombinationLimit {
995 #[inline(always)]
996 fn max_ordinal_present(&self) -> u64 {
997 if let Some(_) = self.max_ifaces {
998 return 2;
999 }
1000 if let Some(_) = self.types {
1001 return 1;
1002 }
1003 0
1004 }
1005 }
1006
1007 impl fidl::encoding::ValueTypeMarker for ChipConcurrencyCombinationLimit {
1008 type Borrowed<'a> = &'a Self;
1009 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1010 value
1011 }
1012 }
1013
1014 unsafe impl fidl::encoding::TypeMarker for ChipConcurrencyCombinationLimit {
1015 type Owned = Self;
1016
1017 #[inline(always)]
1018 fn inline_align(_context: fidl::encoding::Context) -> usize {
1019 8
1020 }
1021
1022 #[inline(always)]
1023 fn inline_size(_context: fidl::encoding::Context) -> usize {
1024 16
1025 }
1026 }
1027
1028 unsafe impl<D: fidl::encoding::ResourceDialect>
1029 fidl::encoding::Encode<ChipConcurrencyCombinationLimit, D>
1030 for &ChipConcurrencyCombinationLimit
1031 {
1032 unsafe fn encode(
1033 self,
1034 encoder: &mut fidl::encoding::Encoder<'_, D>,
1035 offset: usize,
1036 mut depth: fidl::encoding::Depth,
1037 ) -> fidl::Result<()> {
1038 encoder.debug_check_bounds::<ChipConcurrencyCombinationLimit>(offset);
1039 let max_ordinal: u64 = self.max_ordinal_present();
1041 encoder.write_num(max_ordinal, offset);
1042 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1043 if max_ordinal == 0 {
1045 return Ok(());
1046 }
1047 depth.increment()?;
1048 let envelope_size = 8;
1049 let bytes_len = max_ordinal as usize * envelope_size;
1050 #[allow(unused_variables)]
1051 let offset = encoder.out_of_line_offset(bytes_len);
1052 let mut _prev_end_offset: usize = 0;
1053 if 1 > max_ordinal {
1054 return Ok(());
1055 }
1056
1057 let cur_offset: usize = (1 - 1) * envelope_size;
1060
1061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1063
1064 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<IfaceConcurrencyType>, D>(
1069 self.types.as_ref().map(<fidl::encoding::UnboundedVector<IfaceConcurrencyType> as fidl::encoding::ValueTypeMarker>::borrow),
1070 encoder, offset + cur_offset, depth
1071 )?;
1072
1073 _prev_end_offset = cur_offset + envelope_size;
1074 if 2 > max_ordinal {
1075 return Ok(());
1076 }
1077
1078 let cur_offset: usize = (2 - 1) * envelope_size;
1081
1082 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1084
1085 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1090 self.max_ifaces.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1091 encoder,
1092 offset + cur_offset,
1093 depth,
1094 )?;
1095
1096 _prev_end_offset = cur_offset + envelope_size;
1097
1098 Ok(())
1099 }
1100 }
1101
1102 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1103 for ChipConcurrencyCombinationLimit
1104 {
1105 #[inline(always)]
1106 fn new_empty() -> Self {
1107 Self::default()
1108 }
1109
1110 unsafe fn decode(
1111 &mut self,
1112 decoder: &mut fidl::encoding::Decoder<'_, D>,
1113 offset: usize,
1114 mut depth: fidl::encoding::Depth,
1115 ) -> fidl::Result<()> {
1116 decoder.debug_check_bounds::<Self>(offset);
1117 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1118 None => return Err(fidl::Error::NotNullable),
1119 Some(len) => len,
1120 };
1121 if len == 0 {
1123 return Ok(());
1124 };
1125 depth.increment()?;
1126 let envelope_size = 8;
1127 let bytes_len = len * envelope_size;
1128 let offset = decoder.out_of_line_offset(bytes_len)?;
1129 let mut _next_ordinal_to_read = 0;
1131 let mut next_offset = offset;
1132 let end_offset = offset + bytes_len;
1133 _next_ordinal_to_read += 1;
1134 if next_offset >= end_offset {
1135 return Ok(());
1136 }
1137
1138 while _next_ordinal_to_read < 1 {
1140 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1141 _next_ordinal_to_read += 1;
1142 next_offset += envelope_size;
1143 }
1144
1145 let next_out_of_line = decoder.next_out_of_line();
1146 let handles_before = decoder.remaining_handles();
1147 if let Some((inlined, num_bytes, num_handles)) =
1148 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1149 {
1150 let member_inline_size = <fidl::encoding::UnboundedVector<IfaceConcurrencyType> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1151 if inlined != (member_inline_size <= 4) {
1152 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1153 }
1154 let inner_offset;
1155 let mut inner_depth = depth.clone();
1156 if inlined {
1157 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1158 inner_offset = next_offset;
1159 } else {
1160 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1161 inner_depth.increment()?;
1162 }
1163 let val_ref = self.types.get_or_insert_with(|| {
1164 fidl::new_empty!(fidl::encoding::UnboundedVector<IfaceConcurrencyType>, D)
1165 });
1166 fidl::decode!(
1167 fidl::encoding::UnboundedVector<IfaceConcurrencyType>,
1168 D,
1169 val_ref,
1170 decoder,
1171 inner_offset,
1172 inner_depth
1173 )?;
1174 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1175 {
1176 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1177 }
1178 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1179 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1180 }
1181 }
1182
1183 next_offset += envelope_size;
1184 _next_ordinal_to_read += 1;
1185 if next_offset >= end_offset {
1186 return Ok(());
1187 }
1188
1189 while _next_ordinal_to_read < 2 {
1191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1192 _next_ordinal_to_read += 1;
1193 next_offset += envelope_size;
1194 }
1195
1196 let next_out_of_line = decoder.next_out_of_line();
1197 let handles_before = decoder.remaining_handles();
1198 if let Some((inlined, num_bytes, num_handles)) =
1199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1200 {
1201 let member_inline_size =
1202 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1203 if inlined != (member_inline_size <= 4) {
1204 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1205 }
1206 let inner_offset;
1207 let mut inner_depth = depth.clone();
1208 if inlined {
1209 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1210 inner_offset = next_offset;
1211 } else {
1212 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1213 inner_depth.increment()?;
1214 }
1215 let val_ref = self.max_ifaces.get_or_insert_with(|| fidl::new_empty!(u32, D));
1216 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1217 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1218 {
1219 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1220 }
1221 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1222 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1223 }
1224 }
1225
1226 next_offset += envelope_size;
1227
1228 while next_offset < end_offset {
1230 _next_ordinal_to_read += 1;
1231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1232 next_offset += envelope_size;
1233 }
1234
1235 Ok(())
1236 }
1237 }
1238
1239 impl ChipMode {
1240 #[inline(always)]
1241 fn max_ordinal_present(&self) -> u64 {
1242 if let Some(_) = self.available_combinations {
1243 return 2;
1244 }
1245 if let Some(_) = self.id {
1246 return 1;
1247 }
1248 0
1249 }
1250 }
1251
1252 impl fidl::encoding::ValueTypeMarker for ChipMode {
1253 type Borrowed<'a> = &'a Self;
1254 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1255 value
1256 }
1257 }
1258
1259 unsafe impl fidl::encoding::TypeMarker for ChipMode {
1260 type Owned = Self;
1261
1262 #[inline(always)]
1263 fn inline_align(_context: fidl::encoding::Context) -> usize {
1264 8
1265 }
1266
1267 #[inline(always)]
1268 fn inline_size(_context: fidl::encoding::Context) -> usize {
1269 16
1270 }
1271 }
1272
1273 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChipMode, D> for &ChipMode {
1274 unsafe fn encode(
1275 self,
1276 encoder: &mut fidl::encoding::Encoder<'_, D>,
1277 offset: usize,
1278 mut depth: fidl::encoding::Depth,
1279 ) -> fidl::Result<()> {
1280 encoder.debug_check_bounds::<ChipMode>(offset);
1281 let max_ordinal: u64 = self.max_ordinal_present();
1283 encoder.write_num(max_ordinal, offset);
1284 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1285 if max_ordinal == 0 {
1287 return Ok(());
1288 }
1289 depth.increment()?;
1290 let envelope_size = 8;
1291 let bytes_len = max_ordinal as usize * envelope_size;
1292 #[allow(unused_variables)]
1293 let offset = encoder.out_of_line_offset(bytes_len);
1294 let mut _prev_end_offset: usize = 0;
1295 if 1 > max_ordinal {
1296 return Ok(());
1297 }
1298
1299 let cur_offset: usize = (1 - 1) * envelope_size;
1302
1303 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1305
1306 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1311 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1312 encoder,
1313 offset + cur_offset,
1314 depth,
1315 )?;
1316
1317 _prev_end_offset = cur_offset + envelope_size;
1318 if 2 > max_ordinal {
1319 return Ok(());
1320 }
1321
1322 let cur_offset: usize = (2 - 1) * envelope_size;
1325
1326 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1328
1329 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipConcurrencyCombination>, D>(
1334 self.available_combinations.as_ref().map(<fidl::encoding::UnboundedVector<ChipConcurrencyCombination> as fidl::encoding::ValueTypeMarker>::borrow),
1335 encoder, offset + cur_offset, depth
1336 )?;
1337
1338 _prev_end_offset = cur_offset + envelope_size;
1339
1340 Ok(())
1341 }
1342 }
1343
1344 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChipMode {
1345 #[inline(always)]
1346 fn new_empty() -> Self {
1347 Self::default()
1348 }
1349
1350 unsafe fn decode(
1351 &mut self,
1352 decoder: &mut fidl::encoding::Decoder<'_, D>,
1353 offset: usize,
1354 mut depth: fidl::encoding::Depth,
1355 ) -> fidl::Result<()> {
1356 decoder.debug_check_bounds::<Self>(offset);
1357 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1358 None => return Err(fidl::Error::NotNullable),
1359 Some(len) => len,
1360 };
1361 if len == 0 {
1363 return Ok(());
1364 };
1365 depth.increment()?;
1366 let envelope_size = 8;
1367 let bytes_len = len * envelope_size;
1368 let offset = decoder.out_of_line_offset(bytes_len)?;
1369 let mut _next_ordinal_to_read = 0;
1371 let mut next_offset = offset;
1372 let end_offset = offset + bytes_len;
1373 _next_ordinal_to_read += 1;
1374 if next_offset >= end_offset {
1375 return Ok(());
1376 }
1377
1378 while _next_ordinal_to_read < 1 {
1380 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1381 _next_ordinal_to_read += 1;
1382 next_offset += envelope_size;
1383 }
1384
1385 let next_out_of_line = decoder.next_out_of_line();
1386 let handles_before = decoder.remaining_handles();
1387 if let Some((inlined, num_bytes, num_handles)) =
1388 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1389 {
1390 let member_inline_size =
1391 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1392 if inlined != (member_inline_size <= 4) {
1393 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1394 }
1395 let inner_offset;
1396 let mut inner_depth = depth.clone();
1397 if inlined {
1398 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1399 inner_offset = next_offset;
1400 } else {
1401 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1402 inner_depth.increment()?;
1403 }
1404 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1405 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1406 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1407 {
1408 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1409 }
1410 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1411 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1412 }
1413 }
1414
1415 next_offset += envelope_size;
1416 _next_ordinal_to_read += 1;
1417 if next_offset >= end_offset {
1418 return Ok(());
1419 }
1420
1421 while _next_ordinal_to_read < 2 {
1423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1424 _next_ordinal_to_read += 1;
1425 next_offset += envelope_size;
1426 }
1427
1428 let next_out_of_line = decoder.next_out_of_line();
1429 let handles_before = decoder.remaining_handles();
1430 if let Some((inlined, num_bytes, num_handles)) =
1431 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1432 {
1433 let member_inline_size = <fidl::encoding::UnboundedVector<
1434 ChipConcurrencyCombination,
1435 > as fidl::encoding::TypeMarker>::inline_size(
1436 decoder.context
1437 );
1438 if inlined != (member_inline_size <= 4) {
1439 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1440 }
1441 let inner_offset;
1442 let mut inner_depth = depth.clone();
1443 if inlined {
1444 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1445 inner_offset = next_offset;
1446 } else {
1447 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1448 inner_depth.increment()?;
1449 }
1450 let val_ref = self.available_combinations.get_or_insert_with(|| {
1451 fidl::new_empty!(fidl::encoding::UnboundedVector<ChipConcurrencyCombination>, D)
1452 });
1453 fidl::decode!(
1454 fidl::encoding::UnboundedVector<ChipConcurrencyCombination>,
1455 D,
1456 val_ref,
1457 decoder,
1458 inner_offset,
1459 inner_depth
1460 )?;
1461 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1462 {
1463 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1464 }
1465 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1466 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1467 }
1468 }
1469
1470 next_offset += envelope_size;
1471
1472 while next_offset < end_offset {
1474 _next_ordinal_to_read += 1;
1475 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1476 next_offset += envelope_size;
1477 }
1478
1479 Ok(())
1480 }
1481 }
1482
1483 impl Nl80211Message {
1484 #[inline(always)]
1485 fn max_ordinal_present(&self) -> u64 {
1486 if let Some(_) = self.payload {
1487 return 2;
1488 }
1489 if let Some(_) = self.message_type {
1490 return 1;
1491 }
1492 0
1493 }
1494 }
1495
1496 impl fidl::encoding::ValueTypeMarker for Nl80211Message {
1497 type Borrowed<'a> = &'a Self;
1498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1499 value
1500 }
1501 }
1502
1503 unsafe impl fidl::encoding::TypeMarker for Nl80211Message {
1504 type Owned = Self;
1505
1506 #[inline(always)]
1507 fn inline_align(_context: fidl::encoding::Context) -> usize {
1508 8
1509 }
1510
1511 #[inline(always)]
1512 fn inline_size(_context: fidl::encoding::Context) -> usize {
1513 16
1514 }
1515 }
1516
1517 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nl80211Message, D>
1518 for &Nl80211Message
1519 {
1520 unsafe fn encode(
1521 self,
1522 encoder: &mut fidl::encoding::Encoder<'_, D>,
1523 offset: usize,
1524 mut depth: fidl::encoding::Depth,
1525 ) -> fidl::Result<()> {
1526 encoder.debug_check_bounds::<Nl80211Message>(offset);
1527 let max_ordinal: u64 = self.max_ordinal_present();
1529 encoder.write_num(max_ordinal, offset);
1530 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1531 if max_ordinal == 0 {
1533 return Ok(());
1534 }
1535 depth.increment()?;
1536 let envelope_size = 8;
1537 let bytes_len = max_ordinal as usize * envelope_size;
1538 #[allow(unused_variables)]
1539 let offset = encoder.out_of_line_offset(bytes_len);
1540 let mut _prev_end_offset: usize = 0;
1541 if 1 > max_ordinal {
1542 return Ok(());
1543 }
1544
1545 let cur_offset: usize = (1 - 1) * envelope_size;
1548
1549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1551
1552 fidl::encoding::encode_in_envelope_optional::<Nl80211MessageType, D>(
1557 self.message_type
1558 .as_ref()
1559 .map(<Nl80211MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1560 encoder,
1561 offset + cur_offset,
1562 depth,
1563 )?;
1564
1565 _prev_end_offset = cur_offset + envelope_size;
1566 if 2 > max_ordinal {
1567 return Ok(());
1568 }
1569
1570 let cur_offset: usize = (2 - 1) * envelope_size;
1573
1574 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1576
1577 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
1582 self.payload.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
1583 encoder, offset + cur_offset, depth
1584 )?;
1585
1586 _prev_end_offset = cur_offset + envelope_size;
1587
1588 Ok(())
1589 }
1590 }
1591
1592 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nl80211Message {
1593 #[inline(always)]
1594 fn new_empty() -> Self {
1595 Self::default()
1596 }
1597
1598 unsafe fn decode(
1599 &mut self,
1600 decoder: &mut fidl::encoding::Decoder<'_, D>,
1601 offset: usize,
1602 mut depth: fidl::encoding::Depth,
1603 ) -> fidl::Result<()> {
1604 decoder.debug_check_bounds::<Self>(offset);
1605 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1606 None => return Err(fidl::Error::NotNullable),
1607 Some(len) => len,
1608 };
1609 if len == 0 {
1611 return Ok(());
1612 };
1613 depth.increment()?;
1614 let envelope_size = 8;
1615 let bytes_len = len * envelope_size;
1616 let offset = decoder.out_of_line_offset(bytes_len)?;
1617 let mut _next_ordinal_to_read = 0;
1619 let mut next_offset = offset;
1620 let end_offset = offset + bytes_len;
1621 _next_ordinal_to_read += 1;
1622 if next_offset >= end_offset {
1623 return Ok(());
1624 }
1625
1626 while _next_ordinal_to_read < 1 {
1628 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1629 _next_ordinal_to_read += 1;
1630 next_offset += envelope_size;
1631 }
1632
1633 let next_out_of_line = decoder.next_out_of_line();
1634 let handles_before = decoder.remaining_handles();
1635 if let Some((inlined, num_bytes, num_handles)) =
1636 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1637 {
1638 let member_inline_size =
1639 <Nl80211MessageType as fidl::encoding::TypeMarker>::inline_size(
1640 decoder.context,
1641 );
1642 if inlined != (member_inline_size <= 4) {
1643 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1644 }
1645 let inner_offset;
1646 let mut inner_depth = depth.clone();
1647 if inlined {
1648 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1649 inner_offset = next_offset;
1650 } else {
1651 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1652 inner_depth.increment()?;
1653 }
1654 let val_ref = self
1655 .message_type
1656 .get_or_insert_with(|| fidl::new_empty!(Nl80211MessageType, D));
1657 fidl::decode!(Nl80211MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1658 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1659 {
1660 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1661 }
1662 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1663 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1664 }
1665 }
1666
1667 next_offset += envelope_size;
1668 _next_ordinal_to_read += 1;
1669 if next_offset >= end_offset {
1670 return Ok(());
1671 }
1672
1673 while _next_ordinal_to_read < 2 {
1675 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1676 _next_ordinal_to_read += 1;
1677 next_offset += envelope_size;
1678 }
1679
1680 let next_out_of_line = decoder.next_out_of_line();
1681 let handles_before = decoder.remaining_handles();
1682 if let Some((inlined, num_bytes, num_handles)) =
1683 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1684 {
1685 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1686 if inlined != (member_inline_size <= 4) {
1687 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1688 }
1689 let inner_offset;
1690 let mut inner_depth = depth.clone();
1691 if inlined {
1692 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1693 inner_offset = next_offset;
1694 } else {
1695 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1696 inner_depth.increment()?;
1697 }
1698 let val_ref = self.payload.get_or_insert_with(|| {
1699 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
1700 });
1701 fidl::decode!(
1702 fidl::encoding::UnboundedVector<u8>,
1703 D,
1704 val_ref,
1705 decoder,
1706 inner_offset,
1707 inner_depth
1708 )?;
1709 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1710 {
1711 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1712 }
1713 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1714 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1715 }
1716 }
1717
1718 next_offset += envelope_size;
1719
1720 while next_offset < end_offset {
1722 _next_ordinal_to_read += 1;
1723 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1724 next_offset += envelope_size;
1725 }
1726
1727 Ok(())
1728 }
1729 }
1730
1731 impl SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1732 #[inline(always)]
1733 fn max_ordinal_present(&self) -> u64 {
1734 if let Some(_) = self.timed_out {
1735 return 4;
1736 }
1737 if let Some(_) = self.status_code {
1738 return 3;
1739 }
1740 if let Some(_) = self.bssid {
1741 return 2;
1742 }
1743 if let Some(_) = self.ssid {
1744 return 1;
1745 }
1746 0
1747 }
1748 }
1749
1750 impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1751 type Borrowed<'a> = &'a Self;
1752 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1753 value
1754 }
1755 }
1756
1757 unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1758 type Owned = Self;
1759
1760 #[inline(always)]
1761 fn inline_align(_context: fidl::encoding::Context) -> usize {
1762 8
1763 }
1764
1765 #[inline(always)]
1766 fn inline_size(_context: fidl::encoding::Context) -> usize {
1767 16
1768 }
1769 }
1770
1771 unsafe impl<D: fidl::encoding::ResourceDialect>
1772 fidl::encoding::Encode<SupplicantStaIfaceCallbackOnAssociationRejectedRequest, D>
1773 for &SupplicantStaIfaceCallbackOnAssociationRejectedRequest
1774 {
1775 unsafe fn encode(
1776 self,
1777 encoder: &mut fidl::encoding::Encoder<'_, D>,
1778 offset: usize,
1779 mut depth: fidl::encoding::Depth,
1780 ) -> fidl::Result<()> {
1781 encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnAssociationRejectedRequest>(
1782 offset,
1783 );
1784 let max_ordinal: u64 = self.max_ordinal_present();
1786 encoder.write_num(max_ordinal, offset);
1787 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1788 if max_ordinal == 0 {
1790 return Ok(());
1791 }
1792 depth.increment()?;
1793 let envelope_size = 8;
1794 let bytes_len = max_ordinal as usize * envelope_size;
1795 #[allow(unused_variables)]
1796 let offset = encoder.out_of_line_offset(bytes_len);
1797 let mut _prev_end_offset: usize = 0;
1798 if 1 > max_ordinal {
1799 return Ok(());
1800 }
1801
1802 let cur_offset: usize = (1 - 1) * envelope_size;
1805
1806 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1808
1809 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
1814 self.ssid.as_ref().map(
1815 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
1816 ),
1817 encoder,
1818 offset + cur_offset,
1819 depth,
1820 )?;
1821
1822 _prev_end_offset = cur_offset + envelope_size;
1823 if 2 > max_ordinal {
1824 return Ok(());
1825 }
1826
1827 let cur_offset: usize = (2 - 1) * envelope_size;
1830
1831 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1833
1834 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
1839 self.bssid
1840 .as_ref()
1841 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
1842 encoder,
1843 offset + cur_offset,
1844 depth,
1845 )?;
1846
1847 _prev_end_offset = cur_offset + envelope_size;
1848 if 3 > max_ordinal {
1849 return Ok(());
1850 }
1851
1852 let cur_offset: usize = (3 - 1) * envelope_size;
1855
1856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1858
1859 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
1864 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
1865 encoder, offset + cur_offset, depth
1866 )?;
1867
1868 _prev_end_offset = cur_offset + envelope_size;
1869 if 4 > max_ordinal {
1870 return Ok(());
1871 }
1872
1873 let cur_offset: usize = (4 - 1) * envelope_size;
1876
1877 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1879
1880 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1885 self.timed_out.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1886 encoder,
1887 offset + cur_offset,
1888 depth,
1889 )?;
1890
1891 _prev_end_offset = cur_offset + envelope_size;
1892
1893 Ok(())
1894 }
1895 }
1896
1897 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1898 for SupplicantStaIfaceCallbackOnAssociationRejectedRequest
1899 {
1900 #[inline(always)]
1901 fn new_empty() -> Self {
1902 Self::default()
1903 }
1904
1905 unsafe fn decode(
1906 &mut self,
1907 decoder: &mut fidl::encoding::Decoder<'_, D>,
1908 offset: usize,
1909 mut depth: fidl::encoding::Depth,
1910 ) -> fidl::Result<()> {
1911 decoder.debug_check_bounds::<Self>(offset);
1912 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1913 None => return Err(fidl::Error::NotNullable),
1914 Some(len) => len,
1915 };
1916 if len == 0 {
1918 return Ok(());
1919 };
1920 depth.increment()?;
1921 let envelope_size = 8;
1922 let bytes_len = len * envelope_size;
1923 let offset = decoder.out_of_line_offset(bytes_len)?;
1924 let mut _next_ordinal_to_read = 0;
1926 let mut next_offset = offset;
1927 let end_offset = offset + bytes_len;
1928 _next_ordinal_to_read += 1;
1929 if next_offset >= end_offset {
1930 return Ok(());
1931 }
1932
1933 while _next_ordinal_to_read < 1 {
1935 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1936 _next_ordinal_to_read += 1;
1937 next_offset += envelope_size;
1938 }
1939
1940 let next_out_of_line = decoder.next_out_of_line();
1941 let handles_before = decoder.remaining_handles();
1942 if let Some((inlined, num_bytes, num_handles)) =
1943 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1944 {
1945 let member_inline_size =
1946 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
1947 decoder.context,
1948 );
1949 if inlined != (member_inline_size <= 4) {
1950 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1951 }
1952 let inner_offset;
1953 let mut inner_depth = depth.clone();
1954 if inlined {
1955 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1956 inner_offset = next_offset;
1957 } else {
1958 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1959 inner_depth.increment()?;
1960 }
1961 let val_ref = self
1962 .ssid
1963 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
1964 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
1965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1966 {
1967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1968 }
1969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1971 }
1972 }
1973
1974 next_offset += envelope_size;
1975 _next_ordinal_to_read += 1;
1976 if next_offset >= end_offset {
1977 return Ok(());
1978 }
1979
1980 while _next_ordinal_to_read < 2 {
1982 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1983 _next_ordinal_to_read += 1;
1984 next_offset += envelope_size;
1985 }
1986
1987 let next_out_of_line = decoder.next_out_of_line();
1988 let handles_before = decoder.remaining_handles();
1989 if let Some((inlined, num_bytes, num_handles)) =
1990 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1991 {
1992 let member_inline_size =
1993 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
1994 decoder.context,
1995 );
1996 if inlined != (member_inline_size <= 4) {
1997 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1998 }
1999 let inner_offset;
2000 let mut inner_depth = depth.clone();
2001 if inlined {
2002 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2003 inner_offset = next_offset;
2004 } else {
2005 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2006 inner_depth.increment()?;
2007 }
2008 let val_ref = self
2009 .bssid
2010 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2011 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2012 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2013 {
2014 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2015 }
2016 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2017 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2018 }
2019 }
2020
2021 next_offset += envelope_size;
2022 _next_ordinal_to_read += 1;
2023 if next_offset >= end_offset {
2024 return Ok(());
2025 }
2026
2027 while _next_ordinal_to_read < 3 {
2029 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2030 _next_ordinal_to_read += 1;
2031 next_offset += envelope_size;
2032 }
2033
2034 let next_out_of_line = decoder.next_out_of_line();
2035 let handles_before = decoder.remaining_handles();
2036 if let Some((inlined, num_bytes, num_handles)) =
2037 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2038 {
2039 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2040 if inlined != (member_inline_size <= 4) {
2041 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2042 }
2043 let inner_offset;
2044 let mut inner_depth = depth.clone();
2045 if inlined {
2046 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2047 inner_offset = next_offset;
2048 } else {
2049 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2050 inner_depth.increment()?;
2051 }
2052 let val_ref = self.status_code.get_or_insert_with(|| {
2053 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
2054 });
2055 fidl::decode!(
2056 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
2057 D,
2058 val_ref,
2059 decoder,
2060 inner_offset,
2061 inner_depth
2062 )?;
2063 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2064 {
2065 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2066 }
2067 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2068 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2069 }
2070 }
2071
2072 next_offset += envelope_size;
2073 _next_ordinal_to_read += 1;
2074 if next_offset >= end_offset {
2075 return Ok(());
2076 }
2077
2078 while _next_ordinal_to_read < 4 {
2080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2081 _next_ordinal_to_read += 1;
2082 next_offset += envelope_size;
2083 }
2084
2085 let next_out_of_line = decoder.next_out_of_line();
2086 let handles_before = decoder.remaining_handles();
2087 if let Some((inlined, num_bytes, num_handles)) =
2088 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2089 {
2090 let member_inline_size =
2091 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2092 if inlined != (member_inline_size <= 4) {
2093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2094 }
2095 let inner_offset;
2096 let mut inner_depth = depth.clone();
2097 if inlined {
2098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2099 inner_offset = next_offset;
2100 } else {
2101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2102 inner_depth.increment()?;
2103 }
2104 let val_ref = self.timed_out.get_or_insert_with(|| fidl::new_empty!(bool, D));
2105 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2106 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2107 {
2108 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2109 }
2110 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2111 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2112 }
2113 }
2114
2115 next_offset += envelope_size;
2116
2117 while next_offset < end_offset {
2119 _next_ordinal_to_read += 1;
2120 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2121 next_offset += envelope_size;
2122 }
2123
2124 Ok(())
2125 }
2126 }
2127
2128 impl SupplicantStaIfaceCallbackOnDisconnectedRequest {
2129 #[inline(always)]
2130 fn max_ordinal_present(&self) -> u64 {
2131 if let Some(_) = self.reason_code {
2132 return 3;
2133 }
2134 if let Some(_) = self.locally_generated {
2135 return 2;
2136 }
2137 if let Some(_) = self.bssid {
2138 return 1;
2139 }
2140 0
2141 }
2142 }
2143
2144 impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnDisconnectedRequest {
2145 type Borrowed<'a> = &'a Self;
2146 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2147 value
2148 }
2149 }
2150
2151 unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnDisconnectedRequest {
2152 type Owned = Self;
2153
2154 #[inline(always)]
2155 fn inline_align(_context: fidl::encoding::Context) -> usize {
2156 8
2157 }
2158
2159 #[inline(always)]
2160 fn inline_size(_context: fidl::encoding::Context) -> usize {
2161 16
2162 }
2163 }
2164
2165 unsafe impl<D: fidl::encoding::ResourceDialect>
2166 fidl::encoding::Encode<SupplicantStaIfaceCallbackOnDisconnectedRequest, D>
2167 for &SupplicantStaIfaceCallbackOnDisconnectedRequest
2168 {
2169 unsafe fn encode(
2170 self,
2171 encoder: &mut fidl::encoding::Encoder<'_, D>,
2172 offset: usize,
2173 mut depth: fidl::encoding::Depth,
2174 ) -> fidl::Result<()> {
2175 encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnDisconnectedRequest>(offset);
2176 let max_ordinal: u64 = self.max_ordinal_present();
2178 encoder.write_num(max_ordinal, offset);
2179 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2180 if max_ordinal == 0 {
2182 return Ok(());
2183 }
2184 depth.increment()?;
2185 let envelope_size = 8;
2186 let bytes_len = max_ordinal as usize * envelope_size;
2187 #[allow(unused_variables)]
2188 let offset = encoder.out_of_line_offset(bytes_len);
2189 let mut _prev_end_offset: usize = 0;
2190 if 1 > max_ordinal {
2191 return Ok(());
2192 }
2193
2194 let cur_offset: usize = (1 - 1) * envelope_size;
2197
2198 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2200
2201 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2206 self.bssid
2207 .as_ref()
2208 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2209 encoder,
2210 offset + cur_offset,
2211 depth,
2212 )?;
2213
2214 _prev_end_offset = cur_offset + envelope_size;
2215 if 2 > max_ordinal {
2216 return Ok(());
2217 }
2218
2219 let cur_offset: usize = (2 - 1) * envelope_size;
2222
2223 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2225
2226 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2231 self.locally_generated
2232 .as_ref()
2233 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2234 encoder,
2235 offset + cur_offset,
2236 depth,
2237 )?;
2238
2239 _prev_end_offset = cur_offset + envelope_size;
2240 if 3 > max_ordinal {
2241 return Ok(());
2242 }
2243
2244 let cur_offset: usize = (3 - 1) * envelope_size;
2247
2248 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2250
2251 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
2256 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
2257 encoder, offset + cur_offset, depth
2258 )?;
2259
2260 _prev_end_offset = cur_offset + envelope_size;
2261
2262 Ok(())
2263 }
2264 }
2265
2266 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2267 for SupplicantStaIfaceCallbackOnDisconnectedRequest
2268 {
2269 #[inline(always)]
2270 fn new_empty() -> Self {
2271 Self::default()
2272 }
2273
2274 unsafe fn decode(
2275 &mut self,
2276 decoder: &mut fidl::encoding::Decoder<'_, D>,
2277 offset: usize,
2278 mut depth: fidl::encoding::Depth,
2279 ) -> fidl::Result<()> {
2280 decoder.debug_check_bounds::<Self>(offset);
2281 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2282 None => return Err(fidl::Error::NotNullable),
2283 Some(len) => len,
2284 };
2285 if len == 0 {
2287 return Ok(());
2288 };
2289 depth.increment()?;
2290 let envelope_size = 8;
2291 let bytes_len = len * envelope_size;
2292 let offset = decoder.out_of_line_offset(bytes_len)?;
2293 let mut _next_ordinal_to_read = 0;
2295 let mut next_offset = offset;
2296 let end_offset = offset + bytes_len;
2297 _next_ordinal_to_read += 1;
2298 if next_offset >= end_offset {
2299 return Ok(());
2300 }
2301
2302 while _next_ordinal_to_read < 1 {
2304 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2305 _next_ordinal_to_read += 1;
2306 next_offset += envelope_size;
2307 }
2308
2309 let next_out_of_line = decoder.next_out_of_line();
2310 let handles_before = decoder.remaining_handles();
2311 if let Some((inlined, num_bytes, num_handles)) =
2312 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2313 {
2314 let member_inline_size =
2315 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2316 decoder.context,
2317 );
2318 if inlined != (member_inline_size <= 4) {
2319 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2320 }
2321 let inner_offset;
2322 let mut inner_depth = depth.clone();
2323 if inlined {
2324 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2325 inner_offset = next_offset;
2326 } else {
2327 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2328 inner_depth.increment()?;
2329 }
2330 let val_ref = self
2331 .bssid
2332 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2333 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2334 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2335 {
2336 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2337 }
2338 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2339 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2340 }
2341 }
2342
2343 next_offset += envelope_size;
2344 _next_ordinal_to_read += 1;
2345 if next_offset >= end_offset {
2346 return Ok(());
2347 }
2348
2349 while _next_ordinal_to_read < 2 {
2351 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2352 _next_ordinal_to_read += 1;
2353 next_offset += envelope_size;
2354 }
2355
2356 let next_out_of_line = decoder.next_out_of_line();
2357 let handles_before = decoder.remaining_handles();
2358 if let Some((inlined, num_bytes, num_handles)) =
2359 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2360 {
2361 let member_inline_size =
2362 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2363 if inlined != (member_inline_size <= 4) {
2364 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2365 }
2366 let inner_offset;
2367 let mut inner_depth = depth.clone();
2368 if inlined {
2369 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2370 inner_offset = next_offset;
2371 } else {
2372 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2373 inner_depth.increment()?;
2374 }
2375 let val_ref =
2376 self.locally_generated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2377 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2379 {
2380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2381 }
2382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2384 }
2385 }
2386
2387 next_offset += envelope_size;
2388 _next_ordinal_to_read += 1;
2389 if next_offset >= end_offset {
2390 return Ok(());
2391 }
2392
2393 while _next_ordinal_to_read < 3 {
2395 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2396 _next_ordinal_to_read += 1;
2397 next_offset += envelope_size;
2398 }
2399
2400 let next_out_of_line = decoder.next_out_of_line();
2401 let handles_before = decoder.remaining_handles();
2402 if let Some((inlined, num_bytes, num_handles)) =
2403 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2404 {
2405 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2406 if inlined != (member_inline_size <= 4) {
2407 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2408 }
2409 let inner_offset;
2410 let mut inner_depth = depth.clone();
2411 if inlined {
2412 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2413 inner_offset = next_offset;
2414 } else {
2415 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2416 inner_depth.increment()?;
2417 }
2418 let val_ref = self.reason_code.get_or_insert_with(|| {
2419 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
2420 });
2421 fidl::decode!(
2422 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
2423 D,
2424 val_ref,
2425 decoder,
2426 inner_offset,
2427 inner_depth
2428 )?;
2429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2430 {
2431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2432 }
2433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2435 }
2436 }
2437
2438 next_offset += envelope_size;
2439
2440 while next_offset < end_offset {
2442 _next_ordinal_to_read += 1;
2443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2444 next_offset += envelope_size;
2445 }
2446
2447 Ok(())
2448 }
2449 }
2450
2451 impl SupplicantStaIfaceCallbackOnStateChangedRequest {
2452 #[inline(always)]
2453 fn max_ordinal_present(&self) -> u64 {
2454 if let Some(_) = self.ssid {
2455 return 4;
2456 }
2457 if let Some(_) = self.id {
2458 return 3;
2459 }
2460 if let Some(_) = self.bssid {
2461 return 2;
2462 }
2463 if let Some(_) = self.new_state {
2464 return 1;
2465 }
2466 0
2467 }
2468 }
2469
2470 impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnStateChangedRequest {
2471 type Borrowed<'a> = &'a Self;
2472 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2473 value
2474 }
2475 }
2476
2477 unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnStateChangedRequest {
2478 type Owned = Self;
2479
2480 #[inline(always)]
2481 fn inline_align(_context: fidl::encoding::Context) -> usize {
2482 8
2483 }
2484
2485 #[inline(always)]
2486 fn inline_size(_context: fidl::encoding::Context) -> usize {
2487 16
2488 }
2489 }
2490
2491 unsafe impl<D: fidl::encoding::ResourceDialect>
2492 fidl::encoding::Encode<SupplicantStaIfaceCallbackOnStateChangedRequest, D>
2493 for &SupplicantStaIfaceCallbackOnStateChangedRequest
2494 {
2495 unsafe fn encode(
2496 self,
2497 encoder: &mut fidl::encoding::Encoder<'_, D>,
2498 offset: usize,
2499 mut depth: fidl::encoding::Depth,
2500 ) -> fidl::Result<()> {
2501 encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnStateChangedRequest>(offset);
2502 let max_ordinal: u64 = self.max_ordinal_present();
2504 encoder.write_num(max_ordinal, offset);
2505 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2506 if max_ordinal == 0 {
2508 return Ok(());
2509 }
2510 depth.increment()?;
2511 let envelope_size = 8;
2512 let bytes_len = max_ordinal as usize * envelope_size;
2513 #[allow(unused_variables)]
2514 let offset = encoder.out_of_line_offset(bytes_len);
2515 let mut _prev_end_offset: usize = 0;
2516 if 1 > max_ordinal {
2517 return Ok(());
2518 }
2519
2520 let cur_offset: usize = (1 - 1) * envelope_size;
2523
2524 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2526
2527 fidl::encoding::encode_in_envelope_optional::<StaIfaceCallbackState, D>(
2532 self.new_state
2533 .as_ref()
2534 .map(<StaIfaceCallbackState as fidl::encoding::ValueTypeMarker>::borrow),
2535 encoder,
2536 offset + cur_offset,
2537 depth,
2538 )?;
2539
2540 _prev_end_offset = cur_offset + envelope_size;
2541 if 2 > max_ordinal {
2542 return Ok(());
2543 }
2544
2545 let cur_offset: usize = (2 - 1) * envelope_size;
2548
2549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2551
2552 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2557 self.bssid
2558 .as_ref()
2559 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2560 encoder,
2561 offset + cur_offset,
2562 depth,
2563 )?;
2564
2565 _prev_end_offset = cur_offset + envelope_size;
2566 if 3 > max_ordinal {
2567 return Ok(());
2568 }
2569
2570 let cur_offset: usize = (3 - 1) * envelope_size;
2573
2574 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2576
2577 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2582 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2583 encoder,
2584 offset + cur_offset,
2585 depth,
2586 )?;
2587
2588 _prev_end_offset = cur_offset + envelope_size;
2589 if 4 > max_ordinal {
2590 return Ok(());
2591 }
2592
2593 let cur_offset: usize = (4 - 1) * envelope_size;
2596
2597 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2599
2600 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
2605 self.ssid.as_ref().map(
2606 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
2607 ),
2608 encoder,
2609 offset + cur_offset,
2610 depth,
2611 )?;
2612
2613 _prev_end_offset = cur_offset + envelope_size;
2614
2615 Ok(())
2616 }
2617 }
2618
2619 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2620 for SupplicantStaIfaceCallbackOnStateChangedRequest
2621 {
2622 #[inline(always)]
2623 fn new_empty() -> Self {
2624 Self::default()
2625 }
2626
2627 unsafe fn decode(
2628 &mut self,
2629 decoder: &mut fidl::encoding::Decoder<'_, D>,
2630 offset: usize,
2631 mut depth: fidl::encoding::Depth,
2632 ) -> fidl::Result<()> {
2633 decoder.debug_check_bounds::<Self>(offset);
2634 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2635 None => return Err(fidl::Error::NotNullable),
2636 Some(len) => len,
2637 };
2638 if len == 0 {
2640 return Ok(());
2641 };
2642 depth.increment()?;
2643 let envelope_size = 8;
2644 let bytes_len = len * envelope_size;
2645 let offset = decoder.out_of_line_offset(bytes_len)?;
2646 let mut _next_ordinal_to_read = 0;
2648 let mut next_offset = offset;
2649 let end_offset = offset + bytes_len;
2650 _next_ordinal_to_read += 1;
2651 if next_offset >= end_offset {
2652 return Ok(());
2653 }
2654
2655 while _next_ordinal_to_read < 1 {
2657 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2658 _next_ordinal_to_read += 1;
2659 next_offset += envelope_size;
2660 }
2661
2662 let next_out_of_line = decoder.next_out_of_line();
2663 let handles_before = decoder.remaining_handles();
2664 if let Some((inlined, num_bytes, num_handles)) =
2665 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2666 {
2667 let member_inline_size =
2668 <StaIfaceCallbackState as fidl::encoding::TypeMarker>::inline_size(
2669 decoder.context,
2670 );
2671 if inlined != (member_inline_size <= 4) {
2672 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2673 }
2674 let inner_offset;
2675 let mut inner_depth = depth.clone();
2676 if inlined {
2677 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2678 inner_offset = next_offset;
2679 } else {
2680 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2681 inner_depth.increment()?;
2682 }
2683 let val_ref = self
2684 .new_state
2685 .get_or_insert_with(|| fidl::new_empty!(StaIfaceCallbackState, D));
2686 fidl::decode!(
2687 StaIfaceCallbackState,
2688 D,
2689 val_ref,
2690 decoder,
2691 inner_offset,
2692 inner_depth
2693 )?;
2694 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2695 {
2696 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2697 }
2698 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2699 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2700 }
2701 }
2702
2703 next_offset += envelope_size;
2704 _next_ordinal_to_read += 1;
2705 if next_offset >= end_offset {
2706 return Ok(());
2707 }
2708
2709 while _next_ordinal_to_read < 2 {
2711 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2712 _next_ordinal_to_read += 1;
2713 next_offset += envelope_size;
2714 }
2715
2716 let next_out_of_line = decoder.next_out_of_line();
2717 let handles_before = decoder.remaining_handles();
2718 if let Some((inlined, num_bytes, num_handles)) =
2719 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2720 {
2721 let member_inline_size =
2722 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2723 decoder.context,
2724 );
2725 if inlined != (member_inline_size <= 4) {
2726 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2727 }
2728 let inner_offset;
2729 let mut inner_depth = depth.clone();
2730 if inlined {
2731 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2732 inner_offset = next_offset;
2733 } else {
2734 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2735 inner_depth.increment()?;
2736 }
2737 let val_ref = self
2738 .bssid
2739 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2740 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2742 {
2743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2744 }
2745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2747 }
2748 }
2749
2750 next_offset += envelope_size;
2751 _next_ordinal_to_read += 1;
2752 if next_offset >= end_offset {
2753 return Ok(());
2754 }
2755
2756 while _next_ordinal_to_read < 3 {
2758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2759 _next_ordinal_to_read += 1;
2760 next_offset += envelope_size;
2761 }
2762
2763 let next_out_of_line = decoder.next_out_of_line();
2764 let handles_before = decoder.remaining_handles();
2765 if let Some((inlined, num_bytes, num_handles)) =
2766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2767 {
2768 let member_inline_size =
2769 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2770 if inlined != (member_inline_size <= 4) {
2771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2772 }
2773 let inner_offset;
2774 let mut inner_depth = depth.clone();
2775 if inlined {
2776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2777 inner_offset = next_offset;
2778 } else {
2779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2780 inner_depth.increment()?;
2781 }
2782 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2783 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2784 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2785 {
2786 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2787 }
2788 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2789 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2790 }
2791 }
2792
2793 next_offset += envelope_size;
2794 _next_ordinal_to_read += 1;
2795 if next_offset >= end_offset {
2796 return Ok(());
2797 }
2798
2799 while _next_ordinal_to_read < 4 {
2801 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2802 _next_ordinal_to_read += 1;
2803 next_offset += envelope_size;
2804 }
2805
2806 let next_out_of_line = decoder.next_out_of_line();
2807 let handles_before = decoder.remaining_handles();
2808 if let Some((inlined, num_bytes, num_handles)) =
2809 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2810 {
2811 let member_inline_size =
2812 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
2813 decoder.context,
2814 );
2815 if inlined != (member_inline_size <= 4) {
2816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2817 }
2818 let inner_offset;
2819 let mut inner_depth = depth.clone();
2820 if inlined {
2821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2822 inner_offset = next_offset;
2823 } else {
2824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2825 inner_depth.increment()?;
2826 }
2827 let val_ref = self
2828 .ssid
2829 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
2830 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
2831 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2832 {
2833 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2834 }
2835 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2836 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2837 }
2838 }
2839
2840 next_offset += envelope_size;
2841
2842 while next_offset < end_offset {
2844 _next_ordinal_to_read += 1;
2845 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2846 next_offset += envelope_size;
2847 }
2848
2849 Ok(())
2850 }
2851 }
2852
2853 impl SupplicantStaIfaceGetMacAddressResponse {
2854 #[inline(always)]
2855 fn max_ordinal_present(&self) -> u64 {
2856 if let Some(_) = self.mac_addr {
2857 return 1;
2858 }
2859 0
2860 }
2861 }
2862
2863 impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceGetMacAddressResponse {
2864 type Borrowed<'a> = &'a Self;
2865 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2866 value
2867 }
2868 }
2869
2870 unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceGetMacAddressResponse {
2871 type Owned = Self;
2872
2873 #[inline(always)]
2874 fn inline_align(_context: fidl::encoding::Context) -> usize {
2875 8
2876 }
2877
2878 #[inline(always)]
2879 fn inline_size(_context: fidl::encoding::Context) -> usize {
2880 16
2881 }
2882 }
2883
2884 unsafe impl<D: fidl::encoding::ResourceDialect>
2885 fidl::encoding::Encode<SupplicantStaIfaceGetMacAddressResponse, D>
2886 for &SupplicantStaIfaceGetMacAddressResponse
2887 {
2888 unsafe fn encode(
2889 self,
2890 encoder: &mut fidl::encoding::Encoder<'_, D>,
2891 offset: usize,
2892 mut depth: fidl::encoding::Depth,
2893 ) -> fidl::Result<()> {
2894 encoder.debug_check_bounds::<SupplicantStaIfaceGetMacAddressResponse>(offset);
2895 let max_ordinal: u64 = self.max_ordinal_present();
2897 encoder.write_num(max_ordinal, offset);
2898 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2899 if max_ordinal == 0 {
2901 return Ok(());
2902 }
2903 depth.increment()?;
2904 let envelope_size = 8;
2905 let bytes_len = max_ordinal as usize * envelope_size;
2906 #[allow(unused_variables)]
2907 let offset = encoder.out_of_line_offset(bytes_len);
2908 let mut _prev_end_offset: usize = 0;
2909 if 1 > max_ordinal {
2910 return Ok(());
2911 }
2912
2913 let cur_offset: usize = (1 - 1) * envelope_size;
2916
2917 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2919
2920 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2925 self.mac_addr
2926 .as_ref()
2927 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2928 encoder,
2929 offset + cur_offset,
2930 depth,
2931 )?;
2932
2933 _prev_end_offset = cur_offset + envelope_size;
2934
2935 Ok(())
2936 }
2937 }
2938
2939 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2940 for SupplicantStaIfaceGetMacAddressResponse
2941 {
2942 #[inline(always)]
2943 fn new_empty() -> Self {
2944 Self::default()
2945 }
2946
2947 unsafe fn decode(
2948 &mut self,
2949 decoder: &mut fidl::encoding::Decoder<'_, D>,
2950 offset: usize,
2951 mut depth: fidl::encoding::Depth,
2952 ) -> fidl::Result<()> {
2953 decoder.debug_check_bounds::<Self>(offset);
2954 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2955 None => return Err(fidl::Error::NotNullable),
2956 Some(len) => len,
2957 };
2958 if len == 0 {
2960 return Ok(());
2961 };
2962 depth.increment()?;
2963 let envelope_size = 8;
2964 let bytes_len = len * envelope_size;
2965 let offset = decoder.out_of_line_offset(bytes_len)?;
2966 let mut _next_ordinal_to_read = 0;
2968 let mut next_offset = offset;
2969 let end_offset = offset + bytes_len;
2970 _next_ordinal_to_read += 1;
2971 if next_offset >= end_offset {
2972 return Ok(());
2973 }
2974
2975 while _next_ordinal_to_read < 1 {
2977 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2978 _next_ordinal_to_read += 1;
2979 next_offset += envelope_size;
2980 }
2981
2982 let next_out_of_line = decoder.next_out_of_line();
2983 let handles_before = decoder.remaining_handles();
2984 if let Some((inlined, num_bytes, num_handles)) =
2985 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2986 {
2987 let member_inline_size =
2988 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2989 decoder.context,
2990 );
2991 if inlined != (member_inline_size <= 4) {
2992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2993 }
2994 let inner_offset;
2995 let mut inner_depth = depth.clone();
2996 if inlined {
2997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2998 inner_offset = next_offset;
2999 } else {
3000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3001 inner_depth.increment()?;
3002 }
3003 let val_ref = self
3004 .mac_addr
3005 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3006 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3007 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3008 {
3009 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3010 }
3011 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3012 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3013 }
3014 }
3015
3016 next_offset += envelope_size;
3017
3018 while next_offset < end_offset {
3020 _next_ordinal_to_read += 1;
3021 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3022 next_offset += envelope_size;
3023 }
3024
3025 Ok(())
3026 }
3027 }
3028
3029 impl SupplicantStaNetworkSetBssidRequest {
3030 #[inline(always)]
3031 fn max_ordinal_present(&self) -> u64 {
3032 if let Some(_) = self.bssid {
3033 return 1;
3034 }
3035 0
3036 }
3037 }
3038
3039 impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetBssidRequest {
3040 type Borrowed<'a> = &'a Self;
3041 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3042 value
3043 }
3044 }
3045
3046 unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetBssidRequest {
3047 type Owned = Self;
3048
3049 #[inline(always)]
3050 fn inline_align(_context: fidl::encoding::Context) -> usize {
3051 8
3052 }
3053
3054 #[inline(always)]
3055 fn inline_size(_context: fidl::encoding::Context) -> usize {
3056 16
3057 }
3058 }
3059
3060 unsafe impl<D: fidl::encoding::ResourceDialect>
3061 fidl::encoding::Encode<SupplicantStaNetworkSetBssidRequest, D>
3062 for &SupplicantStaNetworkSetBssidRequest
3063 {
3064 unsafe fn encode(
3065 self,
3066 encoder: &mut fidl::encoding::Encoder<'_, D>,
3067 offset: usize,
3068 mut depth: fidl::encoding::Depth,
3069 ) -> fidl::Result<()> {
3070 encoder.debug_check_bounds::<SupplicantStaNetworkSetBssidRequest>(offset);
3071 let max_ordinal: u64 = self.max_ordinal_present();
3073 encoder.write_num(max_ordinal, offset);
3074 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3075 if max_ordinal == 0 {
3077 return Ok(());
3078 }
3079 depth.increment()?;
3080 let envelope_size = 8;
3081 let bytes_len = max_ordinal as usize * envelope_size;
3082 #[allow(unused_variables)]
3083 let offset = encoder.out_of_line_offset(bytes_len);
3084 let mut _prev_end_offset: usize = 0;
3085 if 1 > max_ordinal {
3086 return Ok(());
3087 }
3088
3089 let cur_offset: usize = (1 - 1) * envelope_size;
3092
3093 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3095
3096 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3101 self.bssid
3102 .as_ref()
3103 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3104 encoder,
3105 offset + cur_offset,
3106 depth,
3107 )?;
3108
3109 _prev_end_offset = cur_offset + envelope_size;
3110
3111 Ok(())
3112 }
3113 }
3114
3115 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3116 for SupplicantStaNetworkSetBssidRequest
3117 {
3118 #[inline(always)]
3119 fn new_empty() -> Self {
3120 Self::default()
3121 }
3122
3123 unsafe fn decode(
3124 &mut self,
3125 decoder: &mut fidl::encoding::Decoder<'_, D>,
3126 offset: usize,
3127 mut depth: fidl::encoding::Depth,
3128 ) -> fidl::Result<()> {
3129 decoder.debug_check_bounds::<Self>(offset);
3130 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3131 None => return Err(fidl::Error::NotNullable),
3132 Some(len) => len,
3133 };
3134 if len == 0 {
3136 return Ok(());
3137 };
3138 depth.increment()?;
3139 let envelope_size = 8;
3140 let bytes_len = len * envelope_size;
3141 let offset = decoder.out_of_line_offset(bytes_len)?;
3142 let mut _next_ordinal_to_read = 0;
3144 let mut next_offset = offset;
3145 let end_offset = offset + bytes_len;
3146 _next_ordinal_to_read += 1;
3147 if next_offset >= end_offset {
3148 return Ok(());
3149 }
3150
3151 while _next_ordinal_to_read < 1 {
3153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3154 _next_ordinal_to_read += 1;
3155 next_offset += envelope_size;
3156 }
3157
3158 let next_out_of_line = decoder.next_out_of_line();
3159 let handles_before = decoder.remaining_handles();
3160 if let Some((inlined, num_bytes, num_handles)) =
3161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3162 {
3163 let member_inline_size =
3164 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3165 decoder.context,
3166 );
3167 if inlined != (member_inline_size <= 4) {
3168 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3169 }
3170 let inner_offset;
3171 let mut inner_depth = depth.clone();
3172 if inlined {
3173 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3174 inner_offset = next_offset;
3175 } else {
3176 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3177 inner_depth.increment()?;
3178 }
3179 let val_ref = self
3180 .bssid
3181 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3182 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3184 {
3185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3186 }
3187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3189 }
3190 }
3191
3192 next_offset += envelope_size;
3193
3194 while next_offset < end_offset {
3196 _next_ordinal_to_read += 1;
3197 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3198 next_offset += envelope_size;
3199 }
3200
3201 Ok(())
3202 }
3203 }
3204
3205 impl SupplicantStaNetworkSetPskPassphraseRequest {
3206 #[inline(always)]
3207 fn max_ordinal_present(&self) -> u64 {
3208 if let Some(_) = self.passphrase {
3209 return 1;
3210 }
3211 0
3212 }
3213 }
3214
3215 impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetPskPassphraseRequest {
3216 type Borrowed<'a> = &'a Self;
3217 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3218 value
3219 }
3220 }
3221
3222 unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetPskPassphraseRequest {
3223 type Owned = Self;
3224
3225 #[inline(always)]
3226 fn inline_align(_context: fidl::encoding::Context) -> usize {
3227 8
3228 }
3229
3230 #[inline(always)]
3231 fn inline_size(_context: fidl::encoding::Context) -> usize {
3232 16
3233 }
3234 }
3235
3236 unsafe impl<D: fidl::encoding::ResourceDialect>
3237 fidl::encoding::Encode<SupplicantStaNetworkSetPskPassphraseRequest, D>
3238 for &SupplicantStaNetworkSetPskPassphraseRequest
3239 {
3240 unsafe fn encode(
3241 self,
3242 encoder: &mut fidl::encoding::Encoder<'_, D>,
3243 offset: usize,
3244 mut depth: fidl::encoding::Depth,
3245 ) -> fidl::Result<()> {
3246 encoder.debug_check_bounds::<SupplicantStaNetworkSetPskPassphraseRequest>(offset);
3247 let max_ordinal: u64 = self.max_ordinal_present();
3249 encoder.write_num(max_ordinal, offset);
3250 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3251 if max_ordinal == 0 {
3253 return Ok(());
3254 }
3255 depth.increment()?;
3256 let envelope_size = 8;
3257 let bytes_len = max_ordinal as usize * envelope_size;
3258 #[allow(unused_variables)]
3259 let offset = encoder.out_of_line_offset(bytes_len);
3260 let mut _prev_end_offset: usize = 0;
3261 if 1 > max_ordinal {
3262 return Ok(());
3263 }
3264
3265 let cur_offset: usize = (1 - 1) * envelope_size;
3268
3269 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3271
3272 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3277 self.passphrase.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3278 encoder, offset + cur_offset, depth
3279 )?;
3280
3281 _prev_end_offset = cur_offset + envelope_size;
3282
3283 Ok(())
3284 }
3285 }
3286
3287 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3288 for SupplicantStaNetworkSetPskPassphraseRequest
3289 {
3290 #[inline(always)]
3291 fn new_empty() -> Self {
3292 Self::default()
3293 }
3294
3295 unsafe fn decode(
3296 &mut self,
3297 decoder: &mut fidl::encoding::Decoder<'_, D>,
3298 offset: usize,
3299 mut depth: fidl::encoding::Depth,
3300 ) -> fidl::Result<()> {
3301 decoder.debug_check_bounds::<Self>(offset);
3302 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3303 None => return Err(fidl::Error::NotNullable),
3304 Some(len) => len,
3305 };
3306 if len == 0 {
3308 return Ok(());
3309 };
3310 depth.increment()?;
3311 let envelope_size = 8;
3312 let bytes_len = len * envelope_size;
3313 let offset = decoder.out_of_line_offset(bytes_len)?;
3314 let mut _next_ordinal_to_read = 0;
3316 let mut next_offset = offset;
3317 let end_offset = offset + bytes_len;
3318 _next_ordinal_to_read += 1;
3319 if next_offset >= end_offset {
3320 return Ok(());
3321 }
3322
3323 while _next_ordinal_to_read < 1 {
3325 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3326 _next_ordinal_to_read += 1;
3327 next_offset += envelope_size;
3328 }
3329
3330 let next_out_of_line = decoder.next_out_of_line();
3331 let handles_before = decoder.remaining_handles();
3332 if let Some((inlined, num_bytes, num_handles)) =
3333 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3334 {
3335 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3336 if inlined != (member_inline_size <= 4) {
3337 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3338 }
3339 let inner_offset;
3340 let mut inner_depth = depth.clone();
3341 if inlined {
3342 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3343 inner_offset = next_offset;
3344 } else {
3345 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3346 inner_depth.increment()?;
3347 }
3348 let val_ref = self.passphrase.get_or_insert_with(|| {
3349 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
3350 });
3351 fidl::decode!(
3352 fidl::encoding::UnboundedVector<u8>,
3353 D,
3354 val_ref,
3355 decoder,
3356 inner_offset,
3357 inner_depth
3358 )?;
3359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3360 {
3361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3362 }
3363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3365 }
3366 }
3367
3368 next_offset += envelope_size;
3369
3370 while next_offset < end_offset {
3372 _next_ordinal_to_read += 1;
3373 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3374 next_offset += envelope_size;
3375 }
3376
3377 Ok(())
3378 }
3379 }
3380
3381 impl SupplicantStaNetworkSetSsidRequest {
3382 #[inline(always)]
3383 fn max_ordinal_present(&self) -> u64 {
3384 if let Some(_) = self.ssid {
3385 return 1;
3386 }
3387 0
3388 }
3389 }
3390
3391 impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetSsidRequest {
3392 type Borrowed<'a> = &'a Self;
3393 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3394 value
3395 }
3396 }
3397
3398 unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetSsidRequest {
3399 type Owned = Self;
3400
3401 #[inline(always)]
3402 fn inline_align(_context: fidl::encoding::Context) -> usize {
3403 8
3404 }
3405
3406 #[inline(always)]
3407 fn inline_size(_context: fidl::encoding::Context) -> usize {
3408 16
3409 }
3410 }
3411
3412 unsafe impl<D: fidl::encoding::ResourceDialect>
3413 fidl::encoding::Encode<SupplicantStaNetworkSetSsidRequest, D>
3414 for &SupplicantStaNetworkSetSsidRequest
3415 {
3416 unsafe fn encode(
3417 self,
3418 encoder: &mut fidl::encoding::Encoder<'_, D>,
3419 offset: usize,
3420 mut depth: fidl::encoding::Depth,
3421 ) -> fidl::Result<()> {
3422 encoder.debug_check_bounds::<SupplicantStaNetworkSetSsidRequest>(offset);
3423 let max_ordinal: u64 = self.max_ordinal_present();
3425 encoder.write_num(max_ordinal, offset);
3426 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3427 if max_ordinal == 0 {
3429 return Ok(());
3430 }
3431 depth.increment()?;
3432 let envelope_size = 8;
3433 let bytes_len = max_ordinal as usize * envelope_size;
3434 #[allow(unused_variables)]
3435 let offset = encoder.out_of_line_offset(bytes_len);
3436 let mut _prev_end_offset: usize = 0;
3437 if 1 > max_ordinal {
3438 return Ok(());
3439 }
3440
3441 let cur_offset: usize = (1 - 1) * envelope_size;
3444
3445 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3447
3448 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
3453 self.ssid.as_ref().map(
3454 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
3455 ),
3456 encoder,
3457 offset + cur_offset,
3458 depth,
3459 )?;
3460
3461 _prev_end_offset = cur_offset + envelope_size;
3462
3463 Ok(())
3464 }
3465 }
3466
3467 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3468 for SupplicantStaNetworkSetSsidRequest
3469 {
3470 #[inline(always)]
3471 fn new_empty() -> Self {
3472 Self::default()
3473 }
3474
3475 unsafe fn decode(
3476 &mut self,
3477 decoder: &mut fidl::encoding::Decoder<'_, D>,
3478 offset: usize,
3479 mut depth: fidl::encoding::Depth,
3480 ) -> fidl::Result<()> {
3481 decoder.debug_check_bounds::<Self>(offset);
3482 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3483 None => return Err(fidl::Error::NotNullable),
3484 Some(len) => len,
3485 };
3486 if len == 0 {
3488 return Ok(());
3489 };
3490 depth.increment()?;
3491 let envelope_size = 8;
3492 let bytes_len = len * envelope_size;
3493 let offset = decoder.out_of_line_offset(bytes_len)?;
3494 let mut _next_ordinal_to_read = 0;
3496 let mut next_offset = offset;
3497 let end_offset = offset + bytes_len;
3498 _next_ordinal_to_read += 1;
3499 if next_offset >= end_offset {
3500 return Ok(());
3501 }
3502
3503 while _next_ordinal_to_read < 1 {
3505 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3506 _next_ordinal_to_read += 1;
3507 next_offset += envelope_size;
3508 }
3509
3510 let next_out_of_line = decoder.next_out_of_line();
3511 let handles_before = decoder.remaining_handles();
3512 if let Some((inlined, num_bytes, num_handles)) =
3513 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3514 {
3515 let member_inline_size =
3516 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3517 decoder.context,
3518 );
3519 if inlined != (member_inline_size <= 4) {
3520 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3521 }
3522 let inner_offset;
3523 let mut inner_depth = depth.clone();
3524 if inlined {
3525 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3526 inner_offset = next_offset;
3527 } else {
3528 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3529 inner_depth.increment()?;
3530 }
3531 let val_ref = self
3532 .ssid
3533 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
3534 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3535 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3536 {
3537 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3538 }
3539 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3540 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3541 }
3542 }
3543
3544 next_offset += envelope_size;
3545
3546 while next_offset < end_offset {
3548 _next_ordinal_to_read += 1;
3549 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3550 next_offset += envelope_size;
3551 }
3552
3553 Ok(())
3554 }
3555 }
3556
3557 impl WifiChipGetAvailableModesResponse {
3558 #[inline(always)]
3559 fn max_ordinal_present(&self) -> u64 {
3560 if let Some(_) = self.chip_modes {
3561 return 1;
3562 }
3563 0
3564 }
3565 }
3566
3567 impl fidl::encoding::ValueTypeMarker for WifiChipGetAvailableModesResponse {
3568 type Borrowed<'a> = &'a Self;
3569 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3570 value
3571 }
3572 }
3573
3574 unsafe impl fidl::encoding::TypeMarker for WifiChipGetAvailableModesResponse {
3575 type Owned = Self;
3576
3577 #[inline(always)]
3578 fn inline_align(_context: fidl::encoding::Context) -> usize {
3579 8
3580 }
3581
3582 #[inline(always)]
3583 fn inline_size(_context: fidl::encoding::Context) -> usize {
3584 16
3585 }
3586 }
3587
3588 unsafe impl<D: fidl::encoding::ResourceDialect>
3589 fidl::encoding::Encode<WifiChipGetAvailableModesResponse, D>
3590 for &WifiChipGetAvailableModesResponse
3591 {
3592 unsafe fn encode(
3593 self,
3594 encoder: &mut fidl::encoding::Encoder<'_, D>,
3595 offset: usize,
3596 mut depth: fidl::encoding::Depth,
3597 ) -> fidl::Result<()> {
3598 encoder.debug_check_bounds::<WifiChipGetAvailableModesResponse>(offset);
3599 let max_ordinal: u64 = self.max_ordinal_present();
3601 encoder.write_num(max_ordinal, offset);
3602 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3603 if max_ordinal == 0 {
3605 return Ok(());
3606 }
3607 depth.increment()?;
3608 let envelope_size = 8;
3609 let bytes_len = max_ordinal as usize * envelope_size;
3610 #[allow(unused_variables)]
3611 let offset = encoder.out_of_line_offset(bytes_len);
3612 let mut _prev_end_offset: usize = 0;
3613 if 1 > max_ordinal {
3614 return Ok(());
3615 }
3616
3617 let cur_offset: usize = (1 - 1) * envelope_size;
3620
3621 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3623
3624 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipMode>, D>(
3629 self.chip_modes.as_ref().map(<fidl::encoding::UnboundedVector<ChipMode> as fidl::encoding::ValueTypeMarker>::borrow),
3630 encoder, offset + cur_offset, depth
3631 )?;
3632
3633 _prev_end_offset = cur_offset + envelope_size;
3634
3635 Ok(())
3636 }
3637 }
3638
3639 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3640 for WifiChipGetAvailableModesResponse
3641 {
3642 #[inline(always)]
3643 fn new_empty() -> Self {
3644 Self::default()
3645 }
3646
3647 unsafe fn decode(
3648 &mut self,
3649 decoder: &mut fidl::encoding::Decoder<'_, D>,
3650 offset: usize,
3651 mut depth: fidl::encoding::Depth,
3652 ) -> fidl::Result<()> {
3653 decoder.debug_check_bounds::<Self>(offset);
3654 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3655 None => return Err(fidl::Error::NotNullable),
3656 Some(len) => len,
3657 };
3658 if len == 0 {
3660 return Ok(());
3661 };
3662 depth.increment()?;
3663 let envelope_size = 8;
3664 let bytes_len = len * envelope_size;
3665 let offset = decoder.out_of_line_offset(bytes_len)?;
3666 let mut _next_ordinal_to_read = 0;
3668 let mut next_offset = offset;
3669 let end_offset = offset + bytes_len;
3670 _next_ordinal_to_read += 1;
3671 if next_offset >= end_offset {
3672 return Ok(());
3673 }
3674
3675 while _next_ordinal_to_read < 1 {
3677 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3678 _next_ordinal_to_read += 1;
3679 next_offset += envelope_size;
3680 }
3681
3682 let next_out_of_line = decoder.next_out_of_line();
3683 let handles_before = decoder.remaining_handles();
3684 if let Some((inlined, num_bytes, num_handles)) =
3685 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3686 {
3687 let member_inline_size = <fidl::encoding::UnboundedVector<ChipMode> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3688 if inlined != (member_inline_size <= 4) {
3689 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3690 }
3691 let inner_offset;
3692 let mut inner_depth = depth.clone();
3693 if inlined {
3694 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3695 inner_offset = next_offset;
3696 } else {
3697 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3698 inner_depth.increment()?;
3699 }
3700 let val_ref = self.chip_modes.get_or_insert_with(|| {
3701 fidl::new_empty!(fidl::encoding::UnboundedVector<ChipMode>, D)
3702 });
3703 fidl::decode!(
3704 fidl::encoding::UnboundedVector<ChipMode>,
3705 D,
3706 val_ref,
3707 decoder,
3708 inner_offset,
3709 inner_depth
3710 )?;
3711 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3712 {
3713 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3714 }
3715 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3716 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3717 }
3718 }
3719
3720 next_offset += envelope_size;
3721
3722 while next_offset < end_offset {
3724 _next_ordinal_to_read += 1;
3725 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3726 next_offset += envelope_size;
3727 }
3728
3729 Ok(())
3730 }
3731 }
3732
3733 impl WifiChipGetCapabilitiesResponse {
3734 #[inline(always)]
3735 fn max_ordinal_present(&self) -> u64 {
3736 if let Some(_) = self.capabilities_mask {
3737 return 1;
3738 }
3739 0
3740 }
3741 }
3742
3743 impl fidl::encoding::ValueTypeMarker for WifiChipGetCapabilitiesResponse {
3744 type Borrowed<'a> = &'a Self;
3745 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3746 value
3747 }
3748 }
3749
3750 unsafe impl fidl::encoding::TypeMarker for WifiChipGetCapabilitiesResponse {
3751 type Owned = Self;
3752
3753 #[inline(always)]
3754 fn inline_align(_context: fidl::encoding::Context) -> usize {
3755 8
3756 }
3757
3758 #[inline(always)]
3759 fn inline_size(_context: fidl::encoding::Context) -> usize {
3760 16
3761 }
3762 }
3763
3764 unsafe impl<D: fidl::encoding::ResourceDialect>
3765 fidl::encoding::Encode<WifiChipGetCapabilitiesResponse, D>
3766 for &WifiChipGetCapabilitiesResponse
3767 {
3768 unsafe fn encode(
3769 self,
3770 encoder: &mut fidl::encoding::Encoder<'_, D>,
3771 offset: usize,
3772 mut depth: fidl::encoding::Depth,
3773 ) -> fidl::Result<()> {
3774 encoder.debug_check_bounds::<WifiChipGetCapabilitiesResponse>(offset);
3775 let max_ordinal: u64 = self.max_ordinal_present();
3777 encoder.write_num(max_ordinal, offset);
3778 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3779 if max_ordinal == 0 {
3781 return Ok(());
3782 }
3783 depth.increment()?;
3784 let envelope_size = 8;
3785 let bytes_len = max_ordinal as usize * envelope_size;
3786 #[allow(unused_variables)]
3787 let offset = encoder.out_of_line_offset(bytes_len);
3788 let mut _prev_end_offset: usize = 0;
3789 if 1 > max_ordinal {
3790 return Ok(());
3791 }
3792
3793 let cur_offset: usize = (1 - 1) * envelope_size;
3796
3797 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3799
3800 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3805 self.capabilities_mask
3806 .as_ref()
3807 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3808 encoder,
3809 offset + cur_offset,
3810 depth,
3811 )?;
3812
3813 _prev_end_offset = cur_offset + envelope_size;
3814
3815 Ok(())
3816 }
3817 }
3818
3819 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3820 for WifiChipGetCapabilitiesResponse
3821 {
3822 #[inline(always)]
3823 fn new_empty() -> Self {
3824 Self::default()
3825 }
3826
3827 unsafe fn decode(
3828 &mut self,
3829 decoder: &mut fidl::encoding::Decoder<'_, D>,
3830 offset: usize,
3831 mut depth: fidl::encoding::Depth,
3832 ) -> fidl::Result<()> {
3833 decoder.debug_check_bounds::<Self>(offset);
3834 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3835 None => return Err(fidl::Error::NotNullable),
3836 Some(len) => len,
3837 };
3838 if len == 0 {
3840 return Ok(());
3841 };
3842 depth.increment()?;
3843 let envelope_size = 8;
3844 let bytes_len = len * envelope_size;
3845 let offset = decoder.out_of_line_offset(bytes_len)?;
3846 let mut _next_ordinal_to_read = 0;
3848 let mut next_offset = offset;
3849 let end_offset = offset + bytes_len;
3850 _next_ordinal_to_read += 1;
3851 if next_offset >= end_offset {
3852 return Ok(());
3853 }
3854
3855 while _next_ordinal_to_read < 1 {
3857 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3858 _next_ordinal_to_read += 1;
3859 next_offset += envelope_size;
3860 }
3861
3862 let next_out_of_line = decoder.next_out_of_line();
3863 let handles_before = decoder.remaining_handles();
3864 if let Some((inlined, num_bytes, num_handles)) =
3865 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3866 {
3867 let member_inline_size =
3868 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3869 if inlined != (member_inline_size <= 4) {
3870 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3871 }
3872 let inner_offset;
3873 let mut inner_depth = depth.clone();
3874 if inlined {
3875 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3876 inner_offset = next_offset;
3877 } else {
3878 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3879 inner_depth.increment()?;
3880 }
3881 let val_ref =
3882 self.capabilities_mask.get_or_insert_with(|| fidl::new_empty!(u32, D));
3883 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3884 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3885 {
3886 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3887 }
3888 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3889 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3890 }
3891 }
3892
3893 next_offset += envelope_size;
3894
3895 while next_offset < end_offset {
3897 _next_ordinal_to_read += 1;
3898 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3899 next_offset += envelope_size;
3900 }
3901
3902 Ok(())
3903 }
3904 }
3905
3906 impl WifiChipGetIdResponse {
3907 #[inline(always)]
3908 fn max_ordinal_present(&self) -> u64 {
3909 if let Some(_) = self.id {
3910 return 1;
3911 }
3912 0
3913 }
3914 }
3915
3916 impl fidl::encoding::ValueTypeMarker for WifiChipGetIdResponse {
3917 type Borrowed<'a> = &'a Self;
3918 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3919 value
3920 }
3921 }
3922
3923 unsafe impl fidl::encoding::TypeMarker for WifiChipGetIdResponse {
3924 type Owned = Self;
3925
3926 #[inline(always)]
3927 fn inline_align(_context: fidl::encoding::Context) -> usize {
3928 8
3929 }
3930
3931 #[inline(always)]
3932 fn inline_size(_context: fidl::encoding::Context) -> usize {
3933 16
3934 }
3935 }
3936
3937 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WifiChipGetIdResponse, D>
3938 for &WifiChipGetIdResponse
3939 {
3940 unsafe fn encode(
3941 self,
3942 encoder: &mut fidl::encoding::Encoder<'_, D>,
3943 offset: usize,
3944 mut depth: fidl::encoding::Depth,
3945 ) -> fidl::Result<()> {
3946 encoder.debug_check_bounds::<WifiChipGetIdResponse>(offset);
3947 let max_ordinal: u64 = self.max_ordinal_present();
3949 encoder.write_num(max_ordinal, offset);
3950 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3951 if max_ordinal == 0 {
3953 return Ok(());
3954 }
3955 depth.increment()?;
3956 let envelope_size = 8;
3957 let bytes_len = max_ordinal as usize * envelope_size;
3958 #[allow(unused_variables)]
3959 let offset = encoder.out_of_line_offset(bytes_len);
3960 let mut _prev_end_offset: usize = 0;
3961 if 1 > max_ordinal {
3962 return Ok(());
3963 }
3964
3965 let cur_offset: usize = (1 - 1) * envelope_size;
3968
3969 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3971
3972 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3977 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3978 encoder,
3979 offset + cur_offset,
3980 depth,
3981 )?;
3982
3983 _prev_end_offset = cur_offset + envelope_size;
3984
3985 Ok(())
3986 }
3987 }
3988
3989 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WifiChipGetIdResponse {
3990 #[inline(always)]
3991 fn new_empty() -> Self {
3992 Self::default()
3993 }
3994
3995 unsafe fn decode(
3996 &mut self,
3997 decoder: &mut fidl::encoding::Decoder<'_, D>,
3998 offset: usize,
3999 mut depth: fidl::encoding::Depth,
4000 ) -> fidl::Result<()> {
4001 decoder.debug_check_bounds::<Self>(offset);
4002 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4003 None => return Err(fidl::Error::NotNullable),
4004 Some(len) => len,
4005 };
4006 if len == 0 {
4008 return Ok(());
4009 };
4010 depth.increment()?;
4011 let envelope_size = 8;
4012 let bytes_len = len * envelope_size;
4013 let offset = decoder.out_of_line_offset(bytes_len)?;
4014 let mut _next_ordinal_to_read = 0;
4016 let mut next_offset = offset;
4017 let end_offset = offset + bytes_len;
4018 _next_ordinal_to_read += 1;
4019 if next_offset >= end_offset {
4020 return Ok(());
4021 }
4022
4023 while _next_ordinal_to_read < 1 {
4025 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4026 _next_ordinal_to_read += 1;
4027 next_offset += envelope_size;
4028 }
4029
4030 let next_out_of_line = decoder.next_out_of_line();
4031 let handles_before = decoder.remaining_handles();
4032 if let Some((inlined, num_bytes, num_handles)) =
4033 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4034 {
4035 let member_inline_size =
4036 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4037 if inlined != (member_inline_size <= 4) {
4038 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4039 }
4040 let inner_offset;
4041 let mut inner_depth = depth.clone();
4042 if inlined {
4043 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4044 inner_offset = next_offset;
4045 } else {
4046 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4047 inner_depth.increment()?;
4048 }
4049 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
4050 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4051 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4052 {
4053 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4054 }
4055 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4056 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4057 }
4058 }
4059
4060 next_offset += envelope_size;
4061
4062 while next_offset < end_offset {
4064 _next_ordinal_to_read += 1;
4065 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4066 next_offset += envelope_size;
4067 }
4068
4069 Ok(())
4070 }
4071 }
4072
4073 impl WifiChipGetModeResponse {
4074 #[inline(always)]
4075 fn max_ordinal_present(&self) -> u64 {
4076 if let Some(_) = self.mode {
4077 return 1;
4078 }
4079 0
4080 }
4081 }
4082
4083 impl fidl::encoding::ValueTypeMarker for WifiChipGetModeResponse {
4084 type Borrowed<'a> = &'a Self;
4085 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4086 value
4087 }
4088 }
4089
4090 unsafe impl fidl::encoding::TypeMarker for WifiChipGetModeResponse {
4091 type Owned = Self;
4092
4093 #[inline(always)]
4094 fn inline_align(_context: fidl::encoding::Context) -> usize {
4095 8
4096 }
4097
4098 #[inline(always)]
4099 fn inline_size(_context: fidl::encoding::Context) -> usize {
4100 16
4101 }
4102 }
4103
4104 unsafe impl<D: fidl::encoding::ResourceDialect>
4105 fidl::encoding::Encode<WifiChipGetModeResponse, D> for &WifiChipGetModeResponse
4106 {
4107 unsafe fn encode(
4108 self,
4109 encoder: &mut fidl::encoding::Encoder<'_, D>,
4110 offset: usize,
4111 mut depth: fidl::encoding::Depth,
4112 ) -> fidl::Result<()> {
4113 encoder.debug_check_bounds::<WifiChipGetModeResponse>(offset);
4114 let max_ordinal: u64 = self.max_ordinal_present();
4116 encoder.write_num(max_ordinal, offset);
4117 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4118 if max_ordinal == 0 {
4120 return Ok(());
4121 }
4122 depth.increment()?;
4123 let envelope_size = 8;
4124 let bytes_len = max_ordinal as usize * envelope_size;
4125 #[allow(unused_variables)]
4126 let offset = encoder.out_of_line_offset(bytes_len);
4127 let mut _prev_end_offset: usize = 0;
4128 if 1 > max_ordinal {
4129 return Ok(());
4130 }
4131
4132 let cur_offset: usize = (1 - 1) * envelope_size;
4135
4136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4138
4139 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4144 self.mode.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4145 encoder,
4146 offset + cur_offset,
4147 depth,
4148 )?;
4149
4150 _prev_end_offset = cur_offset + envelope_size;
4151
4152 Ok(())
4153 }
4154 }
4155
4156 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4157 for WifiChipGetModeResponse
4158 {
4159 #[inline(always)]
4160 fn new_empty() -> Self {
4161 Self::default()
4162 }
4163
4164 unsafe fn decode(
4165 &mut self,
4166 decoder: &mut fidl::encoding::Decoder<'_, D>,
4167 offset: usize,
4168 mut depth: fidl::encoding::Depth,
4169 ) -> fidl::Result<()> {
4170 decoder.debug_check_bounds::<Self>(offset);
4171 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4172 None => return Err(fidl::Error::NotNullable),
4173 Some(len) => len,
4174 };
4175 if len == 0 {
4177 return Ok(());
4178 };
4179 depth.increment()?;
4180 let envelope_size = 8;
4181 let bytes_len = len * envelope_size;
4182 let offset = decoder.out_of_line_offset(bytes_len)?;
4183 let mut _next_ordinal_to_read = 0;
4185 let mut next_offset = offset;
4186 let end_offset = offset + bytes_len;
4187 _next_ordinal_to_read += 1;
4188 if next_offset >= end_offset {
4189 return Ok(());
4190 }
4191
4192 while _next_ordinal_to_read < 1 {
4194 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4195 _next_ordinal_to_read += 1;
4196 next_offset += envelope_size;
4197 }
4198
4199 let next_out_of_line = decoder.next_out_of_line();
4200 let handles_before = decoder.remaining_handles();
4201 if let Some((inlined, num_bytes, num_handles)) =
4202 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4203 {
4204 let member_inline_size =
4205 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4206 if inlined != (member_inline_size <= 4) {
4207 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4208 }
4209 let inner_offset;
4210 let mut inner_depth = depth.clone();
4211 if inlined {
4212 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4213 inner_offset = next_offset;
4214 } else {
4215 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4216 inner_depth.increment()?;
4217 }
4218 let val_ref = self.mode.get_or_insert_with(|| fidl::new_empty!(u32, D));
4219 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4220 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4221 {
4222 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4223 }
4224 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4225 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4226 }
4227 }
4228
4229 next_offset += envelope_size;
4230
4231 while next_offset < end_offset {
4233 _next_ordinal_to_read += 1;
4234 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4235 next_offset += envelope_size;
4236 }
4237
4238 Ok(())
4239 }
4240 }
4241
4242 impl WifiChipGetStaIfaceNamesResponse {
4243 #[inline(always)]
4244 fn max_ordinal_present(&self) -> u64 {
4245 if let Some(_) = self.iface_names {
4246 return 1;
4247 }
4248 0
4249 }
4250 }
4251
4252 impl fidl::encoding::ValueTypeMarker for WifiChipGetStaIfaceNamesResponse {
4253 type Borrowed<'a> = &'a Self;
4254 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4255 value
4256 }
4257 }
4258
4259 unsafe impl fidl::encoding::TypeMarker for WifiChipGetStaIfaceNamesResponse {
4260 type Owned = Self;
4261
4262 #[inline(always)]
4263 fn inline_align(_context: fidl::encoding::Context) -> usize {
4264 8
4265 }
4266
4267 #[inline(always)]
4268 fn inline_size(_context: fidl::encoding::Context) -> usize {
4269 16
4270 }
4271 }
4272
4273 unsafe impl<D: fidl::encoding::ResourceDialect>
4274 fidl::encoding::Encode<WifiChipGetStaIfaceNamesResponse, D>
4275 for &WifiChipGetStaIfaceNamesResponse
4276 {
4277 unsafe fn encode(
4278 self,
4279 encoder: &mut fidl::encoding::Encoder<'_, D>,
4280 offset: usize,
4281 mut depth: fidl::encoding::Depth,
4282 ) -> fidl::Result<()> {
4283 encoder.debug_check_bounds::<WifiChipGetStaIfaceNamesResponse>(offset);
4284 let max_ordinal: u64 = self.max_ordinal_present();
4286 encoder.write_num(max_ordinal, offset);
4287 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4288 if max_ordinal == 0 {
4290 return Ok(());
4291 }
4292 depth.increment()?;
4293 let envelope_size = 8;
4294 let bytes_len = max_ordinal as usize * envelope_size;
4295 #[allow(unused_variables)]
4296 let offset = encoder.out_of_line_offset(bytes_len);
4297 let mut _prev_end_offset: usize = 0;
4298 if 1 > max_ordinal {
4299 return Ok(());
4300 }
4301
4302 let cur_offset: usize = (1 - 1) * envelope_size;
4305
4306 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4308
4309 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>, D>(
4314 self.iface_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>> as fidl::encoding::ValueTypeMarker>::borrow),
4315 encoder, offset + cur_offset, depth
4316 )?;
4317
4318 _prev_end_offset = cur_offset + envelope_size;
4319
4320 Ok(())
4321 }
4322 }
4323
4324 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4325 for WifiChipGetStaIfaceNamesResponse
4326 {
4327 #[inline(always)]
4328 fn new_empty() -> Self {
4329 Self::default()
4330 }
4331
4332 unsafe fn decode(
4333 &mut self,
4334 decoder: &mut fidl::encoding::Decoder<'_, D>,
4335 offset: usize,
4336 mut depth: fidl::encoding::Depth,
4337 ) -> fidl::Result<()> {
4338 decoder.debug_check_bounds::<Self>(offset);
4339 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4340 None => return Err(fidl::Error::NotNullable),
4341 Some(len) => len,
4342 };
4343 if len == 0 {
4345 return Ok(());
4346 };
4347 depth.increment()?;
4348 let envelope_size = 8;
4349 let bytes_len = len * envelope_size;
4350 let offset = decoder.out_of_line_offset(bytes_len)?;
4351 let mut _next_ordinal_to_read = 0;
4353 let mut next_offset = offset;
4354 let end_offset = offset + bytes_len;
4355 _next_ordinal_to_read += 1;
4356 if next_offset >= end_offset {
4357 return Ok(());
4358 }
4359
4360 while _next_ordinal_to_read < 1 {
4362 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4363 _next_ordinal_to_read += 1;
4364 next_offset += envelope_size;
4365 }
4366
4367 let next_out_of_line = decoder.next_out_of_line();
4368 let handles_before = decoder.remaining_handles();
4369 if let Some((inlined, num_bytes, num_handles)) =
4370 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4371 {
4372 let member_inline_size = <fidl::encoding::UnboundedVector<
4373 fidl::encoding::BoundedString<16>,
4374 > as fidl::encoding::TypeMarker>::inline_size(
4375 decoder.context
4376 );
4377 if inlined != (member_inline_size <= 4) {
4378 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4379 }
4380 let inner_offset;
4381 let mut inner_depth = depth.clone();
4382 if inlined {
4383 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4384 inner_offset = next_offset;
4385 } else {
4386 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4387 inner_depth.increment()?;
4388 }
4389 let val_ref = self.iface_names.get_or_insert_with(|| {
4390 fidl::new_empty!(
4391 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>,
4392 D
4393 )
4394 });
4395 fidl::decode!(
4396 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>,
4397 D,
4398 val_ref,
4399 decoder,
4400 inner_offset,
4401 inner_depth
4402 )?;
4403 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4404 {
4405 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4406 }
4407 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4408 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4409 }
4410 }
4411
4412 next_offset += envelope_size;
4413
4414 while next_offset < end_offset {
4416 _next_ordinal_to_read += 1;
4417 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4418 next_offset += envelope_size;
4419 }
4420
4421 Ok(())
4422 }
4423 }
4424
4425 impl WifiStaIfaceGetNameResponse {
4426 #[inline(always)]
4427 fn max_ordinal_present(&self) -> u64 {
4428 if let Some(_) = self.iface_name {
4429 return 1;
4430 }
4431 0
4432 }
4433 }
4434
4435 impl fidl::encoding::ValueTypeMarker for WifiStaIfaceGetNameResponse {
4436 type Borrowed<'a> = &'a Self;
4437 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4438 value
4439 }
4440 }
4441
4442 unsafe impl fidl::encoding::TypeMarker for WifiStaIfaceGetNameResponse {
4443 type Owned = Self;
4444
4445 #[inline(always)]
4446 fn inline_align(_context: fidl::encoding::Context) -> usize {
4447 8
4448 }
4449
4450 #[inline(always)]
4451 fn inline_size(_context: fidl::encoding::Context) -> usize {
4452 16
4453 }
4454 }
4455
4456 unsafe impl<D: fidl::encoding::ResourceDialect>
4457 fidl::encoding::Encode<WifiStaIfaceGetNameResponse, D> for &WifiStaIfaceGetNameResponse
4458 {
4459 unsafe fn encode(
4460 self,
4461 encoder: &mut fidl::encoding::Encoder<'_, D>,
4462 offset: usize,
4463 mut depth: fidl::encoding::Depth,
4464 ) -> fidl::Result<()> {
4465 encoder.debug_check_bounds::<WifiStaIfaceGetNameResponse>(offset);
4466 let max_ordinal: u64 = self.max_ordinal_present();
4468 encoder.write_num(max_ordinal, offset);
4469 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4470 if max_ordinal == 0 {
4472 return Ok(());
4473 }
4474 depth.increment()?;
4475 let envelope_size = 8;
4476 let bytes_len = max_ordinal as usize * envelope_size;
4477 #[allow(unused_variables)]
4478 let offset = encoder.out_of_line_offset(bytes_len);
4479 let mut _prev_end_offset: usize = 0;
4480 if 1 > max_ordinal {
4481 return Ok(());
4482 }
4483
4484 let cur_offset: usize = (1 - 1) * envelope_size;
4487
4488 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4490
4491 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
4496 self.iface_name.as_ref().map(
4497 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
4498 ),
4499 encoder,
4500 offset + cur_offset,
4501 depth,
4502 )?;
4503
4504 _prev_end_offset = cur_offset + envelope_size;
4505
4506 Ok(())
4507 }
4508 }
4509
4510 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4511 for WifiStaIfaceGetNameResponse
4512 {
4513 #[inline(always)]
4514 fn new_empty() -> Self {
4515 Self::default()
4516 }
4517
4518 unsafe fn decode(
4519 &mut self,
4520 decoder: &mut fidl::encoding::Decoder<'_, D>,
4521 offset: usize,
4522 mut depth: fidl::encoding::Depth,
4523 ) -> fidl::Result<()> {
4524 decoder.debug_check_bounds::<Self>(offset);
4525 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4526 None => return Err(fidl::Error::NotNullable),
4527 Some(len) => len,
4528 };
4529 if len == 0 {
4531 return Ok(());
4532 };
4533 depth.increment()?;
4534 let envelope_size = 8;
4535 let bytes_len = len * envelope_size;
4536 let offset = decoder.out_of_line_offset(bytes_len)?;
4537 let mut _next_ordinal_to_read = 0;
4539 let mut next_offset = offset;
4540 let end_offset = offset + bytes_len;
4541 _next_ordinal_to_read += 1;
4542 if next_offset >= end_offset {
4543 return Ok(());
4544 }
4545
4546 while _next_ordinal_to_read < 1 {
4548 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4549 _next_ordinal_to_read += 1;
4550 next_offset += envelope_size;
4551 }
4552
4553 let next_out_of_line = decoder.next_out_of_line();
4554 let handles_before = decoder.remaining_handles();
4555 if let Some((inlined, num_bytes, num_handles)) =
4556 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4557 {
4558 let member_inline_size =
4559 <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
4560 decoder.context,
4561 );
4562 if inlined != (member_inline_size <= 4) {
4563 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4564 }
4565 let inner_offset;
4566 let mut inner_depth = depth.clone();
4567 if inlined {
4568 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4569 inner_offset = next_offset;
4570 } else {
4571 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4572 inner_depth.increment()?;
4573 }
4574 let val_ref = self
4575 .iface_name
4576 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
4577 fidl::decode!(
4578 fidl::encoding::BoundedString<16>,
4579 D,
4580 val_ref,
4581 decoder,
4582 inner_offset,
4583 inner_depth
4584 )?;
4585 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4586 {
4587 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4588 }
4589 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4590 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4591 }
4592 }
4593
4594 next_offset += envelope_size;
4595
4596 while next_offset < end_offset {
4598 _next_ordinal_to_read += 1;
4599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4600 next_offset += envelope_size;
4601 }
4602
4603 Ok(())
4604 }
4605 }
4606
4607 impl WifiGetChipIdsResponse {
4608 #[inline(always)]
4609 fn max_ordinal_present(&self) -> u64 {
4610 if let Some(_) = self.chip_ids {
4611 return 1;
4612 }
4613 0
4614 }
4615 }
4616
4617 impl fidl::encoding::ValueTypeMarker for WifiGetChipIdsResponse {
4618 type Borrowed<'a> = &'a Self;
4619 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4620 value
4621 }
4622 }
4623
4624 unsafe impl fidl::encoding::TypeMarker for WifiGetChipIdsResponse {
4625 type Owned = Self;
4626
4627 #[inline(always)]
4628 fn inline_align(_context: fidl::encoding::Context) -> usize {
4629 8
4630 }
4631
4632 #[inline(always)]
4633 fn inline_size(_context: fidl::encoding::Context) -> usize {
4634 16
4635 }
4636 }
4637
4638 unsafe impl<D: fidl::encoding::ResourceDialect>
4639 fidl::encoding::Encode<WifiGetChipIdsResponse, D> for &WifiGetChipIdsResponse
4640 {
4641 unsafe fn encode(
4642 self,
4643 encoder: &mut fidl::encoding::Encoder<'_, D>,
4644 offset: usize,
4645 mut depth: fidl::encoding::Depth,
4646 ) -> fidl::Result<()> {
4647 encoder.debug_check_bounds::<WifiGetChipIdsResponse>(offset);
4648 let max_ordinal: u64 = self.max_ordinal_present();
4650 encoder.write_num(max_ordinal, offset);
4651 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4652 if max_ordinal == 0 {
4654 return Ok(());
4655 }
4656 depth.increment()?;
4657 let envelope_size = 8;
4658 let bytes_len = max_ordinal as usize * envelope_size;
4659 #[allow(unused_variables)]
4660 let offset = encoder.out_of_line_offset(bytes_len);
4661 let mut _prev_end_offset: usize = 0;
4662 if 1 > max_ordinal {
4663 return Ok(());
4664 }
4665
4666 let cur_offset: usize = (1 - 1) * envelope_size;
4669
4670 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4672
4673 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, D>(
4678 self.chip_ids.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
4679 encoder, offset + cur_offset, depth
4680 )?;
4681
4682 _prev_end_offset = cur_offset + envelope_size;
4683
4684 Ok(())
4685 }
4686 }
4687
4688 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4689 for WifiGetChipIdsResponse
4690 {
4691 #[inline(always)]
4692 fn new_empty() -> Self {
4693 Self::default()
4694 }
4695
4696 unsafe fn decode(
4697 &mut self,
4698 decoder: &mut fidl::encoding::Decoder<'_, D>,
4699 offset: usize,
4700 mut depth: fidl::encoding::Depth,
4701 ) -> fidl::Result<()> {
4702 decoder.debug_check_bounds::<Self>(offset);
4703 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4704 None => return Err(fidl::Error::NotNullable),
4705 Some(len) => len,
4706 };
4707 if len == 0 {
4709 return Ok(());
4710 };
4711 depth.increment()?;
4712 let envelope_size = 8;
4713 let bytes_len = len * envelope_size;
4714 let offset = decoder.out_of_line_offset(bytes_len)?;
4715 let mut _next_ordinal_to_read = 0;
4717 let mut next_offset = offset;
4718 let end_offset = offset + bytes_len;
4719 _next_ordinal_to_read += 1;
4720 if next_offset >= end_offset {
4721 return Ok(());
4722 }
4723
4724 while _next_ordinal_to_read < 1 {
4726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4727 _next_ordinal_to_read += 1;
4728 next_offset += envelope_size;
4729 }
4730
4731 let next_out_of_line = decoder.next_out_of_line();
4732 let handles_before = decoder.remaining_handles();
4733 if let Some((inlined, num_bytes, num_handles)) =
4734 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4735 {
4736 let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4737 if inlined != (member_inline_size <= 4) {
4738 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4739 }
4740 let inner_offset;
4741 let mut inner_depth = depth.clone();
4742 if inlined {
4743 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4744 inner_offset = next_offset;
4745 } else {
4746 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4747 inner_depth.increment()?;
4748 }
4749 let val_ref = self.chip_ids.get_or_insert_with(|| {
4750 fidl::new_empty!(fidl::encoding::UnboundedVector<u32>, D)
4751 });
4752 fidl::decode!(
4753 fidl::encoding::UnboundedVector<u32>,
4754 D,
4755 val_ref,
4756 decoder,
4757 inner_offset,
4758 inner_depth
4759 )?;
4760 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4761 {
4762 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4763 }
4764 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4765 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4766 }
4767 }
4768
4769 next_offset += envelope_size;
4770
4771 while next_offset < end_offset {
4773 _next_ordinal_to_read += 1;
4774 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4775 next_offset += envelope_size;
4776 }
4777
4778 Ok(())
4779 }
4780 }
4781
4782 impl WifiGetStateResponse {
4783 #[inline(always)]
4784 fn max_ordinal_present(&self) -> u64 {
4785 if let Some(_) = self.is_started {
4786 return 1;
4787 }
4788 0
4789 }
4790 }
4791
4792 impl fidl::encoding::ValueTypeMarker for WifiGetStateResponse {
4793 type Borrowed<'a> = &'a Self;
4794 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4795 value
4796 }
4797 }
4798
4799 unsafe impl fidl::encoding::TypeMarker for WifiGetStateResponse {
4800 type Owned = Self;
4801
4802 #[inline(always)]
4803 fn inline_align(_context: fidl::encoding::Context) -> usize {
4804 8
4805 }
4806
4807 #[inline(always)]
4808 fn inline_size(_context: fidl::encoding::Context) -> usize {
4809 16
4810 }
4811 }
4812
4813 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WifiGetStateResponse, D>
4814 for &WifiGetStateResponse
4815 {
4816 unsafe fn encode(
4817 self,
4818 encoder: &mut fidl::encoding::Encoder<'_, D>,
4819 offset: usize,
4820 mut depth: fidl::encoding::Depth,
4821 ) -> fidl::Result<()> {
4822 encoder.debug_check_bounds::<WifiGetStateResponse>(offset);
4823 let max_ordinal: u64 = self.max_ordinal_present();
4825 encoder.write_num(max_ordinal, offset);
4826 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4827 if max_ordinal == 0 {
4829 return Ok(());
4830 }
4831 depth.increment()?;
4832 let envelope_size = 8;
4833 let bytes_len = max_ordinal as usize * envelope_size;
4834 #[allow(unused_variables)]
4835 let offset = encoder.out_of_line_offset(bytes_len);
4836 let mut _prev_end_offset: usize = 0;
4837 if 1 > max_ordinal {
4838 return Ok(());
4839 }
4840
4841 let cur_offset: usize = (1 - 1) * envelope_size;
4844
4845 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4847
4848 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4853 self.is_started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4854 encoder,
4855 offset + cur_offset,
4856 depth,
4857 )?;
4858
4859 _prev_end_offset = cur_offset + envelope_size;
4860
4861 Ok(())
4862 }
4863 }
4864
4865 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WifiGetStateResponse {
4866 #[inline(always)]
4867 fn new_empty() -> Self {
4868 Self::default()
4869 }
4870
4871 unsafe fn decode(
4872 &mut self,
4873 decoder: &mut fidl::encoding::Decoder<'_, D>,
4874 offset: usize,
4875 mut depth: fidl::encoding::Depth,
4876 ) -> fidl::Result<()> {
4877 decoder.debug_check_bounds::<Self>(offset);
4878 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4879 None => return Err(fidl::Error::NotNullable),
4880 Some(len) => len,
4881 };
4882 if len == 0 {
4884 return Ok(());
4885 };
4886 depth.increment()?;
4887 let envelope_size = 8;
4888 let bytes_len = len * envelope_size;
4889 let offset = decoder.out_of_line_offset(bytes_len)?;
4890 let mut _next_ordinal_to_read = 0;
4892 let mut next_offset = offset;
4893 let end_offset = offset + bytes_len;
4894 _next_ordinal_to_read += 1;
4895 if next_offset >= end_offset {
4896 return Ok(());
4897 }
4898
4899 while _next_ordinal_to_read < 1 {
4901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4902 _next_ordinal_to_read += 1;
4903 next_offset += envelope_size;
4904 }
4905
4906 let next_out_of_line = decoder.next_out_of_line();
4907 let handles_before = decoder.remaining_handles();
4908 if let Some((inlined, num_bytes, num_handles)) =
4909 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4910 {
4911 let member_inline_size =
4912 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4913 if inlined != (member_inline_size <= 4) {
4914 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4915 }
4916 let inner_offset;
4917 let mut inner_depth = depth.clone();
4918 if inlined {
4919 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4920 inner_offset = next_offset;
4921 } else {
4922 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4923 inner_depth.increment()?;
4924 }
4925 let val_ref = self.is_started.get_or_insert_with(|| fidl::new_empty!(bool, D));
4926 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4927 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4928 {
4929 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4930 }
4931 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4932 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4933 }
4934 }
4935
4936 next_offset += envelope_size;
4937
4938 while next_offset < end_offset {
4940 _next_ordinal_to_read += 1;
4941 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4942 next_offset += envelope_size;
4943 }
4944
4945 Ok(())
4946 }
4947 }
4948}