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