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