1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13pub const COUNTER_NAME_MAX_LENGTH: u8 = 127;
14
15pub const MAX_DRIVER_SPECIFIC_COUNTERS: u32 = 127;
16
17pub const MAX_HISTOGRAMS_PER_TYPE: u8 = 8;
21
22pub const MAX_NOISE_FLOOR_SAMPLES: u8 = 255;
27
28pub const MAX_RSSI_SAMPLES: u8 = 255;
30
31pub const MAX_RX_RATE_INDEX_SAMPLES: u8 = 196;
33
34pub const MAX_SNR_SAMPLES: u16 = 256;
36
37#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
39#[repr(u8)]
40pub enum AntennaFreq {
41 Antenna2G = 1,
43 Antenna5G = 2,
45}
46
47impl AntennaFreq {
48 #[inline]
49 pub fn from_primitive(prim: u8) -> Option<Self> {
50 match prim {
51 1 => Some(Self::Antenna2G),
52 2 => Some(Self::Antenna5G),
53 _ => None,
54 }
55 }
56
57 #[inline]
58 pub const fn into_primitive(self) -> u8 {
59 self as u8
60 }
61
62 #[deprecated = "Strict enums should not use `is_unknown`"]
63 #[inline]
64 pub fn is_unknown(&self) -> bool {
65 false
66 }
67}
68
69#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
72#[repr(u8)]
73pub enum HistScope {
74 Station = 1,
75 PerAntenna = 2,
76}
77
78impl HistScope {
79 #[inline]
80 pub fn from_primitive(prim: u8) -> Option<Self> {
81 match prim {
82 1 => Some(Self::Station),
83 2 => Some(Self::PerAntenna),
84 _ => None,
85 }
86 }
87
88 #[inline]
89 pub const fn into_primitive(self) -> u8 {
90 self as u8
91 }
92
93 #[deprecated = "Strict enums should not use `is_unknown`"]
94 #[inline]
95 pub fn is_unknown(&self) -> bool {
96 false
97 }
98}
99
100#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
102pub struct AntennaId {
103 pub freq: AntennaFreq,
104 pub index: u8,
106}
107
108impl fidl::Persistable for AntennaId {}
109
110#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
112#[repr(C)]
113pub struct HistBucket {
114 pub bucket_index: u16,
117 pub num_samples: u64,
119}
120
121impl fidl::Persistable for HistBucket {}
122
123#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
125pub struct NoiseFloorHistogram {
126 pub hist_scope: HistScope,
127 pub antenna_id: Option<Box<AntennaId>>,
129 pub noise_floor_samples: Vec<HistBucket>,
134 pub invalid_samples: u64,
136}
137
138impl fidl::Persistable for NoiseFloorHistogram {}
139
140#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
142pub struct RssiHistogram {
143 pub hist_scope: HistScope,
144 pub antenna_id: Option<Box<AntennaId>>,
146 pub rssi_samples: Vec<HistBucket>,
151 pub invalid_samples: u64,
153}
154
155impl fidl::Persistable for RssiHistogram {}
156
157#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
159pub struct RxRateIndexHistogram {
160 pub hist_scope: HistScope,
161 pub antenna_id: Option<Box<AntennaId>>,
163 pub rx_rate_index_samples: Vec<HistBucket>,
188 pub invalid_samples: u64,
190}
191
192impl fidl::Persistable for RxRateIndexHistogram {}
193
194#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
196pub struct SnrHistogram {
197 pub hist_scope: HistScope,
198 pub antenna_id: Option<Box<AntennaId>>,
200 pub snr_samples: Vec<HistBucket>,
205 pub invalid_samples: u64,
207}
208
209impl fidl::Persistable for SnrHistogram {}
210
211#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
212#[repr(C)]
213pub struct UnnamedCounter {
214 pub id: u16,
215 pub count: u64,
216}
217
218impl fidl::Persistable for UnnamedCounter {}
219
220#[derive(Clone, Debug, Default, PartialEq)]
221pub struct ConnectionCounters {
222 pub connection_id: Option<u8>,
232 pub driver_specific_counters: Option<Vec<UnnamedCounter>>,
233 pub rx_unicast_total: Option<u64>,
234 pub rx_unicast_drop: Option<u64>,
235 pub rx_multicast: Option<u64>,
236 pub tx_total: Option<u64>,
237 pub tx_drop: Option<u64>,
238 #[doc(hidden)]
239 pub __source_breaking: fidl::marker::SourceBreaking,
240}
241
242impl fidl::Persistable for ConnectionCounters {}
243
244#[derive(Clone, Debug, Default, PartialEq)]
245pub struct IfaceCounterStats {
246 pub connection_counters: Option<ConnectionCounters>,
248 pub driver_specific_counters: Option<Vec<UnnamedCounter>>,
249 #[doc(hidden)]
250 pub __source_breaking: fidl::marker::SourceBreaking,
251}
252
253impl fidl::Persistable for IfaceCounterStats {}
254
255#[derive(Clone, Debug, Default, PartialEq)]
256pub struct IfaceHistogramStats {
257 pub noise_floor_histograms: Option<Vec<NoiseFloorHistogram>>,
259 pub rssi_histograms: Option<Vec<RssiHistogram>>,
261 pub rx_rate_index_histograms: Option<Vec<RxRateIndexHistogram>>,
263 pub snr_histograms: Option<Vec<SnrHistogram>>,
265 #[doc(hidden)]
266 pub __source_breaking: fidl::marker::SourceBreaking,
267}
268
269impl fidl::Persistable for IfaceHistogramStats {}
270
271#[derive(Clone, Debug, Default, PartialEq)]
274pub struct InspectCounterConfig {
275 pub counter_id: Option<u16>,
276 pub counter_name: Option<String>,
277 #[doc(hidden)]
278 pub __source_breaking: fidl::marker::SourceBreaking,
279}
280
281impl fidl::Persistable for InspectCounterConfig {}
282
283#[derive(Clone, Debug, Default, PartialEq)]
284pub struct TelemetrySupport {
285 pub inspect_counter_configs: Option<Vec<InspectCounterConfig>>,
287 #[doc(hidden)]
288 pub __source_breaking: fidl::marker::SourceBreaking,
289}
290
291impl fidl::Persistable for TelemetrySupport {}
292
293mod internal {
294 use super::*;
295 unsafe impl fidl::encoding::TypeMarker for AntennaFreq {
296 type Owned = Self;
297
298 #[inline(always)]
299 fn inline_align(_context: fidl::encoding::Context) -> usize {
300 std::mem::align_of::<u8>()
301 }
302
303 #[inline(always)]
304 fn inline_size(_context: fidl::encoding::Context) -> usize {
305 std::mem::size_of::<u8>()
306 }
307
308 #[inline(always)]
309 fn encode_is_copy() -> bool {
310 true
311 }
312
313 #[inline(always)]
314 fn decode_is_copy() -> bool {
315 false
316 }
317 }
318
319 impl fidl::encoding::ValueTypeMarker for AntennaFreq {
320 type Borrowed<'a> = Self;
321 #[inline(always)]
322 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
323 *value
324 }
325 }
326
327 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AntennaFreq {
328 #[inline]
329 unsafe fn encode(
330 self,
331 encoder: &mut fidl::encoding::Encoder<'_, D>,
332 offset: usize,
333 _depth: fidl::encoding::Depth,
334 ) -> fidl::Result<()> {
335 encoder.debug_check_bounds::<Self>(offset);
336 encoder.write_num(self.into_primitive(), offset);
337 Ok(())
338 }
339 }
340
341 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AntennaFreq {
342 #[inline(always)]
343 fn new_empty() -> Self {
344 Self::Antenna2G
345 }
346
347 #[inline]
348 unsafe fn decode(
349 &mut self,
350 decoder: &mut fidl::encoding::Decoder<'_, D>,
351 offset: usize,
352 _depth: fidl::encoding::Depth,
353 ) -> fidl::Result<()> {
354 decoder.debug_check_bounds::<Self>(offset);
355 let prim = decoder.read_num::<u8>(offset);
356
357 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
358 Ok(())
359 }
360 }
361 unsafe impl fidl::encoding::TypeMarker for HistScope {
362 type Owned = Self;
363
364 #[inline(always)]
365 fn inline_align(_context: fidl::encoding::Context) -> usize {
366 std::mem::align_of::<u8>()
367 }
368
369 #[inline(always)]
370 fn inline_size(_context: fidl::encoding::Context) -> usize {
371 std::mem::size_of::<u8>()
372 }
373
374 #[inline(always)]
375 fn encode_is_copy() -> bool {
376 true
377 }
378
379 #[inline(always)]
380 fn decode_is_copy() -> bool {
381 false
382 }
383 }
384
385 impl fidl::encoding::ValueTypeMarker for HistScope {
386 type Borrowed<'a> = Self;
387 #[inline(always)]
388 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
389 *value
390 }
391 }
392
393 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HistScope {
394 #[inline]
395 unsafe fn encode(
396 self,
397 encoder: &mut fidl::encoding::Encoder<'_, D>,
398 offset: usize,
399 _depth: fidl::encoding::Depth,
400 ) -> fidl::Result<()> {
401 encoder.debug_check_bounds::<Self>(offset);
402 encoder.write_num(self.into_primitive(), offset);
403 Ok(())
404 }
405 }
406
407 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistScope {
408 #[inline(always)]
409 fn new_empty() -> Self {
410 Self::Station
411 }
412
413 #[inline]
414 unsafe fn decode(
415 &mut self,
416 decoder: &mut fidl::encoding::Decoder<'_, D>,
417 offset: usize,
418 _depth: fidl::encoding::Depth,
419 ) -> fidl::Result<()> {
420 decoder.debug_check_bounds::<Self>(offset);
421 let prim = decoder.read_num::<u8>(offset);
422
423 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
424 Ok(())
425 }
426 }
427
428 impl fidl::encoding::ValueTypeMarker for AntennaId {
429 type Borrowed<'a> = &'a Self;
430 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
431 value
432 }
433 }
434
435 unsafe impl fidl::encoding::TypeMarker for AntennaId {
436 type Owned = Self;
437
438 #[inline(always)]
439 fn inline_align(_context: fidl::encoding::Context) -> usize {
440 1
441 }
442
443 #[inline(always)]
444 fn inline_size(_context: fidl::encoding::Context) -> usize {
445 2
446 }
447 }
448
449 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AntennaId, D>
450 for &AntennaId
451 {
452 #[inline]
453 unsafe fn encode(
454 self,
455 encoder: &mut fidl::encoding::Encoder<'_, D>,
456 offset: usize,
457 _depth: fidl::encoding::Depth,
458 ) -> fidl::Result<()> {
459 encoder.debug_check_bounds::<AntennaId>(offset);
460 fidl::encoding::Encode::<AntennaId, D>::encode(
462 (
463 <AntennaFreq as fidl::encoding::ValueTypeMarker>::borrow(&self.freq),
464 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
465 ),
466 encoder,
467 offset,
468 _depth,
469 )
470 }
471 }
472 unsafe impl<
473 D: fidl::encoding::ResourceDialect,
474 T0: fidl::encoding::Encode<AntennaFreq, D>,
475 T1: fidl::encoding::Encode<u8, D>,
476 > fidl::encoding::Encode<AntennaId, D> for (T0, T1)
477 {
478 #[inline]
479 unsafe fn encode(
480 self,
481 encoder: &mut fidl::encoding::Encoder<'_, D>,
482 offset: usize,
483 depth: fidl::encoding::Depth,
484 ) -> fidl::Result<()> {
485 encoder.debug_check_bounds::<AntennaId>(offset);
486 self.0.encode(encoder, offset + 0, depth)?;
490 self.1.encode(encoder, offset + 1, depth)?;
491 Ok(())
492 }
493 }
494
495 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AntennaId {
496 #[inline(always)]
497 fn new_empty() -> Self {
498 Self { freq: fidl::new_empty!(AntennaFreq, D), index: fidl::new_empty!(u8, D) }
499 }
500
501 #[inline]
502 unsafe fn decode(
503 &mut self,
504 decoder: &mut fidl::encoding::Decoder<'_, D>,
505 offset: usize,
506 _depth: fidl::encoding::Depth,
507 ) -> fidl::Result<()> {
508 decoder.debug_check_bounds::<Self>(offset);
509 fidl::decode!(AntennaFreq, D, &mut self.freq, decoder, offset + 0, _depth)?;
511 fidl::decode!(u8, D, &mut self.index, decoder, offset + 1, _depth)?;
512 Ok(())
513 }
514 }
515
516 impl fidl::encoding::ValueTypeMarker for HistBucket {
517 type Borrowed<'a> = &'a Self;
518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
519 value
520 }
521 }
522
523 unsafe impl fidl::encoding::TypeMarker for HistBucket {
524 type Owned = Self;
525
526 #[inline(always)]
527 fn inline_align(_context: fidl::encoding::Context) -> usize {
528 8
529 }
530
531 #[inline(always)]
532 fn inline_size(_context: fidl::encoding::Context) -> usize {
533 16
534 }
535 }
536
537 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HistBucket, D>
538 for &HistBucket
539 {
540 #[inline]
541 unsafe fn encode(
542 self,
543 encoder: &mut fidl::encoding::Encoder<'_, D>,
544 offset: usize,
545 _depth: fidl::encoding::Depth,
546 ) -> fidl::Result<()> {
547 encoder.debug_check_bounds::<HistBucket>(offset);
548 unsafe {
549 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
551 (buf_ptr as *mut HistBucket).write_unaligned((self as *const HistBucket).read());
552 let padding_ptr = buf_ptr.offset(0) as *mut u64;
555 let padding_mask = 0xffffffffffff0000u64;
556 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
557 }
558 Ok(())
559 }
560 }
561 unsafe impl<
562 D: fidl::encoding::ResourceDialect,
563 T0: fidl::encoding::Encode<u16, D>,
564 T1: fidl::encoding::Encode<u64, D>,
565 > fidl::encoding::Encode<HistBucket, D> for (T0, T1)
566 {
567 #[inline]
568 unsafe fn encode(
569 self,
570 encoder: &mut fidl::encoding::Encoder<'_, D>,
571 offset: usize,
572 depth: fidl::encoding::Depth,
573 ) -> fidl::Result<()> {
574 encoder.debug_check_bounds::<HistBucket>(offset);
575 unsafe {
578 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
579 (ptr as *mut u64).write_unaligned(0);
580 }
581 self.0.encode(encoder, offset + 0, depth)?;
583 self.1.encode(encoder, offset + 8, depth)?;
584 Ok(())
585 }
586 }
587
588 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistBucket {
589 #[inline(always)]
590 fn new_empty() -> Self {
591 Self { bucket_index: fidl::new_empty!(u16, D), num_samples: fidl::new_empty!(u64, D) }
592 }
593
594 #[inline]
595 unsafe fn decode(
596 &mut self,
597 decoder: &mut fidl::encoding::Decoder<'_, D>,
598 offset: usize,
599 _depth: fidl::encoding::Depth,
600 ) -> fidl::Result<()> {
601 decoder.debug_check_bounds::<Self>(offset);
602 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
603 let ptr = unsafe { buf_ptr.offset(0) };
605 let padval = unsafe { (ptr as *const u64).read_unaligned() };
606 let mask = 0xffffffffffff0000u64;
607 let maskedval = padval & mask;
608 if maskedval != 0 {
609 return Err(fidl::Error::NonZeroPadding {
610 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
611 });
612 }
613 unsafe {
615 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
616 }
617 Ok(())
618 }
619 }
620
621 impl fidl::encoding::ValueTypeMarker for NoiseFloorHistogram {
622 type Borrowed<'a> = &'a Self;
623 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
624 value
625 }
626 }
627
628 unsafe impl fidl::encoding::TypeMarker for NoiseFloorHistogram {
629 type Owned = Self;
630
631 #[inline(always)]
632 fn inline_align(_context: fidl::encoding::Context) -> usize {
633 8
634 }
635
636 #[inline(always)]
637 fn inline_size(_context: fidl::encoding::Context) -> usize {
638 40
639 }
640 }
641
642 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NoiseFloorHistogram, D>
643 for &NoiseFloorHistogram
644 {
645 #[inline]
646 unsafe fn encode(
647 self,
648 encoder: &mut fidl::encoding::Encoder<'_, D>,
649 offset: usize,
650 _depth: fidl::encoding::Depth,
651 ) -> fidl::Result<()> {
652 encoder.debug_check_bounds::<NoiseFloorHistogram>(offset);
653 fidl::encoding::Encode::<NoiseFloorHistogram, D>::encode(
655 (
656 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
657 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
658 <fidl::encoding::Vector<HistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.noise_floor_samples),
659 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
660 ),
661 encoder, offset, _depth
662 )
663 }
664 }
665 unsafe impl<
666 D: fidl::encoding::ResourceDialect,
667 T0: fidl::encoding::Encode<HistScope, D>,
668 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
669 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 255>, D>,
670 T3: fidl::encoding::Encode<u64, D>,
671 > fidl::encoding::Encode<NoiseFloorHistogram, D> for (T0, T1, T2, T3)
672 {
673 #[inline]
674 unsafe fn encode(
675 self,
676 encoder: &mut fidl::encoding::Encoder<'_, D>,
677 offset: usize,
678 depth: fidl::encoding::Depth,
679 ) -> fidl::Result<()> {
680 encoder.debug_check_bounds::<NoiseFloorHistogram>(offset);
681 unsafe {
684 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
685 (ptr as *mut u64).write_unaligned(0);
686 }
687 self.0.encode(encoder, offset + 0, depth)?;
689 self.1.encode(encoder, offset + 8, depth)?;
690 self.2.encode(encoder, offset + 16, depth)?;
691 self.3.encode(encoder, offset + 32, depth)?;
692 Ok(())
693 }
694 }
695
696 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NoiseFloorHistogram {
697 #[inline(always)]
698 fn new_empty() -> Self {
699 Self {
700 hist_scope: fidl::new_empty!(HistScope, D),
701 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
702 noise_floor_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 255>, D),
703 invalid_samples: fidl::new_empty!(u64, D),
704 }
705 }
706
707 #[inline]
708 unsafe fn decode(
709 &mut self,
710 decoder: &mut fidl::encoding::Decoder<'_, D>,
711 offset: usize,
712 _depth: fidl::encoding::Depth,
713 ) -> fidl::Result<()> {
714 decoder.debug_check_bounds::<Self>(offset);
715 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
717 let padval = unsafe { (ptr as *const u64).read_unaligned() };
718 let mask = 0xffffffffffffff00u64;
719 let maskedval = padval & mask;
720 if maskedval != 0 {
721 return Err(fidl::Error::NonZeroPadding {
722 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
723 });
724 }
725 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
726 fidl::decode!(
727 fidl::encoding::Boxed<AntennaId>,
728 D,
729 &mut self.antenna_id,
730 decoder,
731 offset + 8,
732 _depth
733 )?;
734 fidl::decode!(fidl::encoding::Vector<HistBucket, 255>, D, &mut self.noise_floor_samples, decoder, offset + 16, _depth)?;
735 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
736 Ok(())
737 }
738 }
739
740 impl fidl::encoding::ValueTypeMarker for RssiHistogram {
741 type Borrowed<'a> = &'a Self;
742 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
743 value
744 }
745 }
746
747 unsafe impl fidl::encoding::TypeMarker for RssiHistogram {
748 type Owned = Self;
749
750 #[inline(always)]
751 fn inline_align(_context: fidl::encoding::Context) -> usize {
752 8
753 }
754
755 #[inline(always)]
756 fn inline_size(_context: fidl::encoding::Context) -> usize {
757 40
758 }
759 }
760
761 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RssiHistogram, D>
762 for &RssiHistogram
763 {
764 #[inline]
765 unsafe fn encode(
766 self,
767 encoder: &mut fidl::encoding::Encoder<'_, D>,
768 offset: usize,
769 _depth: fidl::encoding::Depth,
770 ) -> fidl::Result<()> {
771 encoder.debug_check_bounds::<RssiHistogram>(offset);
772 fidl::encoding::Encode::<RssiHistogram, D>::encode(
774 (
775 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
776 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
777 <fidl::encoding::Vector<HistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi_samples),
778 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
779 ),
780 encoder, offset, _depth
781 )
782 }
783 }
784 unsafe impl<
785 D: fidl::encoding::ResourceDialect,
786 T0: fidl::encoding::Encode<HistScope, D>,
787 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
788 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 255>, D>,
789 T3: fidl::encoding::Encode<u64, D>,
790 > fidl::encoding::Encode<RssiHistogram, D> for (T0, T1, T2, T3)
791 {
792 #[inline]
793 unsafe fn encode(
794 self,
795 encoder: &mut fidl::encoding::Encoder<'_, D>,
796 offset: usize,
797 depth: fidl::encoding::Depth,
798 ) -> fidl::Result<()> {
799 encoder.debug_check_bounds::<RssiHistogram>(offset);
800 unsafe {
803 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
804 (ptr as *mut u64).write_unaligned(0);
805 }
806 self.0.encode(encoder, offset + 0, depth)?;
808 self.1.encode(encoder, offset + 8, depth)?;
809 self.2.encode(encoder, offset + 16, depth)?;
810 self.3.encode(encoder, offset + 32, depth)?;
811 Ok(())
812 }
813 }
814
815 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RssiHistogram {
816 #[inline(always)]
817 fn new_empty() -> Self {
818 Self {
819 hist_scope: fidl::new_empty!(HistScope, D),
820 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
821 rssi_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 255>, D),
822 invalid_samples: fidl::new_empty!(u64, D),
823 }
824 }
825
826 #[inline]
827 unsafe fn decode(
828 &mut self,
829 decoder: &mut fidl::encoding::Decoder<'_, D>,
830 offset: usize,
831 _depth: fidl::encoding::Depth,
832 ) -> fidl::Result<()> {
833 decoder.debug_check_bounds::<Self>(offset);
834 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
836 let padval = unsafe { (ptr as *const u64).read_unaligned() };
837 let mask = 0xffffffffffffff00u64;
838 let maskedval = padval & mask;
839 if maskedval != 0 {
840 return Err(fidl::Error::NonZeroPadding {
841 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
842 });
843 }
844 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
845 fidl::decode!(
846 fidl::encoding::Boxed<AntennaId>,
847 D,
848 &mut self.antenna_id,
849 decoder,
850 offset + 8,
851 _depth
852 )?;
853 fidl::decode!(fidl::encoding::Vector<HistBucket, 255>, D, &mut self.rssi_samples, decoder, offset + 16, _depth)?;
854 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
855 Ok(())
856 }
857 }
858
859 impl fidl::encoding::ValueTypeMarker for RxRateIndexHistogram {
860 type Borrowed<'a> = &'a Self;
861 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
862 value
863 }
864 }
865
866 unsafe impl fidl::encoding::TypeMarker for RxRateIndexHistogram {
867 type Owned = Self;
868
869 #[inline(always)]
870 fn inline_align(_context: fidl::encoding::Context) -> usize {
871 8
872 }
873
874 #[inline(always)]
875 fn inline_size(_context: fidl::encoding::Context) -> usize {
876 40
877 }
878 }
879
880 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RxRateIndexHistogram, D>
881 for &RxRateIndexHistogram
882 {
883 #[inline]
884 unsafe fn encode(
885 self,
886 encoder: &mut fidl::encoding::Encoder<'_, D>,
887 offset: usize,
888 _depth: fidl::encoding::Depth,
889 ) -> fidl::Result<()> {
890 encoder.debug_check_bounds::<RxRateIndexHistogram>(offset);
891 fidl::encoding::Encode::<RxRateIndexHistogram, D>::encode(
893 (
894 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
895 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
896 <fidl::encoding::Vector<HistBucket, 196> as fidl::encoding::ValueTypeMarker>::borrow(&self.rx_rate_index_samples),
897 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
898 ),
899 encoder, offset, _depth
900 )
901 }
902 }
903 unsafe impl<
904 D: fidl::encoding::ResourceDialect,
905 T0: fidl::encoding::Encode<HistScope, D>,
906 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
907 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 196>, D>,
908 T3: fidl::encoding::Encode<u64, D>,
909 > fidl::encoding::Encode<RxRateIndexHistogram, D> for (T0, T1, T2, T3)
910 {
911 #[inline]
912 unsafe fn encode(
913 self,
914 encoder: &mut fidl::encoding::Encoder<'_, D>,
915 offset: usize,
916 depth: fidl::encoding::Depth,
917 ) -> fidl::Result<()> {
918 encoder.debug_check_bounds::<RxRateIndexHistogram>(offset);
919 unsafe {
922 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
923 (ptr as *mut u64).write_unaligned(0);
924 }
925 self.0.encode(encoder, offset + 0, depth)?;
927 self.1.encode(encoder, offset + 8, depth)?;
928 self.2.encode(encoder, offset + 16, depth)?;
929 self.3.encode(encoder, offset + 32, depth)?;
930 Ok(())
931 }
932 }
933
934 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RxRateIndexHistogram {
935 #[inline(always)]
936 fn new_empty() -> Self {
937 Self {
938 hist_scope: fidl::new_empty!(HistScope, D),
939 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
940 rx_rate_index_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 196>, D),
941 invalid_samples: fidl::new_empty!(u64, D),
942 }
943 }
944
945 #[inline]
946 unsafe fn decode(
947 &mut self,
948 decoder: &mut fidl::encoding::Decoder<'_, D>,
949 offset: usize,
950 _depth: fidl::encoding::Depth,
951 ) -> fidl::Result<()> {
952 decoder.debug_check_bounds::<Self>(offset);
953 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
955 let padval = unsafe { (ptr as *const u64).read_unaligned() };
956 let mask = 0xffffffffffffff00u64;
957 let maskedval = padval & mask;
958 if maskedval != 0 {
959 return Err(fidl::Error::NonZeroPadding {
960 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
961 });
962 }
963 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
964 fidl::decode!(
965 fidl::encoding::Boxed<AntennaId>,
966 D,
967 &mut self.antenna_id,
968 decoder,
969 offset + 8,
970 _depth
971 )?;
972 fidl::decode!(fidl::encoding::Vector<HistBucket, 196>, D, &mut self.rx_rate_index_samples, decoder, offset + 16, _depth)?;
973 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
974 Ok(())
975 }
976 }
977
978 impl fidl::encoding::ValueTypeMarker for SnrHistogram {
979 type Borrowed<'a> = &'a Self;
980 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
981 value
982 }
983 }
984
985 unsafe impl fidl::encoding::TypeMarker for SnrHistogram {
986 type Owned = Self;
987
988 #[inline(always)]
989 fn inline_align(_context: fidl::encoding::Context) -> usize {
990 8
991 }
992
993 #[inline(always)]
994 fn inline_size(_context: fidl::encoding::Context) -> usize {
995 40
996 }
997 }
998
999 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SnrHistogram, D>
1000 for &SnrHistogram
1001 {
1002 #[inline]
1003 unsafe fn encode(
1004 self,
1005 encoder: &mut fidl::encoding::Encoder<'_, D>,
1006 offset: usize,
1007 _depth: fidl::encoding::Depth,
1008 ) -> fidl::Result<()> {
1009 encoder.debug_check_bounds::<SnrHistogram>(offset);
1010 fidl::encoding::Encode::<SnrHistogram, D>::encode(
1012 (
1013 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
1014 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
1015 <fidl::encoding::Vector<HistBucket, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.snr_samples),
1016 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
1017 ),
1018 encoder, offset, _depth
1019 )
1020 }
1021 }
1022 unsafe impl<
1023 D: fidl::encoding::ResourceDialect,
1024 T0: fidl::encoding::Encode<HistScope, D>,
1025 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
1026 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 256>, D>,
1027 T3: fidl::encoding::Encode<u64, D>,
1028 > fidl::encoding::Encode<SnrHistogram, D> for (T0, T1, T2, T3)
1029 {
1030 #[inline]
1031 unsafe fn encode(
1032 self,
1033 encoder: &mut fidl::encoding::Encoder<'_, D>,
1034 offset: usize,
1035 depth: fidl::encoding::Depth,
1036 ) -> fidl::Result<()> {
1037 encoder.debug_check_bounds::<SnrHistogram>(offset);
1038 unsafe {
1041 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1042 (ptr as *mut u64).write_unaligned(0);
1043 }
1044 self.0.encode(encoder, offset + 0, depth)?;
1046 self.1.encode(encoder, offset + 8, depth)?;
1047 self.2.encode(encoder, offset + 16, depth)?;
1048 self.3.encode(encoder, offset + 32, depth)?;
1049 Ok(())
1050 }
1051 }
1052
1053 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SnrHistogram {
1054 #[inline(always)]
1055 fn new_empty() -> Self {
1056 Self {
1057 hist_scope: fidl::new_empty!(HistScope, D),
1058 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
1059 snr_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 256>, D),
1060 invalid_samples: fidl::new_empty!(u64, D),
1061 }
1062 }
1063
1064 #[inline]
1065 unsafe fn decode(
1066 &mut self,
1067 decoder: &mut fidl::encoding::Decoder<'_, D>,
1068 offset: usize,
1069 _depth: fidl::encoding::Depth,
1070 ) -> fidl::Result<()> {
1071 decoder.debug_check_bounds::<Self>(offset);
1072 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1074 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1075 let mask = 0xffffffffffffff00u64;
1076 let maskedval = padval & mask;
1077 if maskedval != 0 {
1078 return Err(fidl::Error::NonZeroPadding {
1079 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1080 });
1081 }
1082 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
1083 fidl::decode!(
1084 fidl::encoding::Boxed<AntennaId>,
1085 D,
1086 &mut self.antenna_id,
1087 decoder,
1088 offset + 8,
1089 _depth
1090 )?;
1091 fidl::decode!(fidl::encoding::Vector<HistBucket, 256>, D, &mut self.snr_samples, decoder, offset + 16, _depth)?;
1092 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
1093 Ok(())
1094 }
1095 }
1096
1097 impl fidl::encoding::ValueTypeMarker for UnnamedCounter {
1098 type Borrowed<'a> = &'a Self;
1099 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1100 value
1101 }
1102 }
1103
1104 unsafe impl fidl::encoding::TypeMarker for UnnamedCounter {
1105 type Owned = Self;
1106
1107 #[inline(always)]
1108 fn inline_align(_context: fidl::encoding::Context) -> usize {
1109 8
1110 }
1111
1112 #[inline(always)]
1113 fn inline_size(_context: fidl::encoding::Context) -> usize {
1114 16
1115 }
1116 }
1117
1118 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnnamedCounter, D>
1119 for &UnnamedCounter
1120 {
1121 #[inline]
1122 unsafe fn encode(
1123 self,
1124 encoder: &mut fidl::encoding::Encoder<'_, D>,
1125 offset: usize,
1126 _depth: fidl::encoding::Depth,
1127 ) -> fidl::Result<()> {
1128 encoder.debug_check_bounds::<UnnamedCounter>(offset);
1129 unsafe {
1130 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1132 (buf_ptr as *mut UnnamedCounter)
1133 .write_unaligned((self as *const UnnamedCounter).read());
1134 let padding_ptr = buf_ptr.offset(0) as *mut u64;
1137 let padding_mask = 0xffffffffffff0000u64;
1138 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1139 }
1140 Ok(())
1141 }
1142 }
1143 unsafe impl<
1144 D: fidl::encoding::ResourceDialect,
1145 T0: fidl::encoding::Encode<u16, D>,
1146 T1: fidl::encoding::Encode<u64, D>,
1147 > fidl::encoding::Encode<UnnamedCounter, D> for (T0, T1)
1148 {
1149 #[inline]
1150 unsafe fn encode(
1151 self,
1152 encoder: &mut fidl::encoding::Encoder<'_, D>,
1153 offset: usize,
1154 depth: fidl::encoding::Depth,
1155 ) -> fidl::Result<()> {
1156 encoder.debug_check_bounds::<UnnamedCounter>(offset);
1157 unsafe {
1160 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1161 (ptr as *mut u64).write_unaligned(0);
1162 }
1163 self.0.encode(encoder, offset + 0, depth)?;
1165 self.1.encode(encoder, offset + 8, depth)?;
1166 Ok(())
1167 }
1168 }
1169
1170 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnnamedCounter {
1171 #[inline(always)]
1172 fn new_empty() -> Self {
1173 Self { id: fidl::new_empty!(u16, D), count: fidl::new_empty!(u64, D) }
1174 }
1175
1176 #[inline]
1177 unsafe fn decode(
1178 &mut self,
1179 decoder: &mut fidl::encoding::Decoder<'_, D>,
1180 offset: usize,
1181 _depth: fidl::encoding::Depth,
1182 ) -> fidl::Result<()> {
1183 decoder.debug_check_bounds::<Self>(offset);
1184 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1185 let ptr = unsafe { buf_ptr.offset(0) };
1187 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1188 let mask = 0xffffffffffff0000u64;
1189 let maskedval = padval & mask;
1190 if maskedval != 0 {
1191 return Err(fidl::Error::NonZeroPadding {
1192 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1193 });
1194 }
1195 unsafe {
1197 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1198 }
1199 Ok(())
1200 }
1201 }
1202
1203 impl ConnectionCounters {
1204 #[inline(always)]
1205 fn max_ordinal_present(&self) -> u64 {
1206 if let Some(_) = self.tx_drop {
1207 return 7;
1208 }
1209 if let Some(_) = self.tx_total {
1210 return 6;
1211 }
1212 if let Some(_) = self.rx_multicast {
1213 return 5;
1214 }
1215 if let Some(_) = self.rx_unicast_drop {
1216 return 4;
1217 }
1218 if let Some(_) = self.rx_unicast_total {
1219 return 3;
1220 }
1221 if let Some(_) = self.driver_specific_counters {
1222 return 2;
1223 }
1224 if let Some(_) = self.connection_id {
1225 return 1;
1226 }
1227 0
1228 }
1229 }
1230
1231 impl fidl::encoding::ValueTypeMarker for ConnectionCounters {
1232 type Borrowed<'a> = &'a Self;
1233 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1234 value
1235 }
1236 }
1237
1238 unsafe impl fidl::encoding::TypeMarker for ConnectionCounters {
1239 type Owned = Self;
1240
1241 #[inline(always)]
1242 fn inline_align(_context: fidl::encoding::Context) -> usize {
1243 8
1244 }
1245
1246 #[inline(always)]
1247 fn inline_size(_context: fidl::encoding::Context) -> usize {
1248 16
1249 }
1250 }
1251
1252 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionCounters, D>
1253 for &ConnectionCounters
1254 {
1255 unsafe fn encode(
1256 self,
1257 encoder: &mut fidl::encoding::Encoder<'_, D>,
1258 offset: usize,
1259 mut depth: fidl::encoding::Depth,
1260 ) -> fidl::Result<()> {
1261 encoder.debug_check_bounds::<ConnectionCounters>(offset);
1262 let max_ordinal: u64 = self.max_ordinal_present();
1264 encoder.write_num(max_ordinal, offset);
1265 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1266 if max_ordinal == 0 {
1268 return Ok(());
1269 }
1270 depth.increment()?;
1271 let envelope_size = 8;
1272 let bytes_len = max_ordinal as usize * envelope_size;
1273 #[allow(unused_variables)]
1274 let offset = encoder.out_of_line_offset(bytes_len);
1275 let mut _prev_end_offset: usize = 0;
1276 if 1 > max_ordinal {
1277 return Ok(());
1278 }
1279
1280 let cur_offset: usize = (1 - 1) * envelope_size;
1283
1284 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1286
1287 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1292 self.connection_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1293 encoder,
1294 offset + cur_offset,
1295 depth,
1296 )?;
1297
1298 _prev_end_offset = cur_offset + envelope_size;
1299 if 2 > max_ordinal {
1300 return Ok(());
1301 }
1302
1303 let cur_offset: usize = (2 - 1) * envelope_size;
1306
1307 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1309
1310 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedCounter, 127>, D>(
1315 self.driver_specific_counters.as_ref().map(<fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::ValueTypeMarker>::borrow),
1316 encoder, offset + cur_offset, depth
1317 )?;
1318
1319 _prev_end_offset = cur_offset + envelope_size;
1320 if 3 > max_ordinal {
1321 return Ok(());
1322 }
1323
1324 let cur_offset: usize = (3 - 1) * envelope_size;
1327
1328 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1330
1331 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1336 self.rx_unicast_total
1337 .as_ref()
1338 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1339 encoder,
1340 offset + cur_offset,
1341 depth,
1342 )?;
1343
1344 _prev_end_offset = cur_offset + envelope_size;
1345 if 4 > max_ordinal {
1346 return Ok(());
1347 }
1348
1349 let cur_offset: usize = (4 - 1) * envelope_size;
1352
1353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1355
1356 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1361 self.rx_unicast_drop.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1362 encoder,
1363 offset + cur_offset,
1364 depth,
1365 )?;
1366
1367 _prev_end_offset = cur_offset + envelope_size;
1368 if 5 > max_ordinal {
1369 return Ok(());
1370 }
1371
1372 let cur_offset: usize = (5 - 1) * envelope_size;
1375
1376 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1378
1379 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1384 self.rx_multicast.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1385 encoder,
1386 offset + cur_offset,
1387 depth,
1388 )?;
1389
1390 _prev_end_offset = cur_offset + envelope_size;
1391 if 6 > max_ordinal {
1392 return Ok(());
1393 }
1394
1395 let cur_offset: usize = (6 - 1) * envelope_size;
1398
1399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1401
1402 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1407 self.tx_total.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1408 encoder,
1409 offset + cur_offset,
1410 depth,
1411 )?;
1412
1413 _prev_end_offset = cur_offset + envelope_size;
1414 if 7 > max_ordinal {
1415 return Ok(());
1416 }
1417
1418 let cur_offset: usize = (7 - 1) * envelope_size;
1421
1422 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1424
1425 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1430 self.tx_drop.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1431 encoder,
1432 offset + cur_offset,
1433 depth,
1434 )?;
1435
1436 _prev_end_offset = cur_offset + envelope_size;
1437
1438 Ok(())
1439 }
1440 }
1441
1442 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionCounters {
1443 #[inline(always)]
1444 fn new_empty() -> Self {
1445 Self::default()
1446 }
1447
1448 unsafe fn decode(
1449 &mut self,
1450 decoder: &mut fidl::encoding::Decoder<'_, D>,
1451 offset: usize,
1452 mut depth: fidl::encoding::Depth,
1453 ) -> fidl::Result<()> {
1454 decoder.debug_check_bounds::<Self>(offset);
1455 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1456 None => return Err(fidl::Error::NotNullable),
1457 Some(len) => len,
1458 };
1459 if len == 0 {
1461 return Ok(());
1462 };
1463 depth.increment()?;
1464 let envelope_size = 8;
1465 let bytes_len = len * envelope_size;
1466 let offset = decoder.out_of_line_offset(bytes_len)?;
1467 let mut _next_ordinal_to_read = 0;
1469 let mut next_offset = offset;
1470 let end_offset = offset + bytes_len;
1471 _next_ordinal_to_read += 1;
1472 if next_offset >= end_offset {
1473 return Ok(());
1474 }
1475
1476 while _next_ordinal_to_read < 1 {
1478 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1479 _next_ordinal_to_read += 1;
1480 next_offset += envelope_size;
1481 }
1482
1483 let next_out_of_line = decoder.next_out_of_line();
1484 let handles_before = decoder.remaining_handles();
1485 if let Some((inlined, num_bytes, num_handles)) =
1486 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1487 {
1488 let member_inline_size =
1489 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1490 if inlined != (member_inline_size <= 4) {
1491 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1492 }
1493 let inner_offset;
1494 let mut inner_depth = depth.clone();
1495 if inlined {
1496 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1497 inner_offset = next_offset;
1498 } else {
1499 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1500 inner_depth.increment()?;
1501 }
1502 let val_ref = self.connection_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1503 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1504 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1505 {
1506 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1507 }
1508 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1509 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1510 }
1511 }
1512
1513 next_offset += envelope_size;
1514 _next_ordinal_to_read += 1;
1515 if next_offset >= end_offset {
1516 return Ok(());
1517 }
1518
1519 while _next_ordinal_to_read < 2 {
1521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1522 _next_ordinal_to_read += 1;
1523 next_offset += envelope_size;
1524 }
1525
1526 let next_out_of_line = decoder.next_out_of_line();
1527 let handles_before = decoder.remaining_handles();
1528 if let Some((inlined, num_bytes, num_handles)) =
1529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1530 {
1531 let member_inline_size = <fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1532 if inlined != (member_inline_size <= 4) {
1533 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1534 }
1535 let inner_offset;
1536 let mut inner_depth = depth.clone();
1537 if inlined {
1538 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1539 inner_offset = next_offset;
1540 } else {
1541 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1542 inner_depth.increment()?;
1543 }
1544 let val_ref = self.driver_specific_counters.get_or_insert_with(
1545 || fidl::new_empty!(fidl::encoding::Vector<UnnamedCounter, 127>, D),
1546 );
1547 fidl::decode!(fidl::encoding::Vector<UnnamedCounter, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
1548 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1549 {
1550 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1551 }
1552 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1553 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1554 }
1555 }
1556
1557 next_offset += envelope_size;
1558 _next_ordinal_to_read += 1;
1559 if next_offset >= end_offset {
1560 return Ok(());
1561 }
1562
1563 while _next_ordinal_to_read < 3 {
1565 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1566 _next_ordinal_to_read += 1;
1567 next_offset += envelope_size;
1568 }
1569
1570 let next_out_of_line = decoder.next_out_of_line();
1571 let handles_before = decoder.remaining_handles();
1572 if let Some((inlined, num_bytes, num_handles)) =
1573 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1574 {
1575 let member_inline_size =
1576 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1577 if inlined != (member_inline_size <= 4) {
1578 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1579 }
1580 let inner_offset;
1581 let mut inner_depth = depth.clone();
1582 if inlined {
1583 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1584 inner_offset = next_offset;
1585 } else {
1586 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1587 inner_depth.increment()?;
1588 }
1589 let val_ref = self.rx_unicast_total.get_or_insert_with(|| fidl::new_empty!(u64, D));
1590 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1592 {
1593 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1594 }
1595 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1596 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1597 }
1598 }
1599
1600 next_offset += envelope_size;
1601 _next_ordinal_to_read += 1;
1602 if next_offset >= end_offset {
1603 return Ok(());
1604 }
1605
1606 while _next_ordinal_to_read < 4 {
1608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1609 _next_ordinal_to_read += 1;
1610 next_offset += envelope_size;
1611 }
1612
1613 let next_out_of_line = decoder.next_out_of_line();
1614 let handles_before = decoder.remaining_handles();
1615 if let Some((inlined, num_bytes, num_handles)) =
1616 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1617 {
1618 let member_inline_size =
1619 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1620 if inlined != (member_inline_size <= 4) {
1621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1622 }
1623 let inner_offset;
1624 let mut inner_depth = depth.clone();
1625 if inlined {
1626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1627 inner_offset = next_offset;
1628 } else {
1629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1630 inner_depth.increment()?;
1631 }
1632 let val_ref = self.rx_unicast_drop.get_or_insert_with(|| fidl::new_empty!(u64, D));
1633 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1634 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1635 {
1636 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1637 }
1638 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1639 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1640 }
1641 }
1642
1643 next_offset += envelope_size;
1644 _next_ordinal_to_read += 1;
1645 if next_offset >= end_offset {
1646 return Ok(());
1647 }
1648
1649 while _next_ordinal_to_read < 5 {
1651 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1652 _next_ordinal_to_read += 1;
1653 next_offset += envelope_size;
1654 }
1655
1656 let next_out_of_line = decoder.next_out_of_line();
1657 let handles_before = decoder.remaining_handles();
1658 if let Some((inlined, num_bytes, num_handles)) =
1659 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1660 {
1661 let member_inline_size =
1662 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1663 if inlined != (member_inline_size <= 4) {
1664 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1665 }
1666 let inner_offset;
1667 let mut inner_depth = depth.clone();
1668 if inlined {
1669 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1670 inner_offset = next_offset;
1671 } else {
1672 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1673 inner_depth.increment()?;
1674 }
1675 let val_ref = self.rx_multicast.get_or_insert_with(|| fidl::new_empty!(u64, D));
1676 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1677 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1678 {
1679 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1680 }
1681 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1682 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1683 }
1684 }
1685
1686 next_offset += envelope_size;
1687 _next_ordinal_to_read += 1;
1688 if next_offset >= end_offset {
1689 return Ok(());
1690 }
1691
1692 while _next_ordinal_to_read < 6 {
1694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1695 _next_ordinal_to_read += 1;
1696 next_offset += envelope_size;
1697 }
1698
1699 let next_out_of_line = decoder.next_out_of_line();
1700 let handles_before = decoder.remaining_handles();
1701 if let Some((inlined, num_bytes, num_handles)) =
1702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1703 {
1704 let member_inline_size =
1705 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1706 if inlined != (member_inline_size <= 4) {
1707 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1708 }
1709 let inner_offset;
1710 let mut inner_depth = depth.clone();
1711 if inlined {
1712 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1713 inner_offset = next_offset;
1714 } else {
1715 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1716 inner_depth.increment()?;
1717 }
1718 let val_ref = self.tx_total.get_or_insert_with(|| fidl::new_empty!(u64, D));
1719 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1720 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1721 {
1722 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1723 }
1724 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1725 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1726 }
1727 }
1728
1729 next_offset += envelope_size;
1730 _next_ordinal_to_read += 1;
1731 if next_offset >= end_offset {
1732 return Ok(());
1733 }
1734
1735 while _next_ordinal_to_read < 7 {
1737 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1738 _next_ordinal_to_read += 1;
1739 next_offset += envelope_size;
1740 }
1741
1742 let next_out_of_line = decoder.next_out_of_line();
1743 let handles_before = decoder.remaining_handles();
1744 if let Some((inlined, num_bytes, num_handles)) =
1745 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1746 {
1747 let member_inline_size =
1748 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1749 if inlined != (member_inline_size <= 4) {
1750 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1751 }
1752 let inner_offset;
1753 let mut inner_depth = depth.clone();
1754 if inlined {
1755 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1756 inner_offset = next_offset;
1757 } else {
1758 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1759 inner_depth.increment()?;
1760 }
1761 let val_ref = self.tx_drop.get_or_insert_with(|| fidl::new_empty!(u64, D));
1762 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1764 {
1765 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1766 }
1767 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1768 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1769 }
1770 }
1771
1772 next_offset += envelope_size;
1773
1774 while next_offset < end_offset {
1776 _next_ordinal_to_read += 1;
1777 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1778 next_offset += envelope_size;
1779 }
1780
1781 Ok(())
1782 }
1783 }
1784
1785 impl IfaceCounterStats {
1786 #[inline(always)]
1787 fn max_ordinal_present(&self) -> u64 {
1788 if let Some(_) = self.driver_specific_counters {
1789 return 2;
1790 }
1791 if let Some(_) = self.connection_counters {
1792 return 1;
1793 }
1794 0
1795 }
1796 }
1797
1798 impl fidl::encoding::ValueTypeMarker for IfaceCounterStats {
1799 type Borrowed<'a> = &'a Self;
1800 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1801 value
1802 }
1803 }
1804
1805 unsafe impl fidl::encoding::TypeMarker for IfaceCounterStats {
1806 type Owned = Self;
1807
1808 #[inline(always)]
1809 fn inline_align(_context: fidl::encoding::Context) -> usize {
1810 8
1811 }
1812
1813 #[inline(always)]
1814 fn inline_size(_context: fidl::encoding::Context) -> usize {
1815 16
1816 }
1817 }
1818
1819 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IfaceCounterStats, D>
1820 for &IfaceCounterStats
1821 {
1822 unsafe fn encode(
1823 self,
1824 encoder: &mut fidl::encoding::Encoder<'_, D>,
1825 offset: usize,
1826 mut depth: fidl::encoding::Depth,
1827 ) -> fidl::Result<()> {
1828 encoder.debug_check_bounds::<IfaceCounterStats>(offset);
1829 let max_ordinal: u64 = self.max_ordinal_present();
1831 encoder.write_num(max_ordinal, offset);
1832 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1833 if max_ordinal == 0 {
1835 return Ok(());
1836 }
1837 depth.increment()?;
1838 let envelope_size = 8;
1839 let bytes_len = max_ordinal as usize * envelope_size;
1840 #[allow(unused_variables)]
1841 let offset = encoder.out_of_line_offset(bytes_len);
1842 let mut _prev_end_offset: usize = 0;
1843 if 1 > max_ordinal {
1844 return Ok(());
1845 }
1846
1847 let cur_offset: usize = (1 - 1) * envelope_size;
1850
1851 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1853
1854 fidl::encoding::encode_in_envelope_optional::<ConnectionCounters, D>(
1859 self.connection_counters
1860 .as_ref()
1861 .map(<ConnectionCounters as fidl::encoding::ValueTypeMarker>::borrow),
1862 encoder,
1863 offset + cur_offset,
1864 depth,
1865 )?;
1866
1867 _prev_end_offset = cur_offset + envelope_size;
1868 if 2 > max_ordinal {
1869 return Ok(());
1870 }
1871
1872 let cur_offset: usize = (2 - 1) * envelope_size;
1875
1876 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1878
1879 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedCounter, 127>, D>(
1884 self.driver_specific_counters.as_ref().map(<fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::ValueTypeMarker>::borrow),
1885 encoder, offset + cur_offset, depth
1886 )?;
1887
1888 _prev_end_offset = cur_offset + envelope_size;
1889
1890 Ok(())
1891 }
1892 }
1893
1894 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceCounterStats {
1895 #[inline(always)]
1896 fn new_empty() -> Self {
1897 Self::default()
1898 }
1899
1900 unsafe fn decode(
1901 &mut self,
1902 decoder: &mut fidl::encoding::Decoder<'_, D>,
1903 offset: usize,
1904 mut depth: fidl::encoding::Depth,
1905 ) -> fidl::Result<()> {
1906 decoder.debug_check_bounds::<Self>(offset);
1907 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1908 None => return Err(fidl::Error::NotNullable),
1909 Some(len) => len,
1910 };
1911 if len == 0 {
1913 return Ok(());
1914 };
1915 depth.increment()?;
1916 let envelope_size = 8;
1917 let bytes_len = len * envelope_size;
1918 let offset = decoder.out_of_line_offset(bytes_len)?;
1919 let mut _next_ordinal_to_read = 0;
1921 let mut next_offset = offset;
1922 let end_offset = offset + bytes_len;
1923 _next_ordinal_to_read += 1;
1924 if next_offset >= end_offset {
1925 return Ok(());
1926 }
1927
1928 while _next_ordinal_to_read < 1 {
1930 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1931 _next_ordinal_to_read += 1;
1932 next_offset += envelope_size;
1933 }
1934
1935 let next_out_of_line = decoder.next_out_of_line();
1936 let handles_before = decoder.remaining_handles();
1937 if let Some((inlined, num_bytes, num_handles)) =
1938 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1939 {
1940 let member_inline_size =
1941 <ConnectionCounters as fidl::encoding::TypeMarker>::inline_size(
1942 decoder.context,
1943 );
1944 if inlined != (member_inline_size <= 4) {
1945 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1946 }
1947 let inner_offset;
1948 let mut inner_depth = depth.clone();
1949 if inlined {
1950 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1951 inner_offset = next_offset;
1952 } else {
1953 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1954 inner_depth.increment()?;
1955 }
1956 let val_ref = self
1957 .connection_counters
1958 .get_or_insert_with(|| fidl::new_empty!(ConnectionCounters, D));
1959 fidl::decode!(ConnectionCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
1960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1961 {
1962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1963 }
1964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1966 }
1967 }
1968
1969 next_offset += envelope_size;
1970 _next_ordinal_to_read += 1;
1971 if next_offset >= end_offset {
1972 return Ok(());
1973 }
1974
1975 while _next_ordinal_to_read < 2 {
1977 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1978 _next_ordinal_to_read += 1;
1979 next_offset += envelope_size;
1980 }
1981
1982 let next_out_of_line = decoder.next_out_of_line();
1983 let handles_before = decoder.remaining_handles();
1984 if let Some((inlined, num_bytes, num_handles)) =
1985 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1986 {
1987 let member_inline_size = <fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1988 if inlined != (member_inline_size <= 4) {
1989 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1990 }
1991 let inner_offset;
1992 let mut inner_depth = depth.clone();
1993 if inlined {
1994 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1995 inner_offset = next_offset;
1996 } else {
1997 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1998 inner_depth.increment()?;
1999 }
2000 let val_ref = self.driver_specific_counters.get_or_insert_with(
2001 || fidl::new_empty!(fidl::encoding::Vector<UnnamedCounter, 127>, D),
2002 );
2003 fidl::decode!(fidl::encoding::Vector<UnnamedCounter, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
2004 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2005 {
2006 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2007 }
2008 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2009 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2010 }
2011 }
2012
2013 next_offset += envelope_size;
2014
2015 while next_offset < end_offset {
2017 _next_ordinal_to_read += 1;
2018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2019 next_offset += envelope_size;
2020 }
2021
2022 Ok(())
2023 }
2024 }
2025
2026 impl IfaceHistogramStats {
2027 #[inline(always)]
2028 fn max_ordinal_present(&self) -> u64 {
2029 if let Some(_) = self.snr_histograms {
2030 return 4;
2031 }
2032 if let Some(_) = self.rx_rate_index_histograms {
2033 return 3;
2034 }
2035 if let Some(_) = self.rssi_histograms {
2036 return 2;
2037 }
2038 if let Some(_) = self.noise_floor_histograms {
2039 return 1;
2040 }
2041 0
2042 }
2043 }
2044
2045 impl fidl::encoding::ValueTypeMarker for IfaceHistogramStats {
2046 type Borrowed<'a> = &'a Self;
2047 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2048 value
2049 }
2050 }
2051
2052 unsafe impl fidl::encoding::TypeMarker for IfaceHistogramStats {
2053 type Owned = Self;
2054
2055 #[inline(always)]
2056 fn inline_align(_context: fidl::encoding::Context) -> usize {
2057 8
2058 }
2059
2060 #[inline(always)]
2061 fn inline_size(_context: fidl::encoding::Context) -> usize {
2062 16
2063 }
2064 }
2065
2066 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IfaceHistogramStats, D>
2067 for &IfaceHistogramStats
2068 {
2069 unsafe fn encode(
2070 self,
2071 encoder: &mut fidl::encoding::Encoder<'_, D>,
2072 offset: usize,
2073 mut depth: fidl::encoding::Depth,
2074 ) -> fidl::Result<()> {
2075 encoder.debug_check_bounds::<IfaceHistogramStats>(offset);
2076 let max_ordinal: u64 = self.max_ordinal_present();
2078 encoder.write_num(max_ordinal, offset);
2079 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2080 if max_ordinal == 0 {
2082 return Ok(());
2083 }
2084 depth.increment()?;
2085 let envelope_size = 8;
2086 let bytes_len = max_ordinal as usize * envelope_size;
2087 #[allow(unused_variables)]
2088 let offset = encoder.out_of_line_offset(bytes_len);
2089 let mut _prev_end_offset: usize = 0;
2090 if 1 > max_ordinal {
2091 return Ok(());
2092 }
2093
2094 let cur_offset: usize = (1 - 1) * envelope_size;
2097
2098 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2100
2101 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<NoiseFloorHistogram, 8>, D>(
2106 self.noise_floor_histograms.as_ref().map(<fidl::encoding::Vector<NoiseFloorHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2107 encoder, offset + cur_offset, depth
2108 )?;
2109
2110 _prev_end_offset = cur_offset + envelope_size;
2111 if 2 > max_ordinal {
2112 return Ok(());
2113 }
2114
2115 let cur_offset: usize = (2 - 1) * envelope_size;
2118
2119 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2121
2122 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<RssiHistogram, 8>, D>(
2127 self.rssi_histograms.as_ref().map(<fidl::encoding::Vector<RssiHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2128 encoder, offset + cur_offset, depth
2129 )?;
2130
2131 _prev_end_offset = cur_offset + envelope_size;
2132 if 3 > max_ordinal {
2133 return Ok(());
2134 }
2135
2136 let cur_offset: usize = (3 - 1) * envelope_size;
2139
2140 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2142
2143 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<RxRateIndexHistogram, 8>, D>(
2148 self.rx_rate_index_histograms.as_ref().map(<fidl::encoding::Vector<RxRateIndexHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2149 encoder, offset + cur_offset, depth
2150 )?;
2151
2152 _prev_end_offset = cur_offset + envelope_size;
2153 if 4 > max_ordinal {
2154 return Ok(());
2155 }
2156
2157 let cur_offset: usize = (4 - 1) * envelope_size;
2160
2161 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2163
2164 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SnrHistogram, 8>, D>(
2169 self.snr_histograms.as_ref().map(<fidl::encoding::Vector<SnrHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2170 encoder, offset + cur_offset, depth
2171 )?;
2172
2173 _prev_end_offset = cur_offset + envelope_size;
2174
2175 Ok(())
2176 }
2177 }
2178
2179 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceHistogramStats {
2180 #[inline(always)]
2181 fn new_empty() -> Self {
2182 Self::default()
2183 }
2184
2185 unsafe fn decode(
2186 &mut self,
2187 decoder: &mut fidl::encoding::Decoder<'_, D>,
2188 offset: usize,
2189 mut depth: fidl::encoding::Depth,
2190 ) -> fidl::Result<()> {
2191 decoder.debug_check_bounds::<Self>(offset);
2192 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2193 None => return Err(fidl::Error::NotNullable),
2194 Some(len) => len,
2195 };
2196 if len == 0 {
2198 return Ok(());
2199 };
2200 depth.increment()?;
2201 let envelope_size = 8;
2202 let bytes_len = len * envelope_size;
2203 let offset = decoder.out_of_line_offset(bytes_len)?;
2204 let mut _next_ordinal_to_read = 0;
2206 let mut next_offset = offset;
2207 let end_offset = offset + bytes_len;
2208 _next_ordinal_to_read += 1;
2209 if next_offset >= end_offset {
2210 return Ok(());
2211 }
2212
2213 while _next_ordinal_to_read < 1 {
2215 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2216 _next_ordinal_to_read += 1;
2217 next_offset += envelope_size;
2218 }
2219
2220 let next_out_of_line = decoder.next_out_of_line();
2221 let handles_before = decoder.remaining_handles();
2222 if let Some((inlined, num_bytes, num_handles)) =
2223 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2224 {
2225 let member_inline_size = <fidl::encoding::Vector<NoiseFloorHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2226 if inlined != (member_inline_size <= 4) {
2227 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2228 }
2229 let inner_offset;
2230 let mut inner_depth = depth.clone();
2231 if inlined {
2232 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2233 inner_offset = next_offset;
2234 } else {
2235 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2236 inner_depth.increment()?;
2237 }
2238 let val_ref = self.noise_floor_histograms.get_or_insert_with(
2239 || fidl::new_empty!(fidl::encoding::Vector<NoiseFloorHistogram, 8>, D),
2240 );
2241 fidl::decode!(fidl::encoding::Vector<NoiseFloorHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2242 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2243 {
2244 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2245 }
2246 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2247 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2248 }
2249 }
2250
2251 next_offset += envelope_size;
2252 _next_ordinal_to_read += 1;
2253 if next_offset >= end_offset {
2254 return Ok(());
2255 }
2256
2257 while _next_ordinal_to_read < 2 {
2259 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2260 _next_ordinal_to_read += 1;
2261 next_offset += envelope_size;
2262 }
2263
2264 let next_out_of_line = decoder.next_out_of_line();
2265 let handles_before = decoder.remaining_handles();
2266 if let Some((inlined, num_bytes, num_handles)) =
2267 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2268 {
2269 let member_inline_size = <fidl::encoding::Vector<RssiHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2270 if inlined != (member_inline_size <= 4) {
2271 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2272 }
2273 let inner_offset;
2274 let mut inner_depth = depth.clone();
2275 if inlined {
2276 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2277 inner_offset = next_offset;
2278 } else {
2279 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2280 inner_depth.increment()?;
2281 }
2282 let val_ref = self.rssi_histograms.get_or_insert_with(
2283 || fidl::new_empty!(fidl::encoding::Vector<RssiHistogram, 8>, D),
2284 );
2285 fidl::decode!(fidl::encoding::Vector<RssiHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2286 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2287 {
2288 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2289 }
2290 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2291 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2292 }
2293 }
2294
2295 next_offset += envelope_size;
2296 _next_ordinal_to_read += 1;
2297 if next_offset >= end_offset {
2298 return Ok(());
2299 }
2300
2301 while _next_ordinal_to_read < 3 {
2303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2304 _next_ordinal_to_read += 1;
2305 next_offset += envelope_size;
2306 }
2307
2308 let next_out_of_line = decoder.next_out_of_line();
2309 let handles_before = decoder.remaining_handles();
2310 if let Some((inlined, num_bytes, num_handles)) =
2311 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2312 {
2313 let member_inline_size = <fidl::encoding::Vector<RxRateIndexHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2314 if inlined != (member_inline_size <= 4) {
2315 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2316 }
2317 let inner_offset;
2318 let mut inner_depth = depth.clone();
2319 if inlined {
2320 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2321 inner_offset = next_offset;
2322 } else {
2323 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2324 inner_depth.increment()?;
2325 }
2326 let val_ref = self.rx_rate_index_histograms.get_or_insert_with(
2327 || fidl::new_empty!(fidl::encoding::Vector<RxRateIndexHistogram, 8>, D),
2328 );
2329 fidl::decode!(fidl::encoding::Vector<RxRateIndexHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2330 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2331 {
2332 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2333 }
2334 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2335 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2336 }
2337 }
2338
2339 next_offset += envelope_size;
2340 _next_ordinal_to_read += 1;
2341 if next_offset >= end_offset {
2342 return Ok(());
2343 }
2344
2345 while _next_ordinal_to_read < 4 {
2347 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2348 _next_ordinal_to_read += 1;
2349 next_offset += envelope_size;
2350 }
2351
2352 let next_out_of_line = decoder.next_out_of_line();
2353 let handles_before = decoder.remaining_handles();
2354 if let Some((inlined, num_bytes, num_handles)) =
2355 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2356 {
2357 let member_inline_size = <fidl::encoding::Vector<SnrHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2358 if inlined != (member_inline_size <= 4) {
2359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2360 }
2361 let inner_offset;
2362 let mut inner_depth = depth.clone();
2363 if inlined {
2364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2365 inner_offset = next_offset;
2366 } else {
2367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2368 inner_depth.increment()?;
2369 }
2370 let val_ref = self.snr_histograms.get_or_insert_with(
2371 || fidl::new_empty!(fidl::encoding::Vector<SnrHistogram, 8>, D),
2372 );
2373 fidl::decode!(fidl::encoding::Vector<SnrHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2374 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2375 {
2376 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2377 }
2378 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2379 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2380 }
2381 }
2382
2383 next_offset += envelope_size;
2384
2385 while next_offset < end_offset {
2387 _next_ordinal_to_read += 1;
2388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2389 next_offset += envelope_size;
2390 }
2391
2392 Ok(())
2393 }
2394 }
2395
2396 impl InspectCounterConfig {
2397 #[inline(always)]
2398 fn max_ordinal_present(&self) -> u64 {
2399 if let Some(_) = self.counter_name {
2400 return 2;
2401 }
2402 if let Some(_) = self.counter_id {
2403 return 1;
2404 }
2405 0
2406 }
2407 }
2408
2409 impl fidl::encoding::ValueTypeMarker for InspectCounterConfig {
2410 type Borrowed<'a> = &'a Self;
2411 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2412 value
2413 }
2414 }
2415
2416 unsafe impl fidl::encoding::TypeMarker for InspectCounterConfig {
2417 type Owned = Self;
2418
2419 #[inline(always)]
2420 fn inline_align(_context: fidl::encoding::Context) -> usize {
2421 8
2422 }
2423
2424 #[inline(always)]
2425 fn inline_size(_context: fidl::encoding::Context) -> usize {
2426 16
2427 }
2428 }
2429
2430 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InspectCounterConfig, D>
2431 for &InspectCounterConfig
2432 {
2433 unsafe fn encode(
2434 self,
2435 encoder: &mut fidl::encoding::Encoder<'_, D>,
2436 offset: usize,
2437 mut depth: fidl::encoding::Depth,
2438 ) -> fidl::Result<()> {
2439 encoder.debug_check_bounds::<InspectCounterConfig>(offset);
2440 let max_ordinal: u64 = self.max_ordinal_present();
2442 encoder.write_num(max_ordinal, offset);
2443 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2444 if max_ordinal == 0 {
2446 return Ok(());
2447 }
2448 depth.increment()?;
2449 let envelope_size = 8;
2450 let bytes_len = max_ordinal as usize * envelope_size;
2451 #[allow(unused_variables)]
2452 let offset = encoder.out_of_line_offset(bytes_len);
2453 let mut _prev_end_offset: usize = 0;
2454 if 1 > max_ordinal {
2455 return Ok(());
2456 }
2457
2458 let cur_offset: usize = (1 - 1) * envelope_size;
2461
2462 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2464
2465 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2470 self.counter_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2471 encoder,
2472 offset + cur_offset,
2473 depth,
2474 )?;
2475
2476 _prev_end_offset = cur_offset + envelope_size;
2477 if 2 > max_ordinal {
2478 return Ok(());
2479 }
2480
2481 let cur_offset: usize = (2 - 1) * envelope_size;
2484
2485 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2487
2488 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<127>, D>(
2493 self.counter_name.as_ref().map(
2494 <fidl::encoding::BoundedString<127> as fidl::encoding::ValueTypeMarker>::borrow,
2495 ),
2496 encoder,
2497 offset + cur_offset,
2498 depth,
2499 )?;
2500
2501 _prev_end_offset = cur_offset + envelope_size;
2502
2503 Ok(())
2504 }
2505 }
2506
2507 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InspectCounterConfig {
2508 #[inline(always)]
2509 fn new_empty() -> Self {
2510 Self::default()
2511 }
2512
2513 unsafe fn decode(
2514 &mut self,
2515 decoder: &mut fidl::encoding::Decoder<'_, D>,
2516 offset: usize,
2517 mut depth: fidl::encoding::Depth,
2518 ) -> fidl::Result<()> {
2519 decoder.debug_check_bounds::<Self>(offset);
2520 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2521 None => return Err(fidl::Error::NotNullable),
2522 Some(len) => len,
2523 };
2524 if len == 0 {
2526 return Ok(());
2527 };
2528 depth.increment()?;
2529 let envelope_size = 8;
2530 let bytes_len = len * envelope_size;
2531 let offset = decoder.out_of_line_offset(bytes_len)?;
2532 let mut _next_ordinal_to_read = 0;
2534 let mut next_offset = offset;
2535 let end_offset = offset + bytes_len;
2536 _next_ordinal_to_read += 1;
2537 if next_offset >= end_offset {
2538 return Ok(());
2539 }
2540
2541 while _next_ordinal_to_read < 1 {
2543 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2544 _next_ordinal_to_read += 1;
2545 next_offset += envelope_size;
2546 }
2547
2548 let next_out_of_line = decoder.next_out_of_line();
2549 let handles_before = decoder.remaining_handles();
2550 if let Some((inlined, num_bytes, num_handles)) =
2551 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2552 {
2553 let member_inline_size =
2554 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2555 if inlined != (member_inline_size <= 4) {
2556 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2557 }
2558 let inner_offset;
2559 let mut inner_depth = depth.clone();
2560 if inlined {
2561 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2562 inner_offset = next_offset;
2563 } else {
2564 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2565 inner_depth.increment()?;
2566 }
2567 let val_ref = self.counter_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
2568 fidl::decode!(u16, 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 < 2 {
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 <fidl::encoding::BoundedString<127> as fidl::encoding::TypeMarker>::inline_size(
2598 decoder.context,
2599 );
2600 if inlined != (member_inline_size <= 4) {
2601 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2602 }
2603 let inner_offset;
2604 let mut inner_depth = depth.clone();
2605 if inlined {
2606 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2607 inner_offset = next_offset;
2608 } else {
2609 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2610 inner_depth.increment()?;
2611 }
2612 let val_ref = self
2613 .counter_name
2614 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<127>, D));
2615 fidl::decode!(
2616 fidl::encoding::BoundedString<127>,
2617 D,
2618 val_ref,
2619 decoder,
2620 inner_offset,
2621 inner_depth
2622 )?;
2623 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2624 {
2625 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2626 }
2627 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2628 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2629 }
2630 }
2631
2632 next_offset += envelope_size;
2633
2634 while next_offset < end_offset {
2636 _next_ordinal_to_read += 1;
2637 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2638 next_offset += envelope_size;
2639 }
2640
2641 Ok(())
2642 }
2643 }
2644
2645 impl TelemetrySupport {
2646 #[inline(always)]
2647 fn max_ordinal_present(&self) -> u64 {
2648 if let Some(_) = self.inspect_counter_configs {
2649 return 1;
2650 }
2651 0
2652 }
2653 }
2654
2655 impl fidl::encoding::ValueTypeMarker for TelemetrySupport {
2656 type Borrowed<'a> = &'a Self;
2657 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2658 value
2659 }
2660 }
2661
2662 unsafe impl fidl::encoding::TypeMarker for TelemetrySupport {
2663 type Owned = Self;
2664
2665 #[inline(always)]
2666 fn inline_align(_context: fidl::encoding::Context) -> usize {
2667 8
2668 }
2669
2670 #[inline(always)]
2671 fn inline_size(_context: fidl::encoding::Context) -> usize {
2672 16
2673 }
2674 }
2675
2676 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TelemetrySupport, D>
2677 for &TelemetrySupport
2678 {
2679 unsafe fn encode(
2680 self,
2681 encoder: &mut fidl::encoding::Encoder<'_, D>,
2682 offset: usize,
2683 mut depth: fidl::encoding::Depth,
2684 ) -> fidl::Result<()> {
2685 encoder.debug_check_bounds::<TelemetrySupport>(offset);
2686 let max_ordinal: u64 = self.max_ordinal_present();
2688 encoder.write_num(max_ordinal, offset);
2689 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2690 if max_ordinal == 0 {
2692 return Ok(());
2693 }
2694 depth.increment()?;
2695 let envelope_size = 8;
2696 let bytes_len = max_ordinal as usize * envelope_size;
2697 #[allow(unused_variables)]
2698 let offset = encoder.out_of_line_offset(bytes_len);
2699 let mut _prev_end_offset: usize = 0;
2700 if 1 > max_ordinal {
2701 return Ok(());
2702 }
2703
2704 let cur_offset: usize = (1 - 1) * envelope_size;
2707
2708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2710
2711 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InspectCounterConfig, 127>, D>(
2716 self.inspect_counter_configs.as_ref().map(<fidl::encoding::Vector<InspectCounterConfig, 127> as fidl::encoding::ValueTypeMarker>::borrow),
2717 encoder, offset + cur_offset, depth
2718 )?;
2719
2720 _prev_end_offset = cur_offset + envelope_size;
2721
2722 Ok(())
2723 }
2724 }
2725
2726 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TelemetrySupport {
2727 #[inline(always)]
2728 fn new_empty() -> Self {
2729 Self::default()
2730 }
2731
2732 unsafe fn decode(
2733 &mut self,
2734 decoder: &mut fidl::encoding::Decoder<'_, D>,
2735 offset: usize,
2736 mut depth: fidl::encoding::Depth,
2737 ) -> fidl::Result<()> {
2738 decoder.debug_check_bounds::<Self>(offset);
2739 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2740 None => return Err(fidl::Error::NotNullable),
2741 Some(len) => len,
2742 };
2743 if len == 0 {
2745 return Ok(());
2746 };
2747 depth.increment()?;
2748 let envelope_size = 8;
2749 let bytes_len = len * envelope_size;
2750 let offset = decoder.out_of_line_offset(bytes_len)?;
2751 let mut _next_ordinal_to_read = 0;
2753 let mut next_offset = offset;
2754 let end_offset = offset + bytes_len;
2755 _next_ordinal_to_read += 1;
2756 if next_offset >= end_offset {
2757 return Ok(());
2758 }
2759
2760 while _next_ordinal_to_read < 1 {
2762 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2763 _next_ordinal_to_read += 1;
2764 next_offset += envelope_size;
2765 }
2766
2767 let next_out_of_line = decoder.next_out_of_line();
2768 let handles_before = decoder.remaining_handles();
2769 if let Some((inlined, num_bytes, num_handles)) =
2770 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2771 {
2772 let member_inline_size = <fidl::encoding::Vector<InspectCounterConfig, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2773 if inlined != (member_inline_size <= 4) {
2774 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2775 }
2776 let inner_offset;
2777 let mut inner_depth = depth.clone();
2778 if inlined {
2779 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2780 inner_offset = next_offset;
2781 } else {
2782 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2783 inner_depth.increment()?;
2784 }
2785 let val_ref = self.inspect_counter_configs.get_or_insert_with(
2786 || fidl::new_empty!(fidl::encoding::Vector<InspectCounterConfig, 127>, D),
2787 );
2788 fidl::decode!(fidl::encoding::Vector<InspectCounterConfig, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
2789 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2790 {
2791 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2792 }
2793 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2794 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2795 }
2796 }
2797
2798 next_offset += envelope_size;
2799
2800 while next_offset < end_offset {
2802 _next_ordinal_to_read += 1;
2803 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2804 next_offset += envelope_size;
2805 }
2806
2807 Ok(())
2808 }
2809 }
2810}