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