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
11pub const GAUGE_STATISTIC_MAX_LENGTH: u8 = 5;
12
13pub const MAX_DRIVER_SPECIFIC_COUNTERS: u32 = 127;
14
15pub const MAX_DRIVER_SPECIFIC_GAUGES: 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
37pub const STAT_NAME_MAX_LENGTH: u8 = 127;
38
39#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
41#[repr(u8)]
42pub enum AntennaFreq {
43 Antenna2G = 1,
45 Antenna5G = 2,
47}
48
49impl AntennaFreq {
50 #[inline]
51 pub fn from_primitive(prim: u8) -> Option<Self> {
52 match prim {
53 1 => Some(Self::Antenna2G),
54 2 => Some(Self::Antenna5G),
55 _ => None,
56 }
57 }
58
59 #[inline]
60 pub const fn into_primitive(self) -> u8 {
61 self as u8
62 }
63}
64
65#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
67pub enum GaugeStatistic {
68 Min,
69 Max,
70 Sum,
71 Last,
72 Mean,
73 #[doc(hidden)]
74 __SourceBreaking {
75 unknown_ordinal: u8,
76 },
77}
78
79#[macro_export]
81macro_rules! GaugeStatisticUnknown {
82 () => {
83 _
84 };
85}
86
87impl GaugeStatistic {
88 #[inline]
89 pub fn from_primitive(prim: u8) -> Option<Self> {
90 match prim {
91 1 => Some(Self::Min),
92 2 => Some(Self::Max),
93 3 => Some(Self::Sum),
94 4 => Some(Self::Last),
95 5 => Some(Self::Mean),
96 _ => None,
97 }
98 }
99
100 #[inline]
101 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
102 match prim {
103 1 => Self::Min,
104 2 => Self::Max,
105 3 => Self::Sum,
106 4 => Self::Last,
107 5 => Self::Mean,
108 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
109 }
110 }
111
112 #[inline]
113 pub fn unknown() -> Self {
114 Self::__SourceBreaking { unknown_ordinal: 0xff }
115 }
116
117 #[inline]
118 pub const fn into_primitive(self) -> u8 {
119 match self {
120 Self::Min => 1,
121 Self::Max => 2,
122 Self::Sum => 3,
123 Self::Last => 4,
124 Self::Mean => 5,
125 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
126 }
127 }
128
129 #[inline]
130 pub fn is_unknown(&self) -> bool {
131 match self {
132 Self::__SourceBreaking { unknown_ordinal: _ } => true,
133 _ => false,
134 }
135 }
136}
137
138#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
141#[repr(u8)]
142pub enum HistScope {
143 Station = 1,
144 PerAntenna = 2,
145}
146
147impl HistScope {
148 #[inline]
149 pub fn from_primitive(prim: u8) -> Option<Self> {
150 match prim {
151 1 => Some(Self::Station),
152 2 => Some(Self::PerAntenna),
153 _ => None,
154 }
155 }
156
157 #[inline]
158 pub const fn into_primitive(self) -> u8 {
159 self as u8
160 }
161}
162
163#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
165pub struct AntennaId {
166 pub freq: AntennaFreq,
167 pub index: u8,
169}
170
171impl fidl::Persistable for AntennaId {}
172
173#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
175#[repr(C)]
176pub struct HistBucket {
177 pub bucket_index: u16,
180 pub num_samples: u64,
182}
183
184impl fidl::Persistable for HistBucket {}
185
186#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
188pub struct NoiseFloorHistogram {
189 pub hist_scope: HistScope,
190 pub antenna_id: Option<Box<AntennaId>>,
192 pub noise_floor_samples: Vec<HistBucket>,
197 pub invalid_samples: u64,
199}
200
201impl fidl::Persistable for NoiseFloorHistogram {}
202
203#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
205pub struct RssiHistogram {
206 pub hist_scope: HistScope,
207 pub antenna_id: Option<Box<AntennaId>>,
209 pub rssi_samples: Vec<HistBucket>,
214 pub invalid_samples: u64,
216}
217
218impl fidl::Persistable for RssiHistogram {}
219
220#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
222pub struct RxRateIndexHistogram {
223 pub hist_scope: HistScope,
224 pub antenna_id: Option<Box<AntennaId>>,
226 pub rx_rate_index_samples: Vec<HistBucket>,
251 pub invalid_samples: u64,
253}
254
255impl fidl::Persistable for RxRateIndexHistogram {}
256
257#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
259pub struct SnrHistogram {
260 pub hist_scope: HistScope,
261 pub antenna_id: Option<Box<AntennaId>>,
263 pub snr_samples: Vec<HistBucket>,
268 pub invalid_samples: u64,
270}
271
272impl fidl::Persistable for SnrHistogram {}
273
274#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
275#[repr(C)]
276pub struct UnnamedCounter {
277 pub id: u16,
278 pub count: u64,
279}
280
281impl fidl::Persistable for UnnamedCounter {}
282
283#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
284#[repr(C)]
285pub struct UnnamedGauge {
286 pub id: u16,
287 pub value: i64,
288}
289
290impl fidl::Persistable for UnnamedGauge {}
291
292#[derive(Clone, Debug, Default, PartialEq)]
293pub struct ConnectionStats {
294 pub connection_id: Option<u8>,
304 pub driver_specific_counters: Option<Vec<UnnamedCounter>>,
305 pub driver_specific_gauges: Option<Vec<UnnamedGauge>>,
306 pub rx_unicast_total: Option<u64>,
307 pub rx_unicast_drop: Option<u64>,
308 pub rx_multicast: Option<u64>,
309 pub tx_total: Option<u64>,
310 pub tx_drop: Option<u64>,
311 #[doc(hidden)]
312 pub __source_breaking: fidl::marker::SourceBreaking,
313}
314
315impl fidl::Persistable for ConnectionStats {}
316
317#[derive(Clone, Debug, Default, PartialEq)]
318pub struct IfaceHistogramStats {
319 pub noise_floor_histograms: Option<Vec<NoiseFloorHistogram>>,
321 pub rssi_histograms: Option<Vec<RssiHistogram>>,
323 pub rx_rate_index_histograms: Option<Vec<RxRateIndexHistogram>>,
325 pub snr_histograms: Option<Vec<SnrHistogram>>,
327 #[doc(hidden)]
328 pub __source_breaking: fidl::marker::SourceBreaking,
329}
330
331impl fidl::Persistable for IfaceHistogramStats {}
332
333#[derive(Clone, Debug, Default, PartialEq)]
334pub struct IfaceStats {
335 pub connection_stats: Option<ConnectionStats>,
337 pub driver_specific_counters: Option<Vec<UnnamedCounter>>,
338 pub driver_specific_gauges: Option<Vec<UnnamedGauge>>,
339 #[doc(hidden)]
340 pub __source_breaking: fidl::marker::SourceBreaking,
341}
342
343impl fidl::Persistable for IfaceStats {}
344
345#[derive(Clone, Debug, Default, PartialEq)]
348pub struct InspectCounterConfig {
349 pub counter_id: Option<u16>,
350 pub counter_name: Option<String>,
351 #[doc(hidden)]
352 pub __source_breaking: fidl::marker::SourceBreaking,
353}
354
355impl fidl::Persistable for InspectCounterConfig {}
356
357#[derive(Clone, Debug, Default, PartialEq)]
360pub struct InspectGaugeConfig {
361 pub gauge_id: Option<u16>,
362 pub gauge_name: Option<String>,
363 pub statistics: Option<Vec<GaugeStatistic>>,
365 #[doc(hidden)]
366 pub __source_breaking: fidl::marker::SourceBreaking,
367}
368
369impl fidl::Persistable for InspectGaugeConfig {}
370
371#[derive(Clone, Debug, Default, PartialEq)]
372pub struct TelemetrySupport {
373 pub inspect_counter_configs: Option<Vec<InspectCounterConfig>>,
375 pub inspect_gauge_configs: Option<Vec<InspectGaugeConfig>>,
377 #[doc(hidden)]
378 pub __source_breaking: fidl::marker::SourceBreaking,
379}
380
381impl fidl::Persistable for TelemetrySupport {}
382
383mod internal {
384 use super::*;
385 unsafe impl fidl::encoding::TypeMarker for AntennaFreq {
386 type Owned = Self;
387
388 #[inline(always)]
389 fn inline_align(_context: fidl::encoding::Context) -> usize {
390 std::mem::align_of::<u8>()
391 }
392
393 #[inline(always)]
394 fn inline_size(_context: fidl::encoding::Context) -> usize {
395 std::mem::size_of::<u8>()
396 }
397
398 #[inline(always)]
399 fn encode_is_copy() -> bool {
400 true
401 }
402
403 #[inline(always)]
404 fn decode_is_copy() -> bool {
405 false
406 }
407 }
408
409 impl fidl::encoding::ValueTypeMarker for AntennaFreq {
410 type Borrowed<'a> = Self;
411 #[inline(always)]
412 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
413 *value
414 }
415 }
416
417 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AntennaFreq {
418 #[inline]
419 unsafe fn encode(
420 self,
421 encoder: &mut fidl::encoding::Encoder<'_, D>,
422 offset: usize,
423 _depth: fidl::encoding::Depth,
424 ) -> fidl::Result<()> {
425 encoder.debug_check_bounds::<Self>(offset);
426 encoder.write_num(self.into_primitive(), offset);
427 Ok(())
428 }
429 }
430
431 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AntennaFreq {
432 #[inline(always)]
433 fn new_empty() -> Self {
434 Self::Antenna2G
435 }
436
437 #[inline]
438 unsafe fn decode(
439 &mut self,
440 decoder: &mut fidl::encoding::Decoder<'_, D>,
441 offset: usize,
442 _depth: fidl::encoding::Depth,
443 ) -> fidl::Result<()> {
444 decoder.debug_check_bounds::<Self>(offset);
445 let prim = decoder.read_num::<u8>(offset);
446
447 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
448 Ok(())
449 }
450 }
451 unsafe impl fidl::encoding::TypeMarker for GaugeStatistic {
452 type Owned = Self;
453
454 #[inline(always)]
455 fn inline_align(_context: fidl::encoding::Context) -> usize {
456 std::mem::align_of::<u8>()
457 }
458
459 #[inline(always)]
460 fn inline_size(_context: fidl::encoding::Context) -> usize {
461 std::mem::size_of::<u8>()
462 }
463
464 #[inline(always)]
465 fn encode_is_copy() -> bool {
466 false
467 }
468
469 #[inline(always)]
470 fn decode_is_copy() -> bool {
471 false
472 }
473 }
474
475 impl fidl::encoding::ValueTypeMarker for GaugeStatistic {
476 type Borrowed<'a> = Self;
477 #[inline(always)]
478 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
479 *value
480 }
481 }
482
483 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GaugeStatistic {
484 #[inline]
485 unsafe fn encode(
486 self,
487 encoder: &mut fidl::encoding::Encoder<'_, D>,
488 offset: usize,
489 _depth: fidl::encoding::Depth,
490 ) -> fidl::Result<()> {
491 encoder.debug_check_bounds::<Self>(offset);
492 encoder.write_num(self.into_primitive(), offset);
493 Ok(())
494 }
495 }
496
497 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GaugeStatistic {
498 #[inline(always)]
499 fn new_empty() -> Self {
500 Self::unknown()
501 }
502
503 #[inline]
504 unsafe fn decode(
505 &mut self,
506 decoder: &mut fidl::encoding::Decoder<'_, D>,
507 offset: usize,
508 _depth: fidl::encoding::Depth,
509 ) -> fidl::Result<()> {
510 decoder.debug_check_bounds::<Self>(offset);
511 let prim = decoder.read_num::<u8>(offset);
512
513 *self = Self::from_primitive_allow_unknown(prim);
514 Ok(())
515 }
516 }
517 unsafe impl fidl::encoding::TypeMarker for HistScope {
518 type Owned = Self;
519
520 #[inline(always)]
521 fn inline_align(_context: fidl::encoding::Context) -> usize {
522 std::mem::align_of::<u8>()
523 }
524
525 #[inline(always)]
526 fn inline_size(_context: fidl::encoding::Context) -> usize {
527 std::mem::size_of::<u8>()
528 }
529
530 #[inline(always)]
531 fn encode_is_copy() -> bool {
532 true
533 }
534
535 #[inline(always)]
536 fn decode_is_copy() -> bool {
537 false
538 }
539 }
540
541 impl fidl::encoding::ValueTypeMarker for HistScope {
542 type Borrowed<'a> = Self;
543 #[inline(always)]
544 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
545 *value
546 }
547 }
548
549 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HistScope {
550 #[inline]
551 unsafe fn encode(
552 self,
553 encoder: &mut fidl::encoding::Encoder<'_, D>,
554 offset: usize,
555 _depth: fidl::encoding::Depth,
556 ) -> fidl::Result<()> {
557 encoder.debug_check_bounds::<Self>(offset);
558 encoder.write_num(self.into_primitive(), offset);
559 Ok(())
560 }
561 }
562
563 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistScope {
564 #[inline(always)]
565 fn new_empty() -> Self {
566 Self::Station
567 }
568
569 #[inline]
570 unsafe fn decode(
571 &mut self,
572 decoder: &mut fidl::encoding::Decoder<'_, D>,
573 offset: usize,
574 _depth: fidl::encoding::Depth,
575 ) -> fidl::Result<()> {
576 decoder.debug_check_bounds::<Self>(offset);
577 let prim = decoder.read_num::<u8>(offset);
578
579 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
580 Ok(())
581 }
582 }
583
584 impl fidl::encoding::ValueTypeMarker for AntennaId {
585 type Borrowed<'a> = &'a Self;
586 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
587 value
588 }
589 }
590
591 unsafe impl fidl::encoding::TypeMarker for AntennaId {
592 type Owned = Self;
593
594 #[inline(always)]
595 fn inline_align(_context: fidl::encoding::Context) -> usize {
596 1
597 }
598
599 #[inline(always)]
600 fn inline_size(_context: fidl::encoding::Context) -> usize {
601 2
602 }
603 }
604
605 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AntennaId, D>
606 for &AntennaId
607 {
608 #[inline]
609 unsafe fn encode(
610 self,
611 encoder: &mut fidl::encoding::Encoder<'_, D>,
612 offset: usize,
613 _depth: fidl::encoding::Depth,
614 ) -> fidl::Result<()> {
615 encoder.debug_check_bounds::<AntennaId>(offset);
616 fidl::encoding::Encode::<AntennaId, D>::encode(
618 (
619 <AntennaFreq as fidl::encoding::ValueTypeMarker>::borrow(&self.freq),
620 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
621 ),
622 encoder,
623 offset,
624 _depth,
625 )
626 }
627 }
628 unsafe impl<
629 D: fidl::encoding::ResourceDialect,
630 T0: fidl::encoding::Encode<AntennaFreq, D>,
631 T1: fidl::encoding::Encode<u8, D>,
632 > fidl::encoding::Encode<AntennaId, D> for (T0, T1)
633 {
634 #[inline]
635 unsafe fn encode(
636 self,
637 encoder: &mut fidl::encoding::Encoder<'_, D>,
638 offset: usize,
639 depth: fidl::encoding::Depth,
640 ) -> fidl::Result<()> {
641 encoder.debug_check_bounds::<AntennaId>(offset);
642 self.0.encode(encoder, offset + 0, depth)?;
646 self.1.encode(encoder, offset + 1, depth)?;
647 Ok(())
648 }
649 }
650
651 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AntennaId {
652 #[inline(always)]
653 fn new_empty() -> Self {
654 Self { freq: fidl::new_empty!(AntennaFreq, D), index: fidl::new_empty!(u8, D) }
655 }
656
657 #[inline]
658 unsafe fn decode(
659 &mut self,
660 decoder: &mut fidl::encoding::Decoder<'_, D>,
661 offset: usize,
662 _depth: fidl::encoding::Depth,
663 ) -> fidl::Result<()> {
664 decoder.debug_check_bounds::<Self>(offset);
665 fidl::decode!(AntennaFreq, D, &mut self.freq, decoder, offset + 0, _depth)?;
667 fidl::decode!(u8, D, &mut self.index, decoder, offset + 1, _depth)?;
668 Ok(())
669 }
670 }
671
672 impl fidl::encoding::ValueTypeMarker for HistBucket {
673 type Borrowed<'a> = &'a Self;
674 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
675 value
676 }
677 }
678
679 unsafe impl fidl::encoding::TypeMarker for HistBucket {
680 type Owned = Self;
681
682 #[inline(always)]
683 fn inline_align(_context: fidl::encoding::Context) -> usize {
684 8
685 }
686
687 #[inline(always)]
688 fn inline_size(_context: fidl::encoding::Context) -> usize {
689 16
690 }
691 }
692
693 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HistBucket, D>
694 for &HistBucket
695 {
696 #[inline]
697 unsafe fn encode(
698 self,
699 encoder: &mut fidl::encoding::Encoder<'_, D>,
700 offset: usize,
701 _depth: fidl::encoding::Depth,
702 ) -> fidl::Result<()> {
703 encoder.debug_check_bounds::<HistBucket>(offset);
704 unsafe {
705 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
707 (buf_ptr as *mut HistBucket).write_unaligned((self as *const HistBucket).read());
708 let padding_ptr = buf_ptr.offset(0) as *mut u64;
711 let padding_mask = 0xffffffffffff0000u64;
712 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
713 }
714 Ok(())
715 }
716 }
717 unsafe impl<
718 D: fidl::encoding::ResourceDialect,
719 T0: fidl::encoding::Encode<u16, D>,
720 T1: fidl::encoding::Encode<u64, D>,
721 > fidl::encoding::Encode<HistBucket, D> for (T0, T1)
722 {
723 #[inline]
724 unsafe fn encode(
725 self,
726 encoder: &mut fidl::encoding::Encoder<'_, D>,
727 offset: usize,
728 depth: fidl::encoding::Depth,
729 ) -> fidl::Result<()> {
730 encoder.debug_check_bounds::<HistBucket>(offset);
731 unsafe {
734 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
735 (ptr as *mut u64).write_unaligned(0);
736 }
737 self.0.encode(encoder, offset + 0, depth)?;
739 self.1.encode(encoder, offset + 8, depth)?;
740 Ok(())
741 }
742 }
743
744 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistBucket {
745 #[inline(always)]
746 fn new_empty() -> Self {
747 Self { bucket_index: fidl::new_empty!(u16, D), num_samples: fidl::new_empty!(u64, D) }
748 }
749
750 #[inline]
751 unsafe fn decode(
752 &mut self,
753 decoder: &mut fidl::encoding::Decoder<'_, D>,
754 offset: usize,
755 _depth: fidl::encoding::Depth,
756 ) -> fidl::Result<()> {
757 decoder.debug_check_bounds::<Self>(offset);
758 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
759 let ptr = unsafe { buf_ptr.offset(0) };
761 let padval = unsafe { (ptr as *const u64).read_unaligned() };
762 let mask = 0xffffffffffff0000u64;
763 let maskedval = padval & mask;
764 if maskedval != 0 {
765 return Err(fidl::Error::NonZeroPadding {
766 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
767 });
768 }
769 unsafe {
771 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
772 }
773 Ok(())
774 }
775 }
776
777 impl fidl::encoding::ValueTypeMarker for NoiseFloorHistogram {
778 type Borrowed<'a> = &'a Self;
779 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
780 value
781 }
782 }
783
784 unsafe impl fidl::encoding::TypeMarker for NoiseFloorHistogram {
785 type Owned = Self;
786
787 #[inline(always)]
788 fn inline_align(_context: fidl::encoding::Context) -> usize {
789 8
790 }
791
792 #[inline(always)]
793 fn inline_size(_context: fidl::encoding::Context) -> usize {
794 40
795 }
796 }
797
798 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NoiseFloorHistogram, D>
799 for &NoiseFloorHistogram
800 {
801 #[inline]
802 unsafe fn encode(
803 self,
804 encoder: &mut fidl::encoding::Encoder<'_, D>,
805 offset: usize,
806 _depth: fidl::encoding::Depth,
807 ) -> fidl::Result<()> {
808 encoder.debug_check_bounds::<NoiseFloorHistogram>(offset);
809 fidl::encoding::Encode::<NoiseFloorHistogram, D>::encode(
811 (
812 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
813 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
814 <fidl::encoding::Vector<HistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.noise_floor_samples),
815 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
816 ),
817 encoder, offset, _depth
818 )
819 }
820 }
821 unsafe impl<
822 D: fidl::encoding::ResourceDialect,
823 T0: fidl::encoding::Encode<HistScope, D>,
824 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
825 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 255>, D>,
826 T3: fidl::encoding::Encode<u64, D>,
827 > fidl::encoding::Encode<NoiseFloorHistogram, D> for (T0, T1, T2, T3)
828 {
829 #[inline]
830 unsafe fn encode(
831 self,
832 encoder: &mut fidl::encoding::Encoder<'_, D>,
833 offset: usize,
834 depth: fidl::encoding::Depth,
835 ) -> fidl::Result<()> {
836 encoder.debug_check_bounds::<NoiseFloorHistogram>(offset);
837 unsafe {
840 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
841 (ptr as *mut u64).write_unaligned(0);
842 }
843 self.0.encode(encoder, offset + 0, depth)?;
845 self.1.encode(encoder, offset + 8, depth)?;
846 self.2.encode(encoder, offset + 16, depth)?;
847 self.3.encode(encoder, offset + 32, depth)?;
848 Ok(())
849 }
850 }
851
852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NoiseFloorHistogram {
853 #[inline(always)]
854 fn new_empty() -> Self {
855 Self {
856 hist_scope: fidl::new_empty!(HistScope, D),
857 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
858 noise_floor_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 255>, D),
859 invalid_samples: fidl::new_empty!(u64, D),
860 }
861 }
862
863 #[inline]
864 unsafe fn decode(
865 &mut self,
866 decoder: &mut fidl::encoding::Decoder<'_, D>,
867 offset: usize,
868 _depth: fidl::encoding::Depth,
869 ) -> fidl::Result<()> {
870 decoder.debug_check_bounds::<Self>(offset);
871 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
873 let padval = unsafe { (ptr as *const u64).read_unaligned() };
874 let mask = 0xffffffffffffff00u64;
875 let maskedval = padval & mask;
876 if maskedval != 0 {
877 return Err(fidl::Error::NonZeroPadding {
878 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
879 });
880 }
881 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
882 fidl::decode!(
883 fidl::encoding::Boxed<AntennaId>,
884 D,
885 &mut self.antenna_id,
886 decoder,
887 offset + 8,
888 _depth
889 )?;
890 fidl::decode!(fidl::encoding::Vector<HistBucket, 255>, D, &mut self.noise_floor_samples, decoder, offset + 16, _depth)?;
891 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
892 Ok(())
893 }
894 }
895
896 impl fidl::encoding::ValueTypeMarker for RssiHistogram {
897 type Borrowed<'a> = &'a Self;
898 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
899 value
900 }
901 }
902
903 unsafe impl fidl::encoding::TypeMarker for RssiHistogram {
904 type Owned = Self;
905
906 #[inline(always)]
907 fn inline_align(_context: fidl::encoding::Context) -> usize {
908 8
909 }
910
911 #[inline(always)]
912 fn inline_size(_context: fidl::encoding::Context) -> usize {
913 40
914 }
915 }
916
917 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RssiHistogram, D>
918 for &RssiHistogram
919 {
920 #[inline]
921 unsafe fn encode(
922 self,
923 encoder: &mut fidl::encoding::Encoder<'_, D>,
924 offset: usize,
925 _depth: fidl::encoding::Depth,
926 ) -> fidl::Result<()> {
927 encoder.debug_check_bounds::<RssiHistogram>(offset);
928 fidl::encoding::Encode::<RssiHistogram, D>::encode(
930 (
931 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
932 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
933 <fidl::encoding::Vector<HistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi_samples),
934 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
935 ),
936 encoder, offset, _depth
937 )
938 }
939 }
940 unsafe impl<
941 D: fidl::encoding::ResourceDialect,
942 T0: fidl::encoding::Encode<HistScope, D>,
943 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
944 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 255>, D>,
945 T3: fidl::encoding::Encode<u64, D>,
946 > fidl::encoding::Encode<RssiHistogram, D> for (T0, T1, T2, T3)
947 {
948 #[inline]
949 unsafe fn encode(
950 self,
951 encoder: &mut fidl::encoding::Encoder<'_, D>,
952 offset: usize,
953 depth: fidl::encoding::Depth,
954 ) -> fidl::Result<()> {
955 encoder.debug_check_bounds::<RssiHistogram>(offset);
956 unsafe {
959 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
960 (ptr as *mut u64).write_unaligned(0);
961 }
962 self.0.encode(encoder, offset + 0, depth)?;
964 self.1.encode(encoder, offset + 8, depth)?;
965 self.2.encode(encoder, offset + 16, depth)?;
966 self.3.encode(encoder, offset + 32, depth)?;
967 Ok(())
968 }
969 }
970
971 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RssiHistogram {
972 #[inline(always)]
973 fn new_empty() -> Self {
974 Self {
975 hist_scope: fidl::new_empty!(HistScope, D),
976 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
977 rssi_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 255>, D),
978 invalid_samples: fidl::new_empty!(u64, D),
979 }
980 }
981
982 #[inline]
983 unsafe fn decode(
984 &mut self,
985 decoder: &mut fidl::encoding::Decoder<'_, D>,
986 offset: usize,
987 _depth: fidl::encoding::Depth,
988 ) -> fidl::Result<()> {
989 decoder.debug_check_bounds::<Self>(offset);
990 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
992 let padval = unsafe { (ptr as *const u64).read_unaligned() };
993 let mask = 0xffffffffffffff00u64;
994 let maskedval = padval & mask;
995 if maskedval != 0 {
996 return Err(fidl::Error::NonZeroPadding {
997 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
998 });
999 }
1000 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
1001 fidl::decode!(
1002 fidl::encoding::Boxed<AntennaId>,
1003 D,
1004 &mut self.antenna_id,
1005 decoder,
1006 offset + 8,
1007 _depth
1008 )?;
1009 fidl::decode!(fidl::encoding::Vector<HistBucket, 255>, D, &mut self.rssi_samples, decoder, offset + 16, _depth)?;
1010 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
1011 Ok(())
1012 }
1013 }
1014
1015 impl fidl::encoding::ValueTypeMarker for RxRateIndexHistogram {
1016 type Borrowed<'a> = &'a Self;
1017 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1018 value
1019 }
1020 }
1021
1022 unsafe impl fidl::encoding::TypeMarker for RxRateIndexHistogram {
1023 type Owned = Self;
1024
1025 #[inline(always)]
1026 fn inline_align(_context: fidl::encoding::Context) -> usize {
1027 8
1028 }
1029
1030 #[inline(always)]
1031 fn inline_size(_context: fidl::encoding::Context) -> usize {
1032 40
1033 }
1034 }
1035
1036 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RxRateIndexHistogram, D>
1037 for &RxRateIndexHistogram
1038 {
1039 #[inline]
1040 unsafe fn encode(
1041 self,
1042 encoder: &mut fidl::encoding::Encoder<'_, D>,
1043 offset: usize,
1044 _depth: fidl::encoding::Depth,
1045 ) -> fidl::Result<()> {
1046 encoder.debug_check_bounds::<RxRateIndexHistogram>(offset);
1047 fidl::encoding::Encode::<RxRateIndexHistogram, D>::encode(
1049 (
1050 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
1051 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
1052 <fidl::encoding::Vector<HistBucket, 196> as fidl::encoding::ValueTypeMarker>::borrow(&self.rx_rate_index_samples),
1053 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
1054 ),
1055 encoder, offset, _depth
1056 )
1057 }
1058 }
1059 unsafe impl<
1060 D: fidl::encoding::ResourceDialect,
1061 T0: fidl::encoding::Encode<HistScope, D>,
1062 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
1063 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 196>, D>,
1064 T3: fidl::encoding::Encode<u64, D>,
1065 > fidl::encoding::Encode<RxRateIndexHistogram, D> for (T0, T1, T2, T3)
1066 {
1067 #[inline]
1068 unsafe fn encode(
1069 self,
1070 encoder: &mut fidl::encoding::Encoder<'_, D>,
1071 offset: usize,
1072 depth: fidl::encoding::Depth,
1073 ) -> fidl::Result<()> {
1074 encoder.debug_check_bounds::<RxRateIndexHistogram>(offset);
1075 unsafe {
1078 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1079 (ptr as *mut u64).write_unaligned(0);
1080 }
1081 self.0.encode(encoder, offset + 0, depth)?;
1083 self.1.encode(encoder, offset + 8, depth)?;
1084 self.2.encode(encoder, offset + 16, depth)?;
1085 self.3.encode(encoder, offset + 32, depth)?;
1086 Ok(())
1087 }
1088 }
1089
1090 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RxRateIndexHistogram {
1091 #[inline(always)]
1092 fn new_empty() -> Self {
1093 Self {
1094 hist_scope: fidl::new_empty!(HistScope, D),
1095 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
1096 rx_rate_index_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 196>, D),
1097 invalid_samples: fidl::new_empty!(u64, D),
1098 }
1099 }
1100
1101 #[inline]
1102 unsafe fn decode(
1103 &mut self,
1104 decoder: &mut fidl::encoding::Decoder<'_, D>,
1105 offset: usize,
1106 _depth: fidl::encoding::Depth,
1107 ) -> fidl::Result<()> {
1108 decoder.debug_check_bounds::<Self>(offset);
1109 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1111 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1112 let mask = 0xffffffffffffff00u64;
1113 let maskedval = padval & mask;
1114 if maskedval != 0 {
1115 return Err(fidl::Error::NonZeroPadding {
1116 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1117 });
1118 }
1119 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
1120 fidl::decode!(
1121 fidl::encoding::Boxed<AntennaId>,
1122 D,
1123 &mut self.antenna_id,
1124 decoder,
1125 offset + 8,
1126 _depth
1127 )?;
1128 fidl::decode!(fidl::encoding::Vector<HistBucket, 196>, D, &mut self.rx_rate_index_samples, decoder, offset + 16, _depth)?;
1129 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
1130 Ok(())
1131 }
1132 }
1133
1134 impl fidl::encoding::ValueTypeMarker for SnrHistogram {
1135 type Borrowed<'a> = &'a Self;
1136 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1137 value
1138 }
1139 }
1140
1141 unsafe impl fidl::encoding::TypeMarker for SnrHistogram {
1142 type Owned = Self;
1143
1144 #[inline(always)]
1145 fn inline_align(_context: fidl::encoding::Context) -> usize {
1146 8
1147 }
1148
1149 #[inline(always)]
1150 fn inline_size(_context: fidl::encoding::Context) -> usize {
1151 40
1152 }
1153 }
1154
1155 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SnrHistogram, D>
1156 for &SnrHistogram
1157 {
1158 #[inline]
1159 unsafe fn encode(
1160 self,
1161 encoder: &mut fidl::encoding::Encoder<'_, D>,
1162 offset: usize,
1163 _depth: fidl::encoding::Depth,
1164 ) -> fidl::Result<()> {
1165 encoder.debug_check_bounds::<SnrHistogram>(offset);
1166 fidl::encoding::Encode::<SnrHistogram, D>::encode(
1168 (
1169 <HistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
1170 <fidl::encoding::Boxed<AntennaId> as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
1171 <fidl::encoding::Vector<HistBucket, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.snr_samples),
1172 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
1173 ),
1174 encoder, offset, _depth
1175 )
1176 }
1177 }
1178 unsafe impl<
1179 D: fidl::encoding::ResourceDialect,
1180 T0: fidl::encoding::Encode<HistScope, D>,
1181 T1: fidl::encoding::Encode<fidl::encoding::Boxed<AntennaId>, D>,
1182 T2: fidl::encoding::Encode<fidl::encoding::Vector<HistBucket, 256>, D>,
1183 T3: fidl::encoding::Encode<u64, D>,
1184 > fidl::encoding::Encode<SnrHistogram, D> for (T0, T1, T2, T3)
1185 {
1186 #[inline]
1187 unsafe fn encode(
1188 self,
1189 encoder: &mut fidl::encoding::Encoder<'_, D>,
1190 offset: usize,
1191 depth: fidl::encoding::Depth,
1192 ) -> fidl::Result<()> {
1193 encoder.debug_check_bounds::<SnrHistogram>(offset);
1194 unsafe {
1197 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1198 (ptr as *mut u64).write_unaligned(0);
1199 }
1200 self.0.encode(encoder, offset + 0, depth)?;
1202 self.1.encode(encoder, offset + 8, depth)?;
1203 self.2.encode(encoder, offset + 16, depth)?;
1204 self.3.encode(encoder, offset + 32, depth)?;
1205 Ok(())
1206 }
1207 }
1208
1209 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SnrHistogram {
1210 #[inline(always)]
1211 fn new_empty() -> Self {
1212 Self {
1213 hist_scope: fidl::new_empty!(HistScope, D),
1214 antenna_id: fidl::new_empty!(fidl::encoding::Boxed<AntennaId>, D),
1215 snr_samples: fidl::new_empty!(fidl::encoding::Vector<HistBucket, 256>, D),
1216 invalid_samples: fidl::new_empty!(u64, D),
1217 }
1218 }
1219
1220 #[inline]
1221 unsafe fn decode(
1222 &mut self,
1223 decoder: &mut fidl::encoding::Decoder<'_, D>,
1224 offset: usize,
1225 _depth: fidl::encoding::Depth,
1226 ) -> fidl::Result<()> {
1227 decoder.debug_check_bounds::<Self>(offset);
1228 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1230 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1231 let mask = 0xffffffffffffff00u64;
1232 let maskedval = padval & mask;
1233 if maskedval != 0 {
1234 return Err(fidl::Error::NonZeroPadding {
1235 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1236 });
1237 }
1238 fidl::decode!(HistScope, D, &mut self.hist_scope, decoder, offset + 0, _depth)?;
1239 fidl::decode!(
1240 fidl::encoding::Boxed<AntennaId>,
1241 D,
1242 &mut self.antenna_id,
1243 decoder,
1244 offset + 8,
1245 _depth
1246 )?;
1247 fidl::decode!(fidl::encoding::Vector<HistBucket, 256>, D, &mut self.snr_samples, decoder, offset + 16, _depth)?;
1248 fidl::decode!(u64, D, &mut self.invalid_samples, decoder, offset + 32, _depth)?;
1249 Ok(())
1250 }
1251 }
1252
1253 impl fidl::encoding::ValueTypeMarker for UnnamedCounter {
1254 type Borrowed<'a> = &'a Self;
1255 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1256 value
1257 }
1258 }
1259
1260 unsafe impl fidl::encoding::TypeMarker for UnnamedCounter {
1261 type Owned = Self;
1262
1263 #[inline(always)]
1264 fn inline_align(_context: fidl::encoding::Context) -> usize {
1265 8
1266 }
1267
1268 #[inline(always)]
1269 fn inline_size(_context: fidl::encoding::Context) -> usize {
1270 16
1271 }
1272 }
1273
1274 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnnamedCounter, D>
1275 for &UnnamedCounter
1276 {
1277 #[inline]
1278 unsafe fn encode(
1279 self,
1280 encoder: &mut fidl::encoding::Encoder<'_, D>,
1281 offset: usize,
1282 _depth: fidl::encoding::Depth,
1283 ) -> fidl::Result<()> {
1284 encoder.debug_check_bounds::<UnnamedCounter>(offset);
1285 unsafe {
1286 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1288 (buf_ptr as *mut UnnamedCounter)
1289 .write_unaligned((self as *const UnnamedCounter).read());
1290 let padding_ptr = buf_ptr.offset(0) as *mut u64;
1293 let padding_mask = 0xffffffffffff0000u64;
1294 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1295 }
1296 Ok(())
1297 }
1298 }
1299 unsafe impl<
1300 D: fidl::encoding::ResourceDialect,
1301 T0: fidl::encoding::Encode<u16, D>,
1302 T1: fidl::encoding::Encode<u64, D>,
1303 > fidl::encoding::Encode<UnnamedCounter, D> for (T0, T1)
1304 {
1305 #[inline]
1306 unsafe fn encode(
1307 self,
1308 encoder: &mut fidl::encoding::Encoder<'_, D>,
1309 offset: usize,
1310 depth: fidl::encoding::Depth,
1311 ) -> fidl::Result<()> {
1312 encoder.debug_check_bounds::<UnnamedCounter>(offset);
1313 unsafe {
1316 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1317 (ptr as *mut u64).write_unaligned(0);
1318 }
1319 self.0.encode(encoder, offset + 0, depth)?;
1321 self.1.encode(encoder, offset + 8, depth)?;
1322 Ok(())
1323 }
1324 }
1325
1326 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnnamedCounter {
1327 #[inline(always)]
1328 fn new_empty() -> Self {
1329 Self { id: fidl::new_empty!(u16, D), count: fidl::new_empty!(u64, D) }
1330 }
1331
1332 #[inline]
1333 unsafe fn decode(
1334 &mut self,
1335 decoder: &mut fidl::encoding::Decoder<'_, D>,
1336 offset: usize,
1337 _depth: fidl::encoding::Depth,
1338 ) -> fidl::Result<()> {
1339 decoder.debug_check_bounds::<Self>(offset);
1340 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1341 let ptr = unsafe { buf_ptr.offset(0) };
1343 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1344 let mask = 0xffffffffffff0000u64;
1345 let maskedval = padval & mask;
1346 if maskedval != 0 {
1347 return Err(fidl::Error::NonZeroPadding {
1348 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1349 });
1350 }
1351 unsafe {
1353 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1354 }
1355 Ok(())
1356 }
1357 }
1358
1359 impl fidl::encoding::ValueTypeMarker for UnnamedGauge {
1360 type Borrowed<'a> = &'a Self;
1361 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1362 value
1363 }
1364 }
1365
1366 unsafe impl fidl::encoding::TypeMarker for UnnamedGauge {
1367 type Owned = Self;
1368
1369 #[inline(always)]
1370 fn inline_align(_context: fidl::encoding::Context) -> usize {
1371 8
1372 }
1373
1374 #[inline(always)]
1375 fn inline_size(_context: fidl::encoding::Context) -> usize {
1376 16
1377 }
1378 }
1379
1380 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnnamedGauge, D>
1381 for &UnnamedGauge
1382 {
1383 #[inline]
1384 unsafe fn encode(
1385 self,
1386 encoder: &mut fidl::encoding::Encoder<'_, D>,
1387 offset: usize,
1388 _depth: fidl::encoding::Depth,
1389 ) -> fidl::Result<()> {
1390 encoder.debug_check_bounds::<UnnamedGauge>(offset);
1391 unsafe {
1392 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1394 (buf_ptr as *mut UnnamedGauge)
1395 .write_unaligned((self as *const UnnamedGauge).read());
1396 let padding_ptr = buf_ptr.offset(0) as *mut u64;
1399 let padding_mask = 0xffffffffffff0000u64;
1400 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1401 }
1402 Ok(())
1403 }
1404 }
1405 unsafe impl<
1406 D: fidl::encoding::ResourceDialect,
1407 T0: fidl::encoding::Encode<u16, D>,
1408 T1: fidl::encoding::Encode<i64, D>,
1409 > fidl::encoding::Encode<UnnamedGauge, D> for (T0, T1)
1410 {
1411 #[inline]
1412 unsafe fn encode(
1413 self,
1414 encoder: &mut fidl::encoding::Encoder<'_, D>,
1415 offset: usize,
1416 depth: fidl::encoding::Depth,
1417 ) -> fidl::Result<()> {
1418 encoder.debug_check_bounds::<UnnamedGauge>(offset);
1419 unsafe {
1422 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1423 (ptr as *mut u64).write_unaligned(0);
1424 }
1425 self.0.encode(encoder, offset + 0, depth)?;
1427 self.1.encode(encoder, offset + 8, depth)?;
1428 Ok(())
1429 }
1430 }
1431
1432 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnnamedGauge {
1433 #[inline(always)]
1434 fn new_empty() -> Self {
1435 Self { id: fidl::new_empty!(u16, D), value: fidl::new_empty!(i64, D) }
1436 }
1437
1438 #[inline]
1439 unsafe fn decode(
1440 &mut self,
1441 decoder: &mut fidl::encoding::Decoder<'_, D>,
1442 offset: usize,
1443 _depth: fidl::encoding::Depth,
1444 ) -> fidl::Result<()> {
1445 decoder.debug_check_bounds::<Self>(offset);
1446 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1447 let ptr = unsafe { buf_ptr.offset(0) };
1449 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1450 let mask = 0xffffffffffff0000u64;
1451 let maskedval = padval & mask;
1452 if maskedval != 0 {
1453 return Err(fidl::Error::NonZeroPadding {
1454 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1455 });
1456 }
1457 unsafe {
1459 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1460 }
1461 Ok(())
1462 }
1463 }
1464
1465 impl ConnectionStats {
1466 #[inline(always)]
1467 fn max_ordinal_present(&self) -> u64 {
1468 if let Some(_) = self.tx_drop {
1469 return 8;
1470 }
1471 if let Some(_) = self.tx_total {
1472 return 7;
1473 }
1474 if let Some(_) = self.rx_multicast {
1475 return 6;
1476 }
1477 if let Some(_) = self.rx_unicast_drop {
1478 return 5;
1479 }
1480 if let Some(_) = self.rx_unicast_total {
1481 return 4;
1482 }
1483 if let Some(_) = self.driver_specific_gauges {
1484 return 3;
1485 }
1486 if let Some(_) = self.driver_specific_counters {
1487 return 2;
1488 }
1489 if let Some(_) = self.connection_id {
1490 return 1;
1491 }
1492 0
1493 }
1494 }
1495
1496 impl fidl::encoding::ValueTypeMarker for ConnectionStats {
1497 type Borrowed<'a> = &'a Self;
1498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1499 value
1500 }
1501 }
1502
1503 unsafe impl fidl::encoding::TypeMarker for ConnectionStats {
1504 type Owned = Self;
1505
1506 #[inline(always)]
1507 fn inline_align(_context: fidl::encoding::Context) -> usize {
1508 8
1509 }
1510
1511 #[inline(always)]
1512 fn inline_size(_context: fidl::encoding::Context) -> usize {
1513 16
1514 }
1515 }
1516
1517 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionStats, D>
1518 for &ConnectionStats
1519 {
1520 unsafe fn encode(
1521 self,
1522 encoder: &mut fidl::encoding::Encoder<'_, D>,
1523 offset: usize,
1524 mut depth: fidl::encoding::Depth,
1525 ) -> fidl::Result<()> {
1526 encoder.debug_check_bounds::<ConnectionStats>(offset);
1527 let max_ordinal: u64 = self.max_ordinal_present();
1529 encoder.write_num(max_ordinal, offset);
1530 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1531 if max_ordinal == 0 {
1533 return Ok(());
1534 }
1535 depth.increment()?;
1536 let envelope_size = 8;
1537 let bytes_len = max_ordinal as usize * envelope_size;
1538 #[allow(unused_variables)]
1539 let offset = encoder.out_of_line_offset(bytes_len);
1540 let mut _prev_end_offset: usize = 0;
1541 if 1 > max_ordinal {
1542 return Ok(());
1543 }
1544
1545 let cur_offset: usize = (1 - 1) * envelope_size;
1548
1549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1551
1552 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1557 self.connection_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1558 encoder,
1559 offset + cur_offset,
1560 depth,
1561 )?;
1562
1563 _prev_end_offset = cur_offset + envelope_size;
1564 if 2 > max_ordinal {
1565 return Ok(());
1566 }
1567
1568 let cur_offset: usize = (2 - 1) * envelope_size;
1571
1572 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1574
1575 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedCounter, 127>, D>(
1580 self.driver_specific_counters.as_ref().map(<fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::ValueTypeMarker>::borrow),
1581 encoder, offset + cur_offset, depth
1582 )?;
1583
1584 _prev_end_offset = cur_offset + envelope_size;
1585 if 3 > max_ordinal {
1586 return Ok(());
1587 }
1588
1589 let cur_offset: usize = (3 - 1) * envelope_size;
1592
1593 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1595
1596 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedGauge, 127>, D>(
1601 self.driver_specific_gauges.as_ref().map(<fidl::encoding::Vector<UnnamedGauge, 127> as fidl::encoding::ValueTypeMarker>::borrow),
1602 encoder, offset + cur_offset, depth
1603 )?;
1604
1605 _prev_end_offset = cur_offset + envelope_size;
1606 if 4 > max_ordinal {
1607 return Ok(());
1608 }
1609
1610 let cur_offset: usize = (4 - 1) * envelope_size;
1613
1614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1616
1617 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1622 self.rx_unicast_total
1623 .as_ref()
1624 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1625 encoder,
1626 offset + cur_offset,
1627 depth,
1628 )?;
1629
1630 _prev_end_offset = cur_offset + envelope_size;
1631 if 5 > max_ordinal {
1632 return Ok(());
1633 }
1634
1635 let cur_offset: usize = (5 - 1) * envelope_size;
1638
1639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1641
1642 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1647 self.rx_unicast_drop.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1648 encoder,
1649 offset + cur_offset,
1650 depth,
1651 )?;
1652
1653 _prev_end_offset = cur_offset + envelope_size;
1654 if 6 > max_ordinal {
1655 return Ok(());
1656 }
1657
1658 let cur_offset: usize = (6 - 1) * envelope_size;
1661
1662 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1664
1665 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1670 self.rx_multicast.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1671 encoder,
1672 offset + cur_offset,
1673 depth,
1674 )?;
1675
1676 _prev_end_offset = cur_offset + envelope_size;
1677 if 7 > max_ordinal {
1678 return Ok(());
1679 }
1680
1681 let cur_offset: usize = (7 - 1) * envelope_size;
1684
1685 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1687
1688 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1693 self.tx_total.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1694 encoder,
1695 offset + cur_offset,
1696 depth,
1697 )?;
1698
1699 _prev_end_offset = cur_offset + envelope_size;
1700 if 8 > max_ordinal {
1701 return Ok(());
1702 }
1703
1704 let cur_offset: usize = (8 - 1) * envelope_size;
1707
1708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1710
1711 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1716 self.tx_drop.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1717 encoder,
1718 offset + cur_offset,
1719 depth,
1720 )?;
1721
1722 _prev_end_offset = cur_offset + envelope_size;
1723
1724 Ok(())
1725 }
1726 }
1727
1728 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionStats {
1729 #[inline(always)]
1730 fn new_empty() -> Self {
1731 Self::default()
1732 }
1733
1734 unsafe fn decode(
1735 &mut self,
1736 decoder: &mut fidl::encoding::Decoder<'_, D>,
1737 offset: usize,
1738 mut depth: fidl::encoding::Depth,
1739 ) -> fidl::Result<()> {
1740 decoder.debug_check_bounds::<Self>(offset);
1741 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1742 None => return Err(fidl::Error::NotNullable),
1743 Some(len) => len,
1744 };
1745 if len == 0 {
1747 return Ok(());
1748 };
1749 depth.increment()?;
1750 let envelope_size = 8;
1751 let bytes_len = len * envelope_size;
1752 let offset = decoder.out_of_line_offset(bytes_len)?;
1753 let mut _next_ordinal_to_read = 0;
1755 let mut next_offset = offset;
1756 let end_offset = offset + bytes_len;
1757 _next_ordinal_to_read += 1;
1758 if next_offset >= end_offset {
1759 return Ok(());
1760 }
1761
1762 while _next_ordinal_to_read < 1 {
1764 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1765 _next_ordinal_to_read += 1;
1766 next_offset += envelope_size;
1767 }
1768
1769 let next_out_of_line = decoder.next_out_of_line();
1770 let handles_before = decoder.remaining_handles();
1771 if let Some((inlined, num_bytes, num_handles)) =
1772 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1773 {
1774 let member_inline_size =
1775 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1776 if inlined != (member_inline_size <= 4) {
1777 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1778 }
1779 let inner_offset;
1780 let mut inner_depth = depth.clone();
1781 if inlined {
1782 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1783 inner_offset = next_offset;
1784 } else {
1785 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1786 inner_depth.increment()?;
1787 }
1788 let val_ref = self.connection_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1789 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1791 {
1792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1793 }
1794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1796 }
1797 }
1798
1799 next_offset += envelope_size;
1800 _next_ordinal_to_read += 1;
1801 if next_offset >= end_offset {
1802 return Ok(());
1803 }
1804
1805 while _next_ordinal_to_read < 2 {
1807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1808 _next_ordinal_to_read += 1;
1809 next_offset += envelope_size;
1810 }
1811
1812 let next_out_of_line = decoder.next_out_of_line();
1813 let handles_before = decoder.remaining_handles();
1814 if let Some((inlined, num_bytes, num_handles)) =
1815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1816 {
1817 let member_inline_size = <fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1818 if inlined != (member_inline_size <= 4) {
1819 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1820 }
1821 let inner_offset;
1822 let mut inner_depth = depth.clone();
1823 if inlined {
1824 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1825 inner_offset = next_offset;
1826 } else {
1827 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1828 inner_depth.increment()?;
1829 }
1830 let val_ref = self.driver_specific_counters.get_or_insert_with(
1831 || fidl::new_empty!(fidl::encoding::Vector<UnnamedCounter, 127>, D),
1832 );
1833 fidl::decode!(fidl::encoding::Vector<UnnamedCounter, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
1834 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1835 {
1836 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1837 }
1838 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1839 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1840 }
1841 }
1842
1843 next_offset += envelope_size;
1844 _next_ordinal_to_read += 1;
1845 if next_offset >= end_offset {
1846 return Ok(());
1847 }
1848
1849 while _next_ordinal_to_read < 3 {
1851 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1852 _next_ordinal_to_read += 1;
1853 next_offset += envelope_size;
1854 }
1855
1856 let next_out_of_line = decoder.next_out_of_line();
1857 let handles_before = decoder.remaining_handles();
1858 if let Some((inlined, num_bytes, num_handles)) =
1859 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1860 {
1861 let member_inline_size = <fidl::encoding::Vector<UnnamedGauge, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1862 if inlined != (member_inline_size <= 4) {
1863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1864 }
1865 let inner_offset;
1866 let mut inner_depth = depth.clone();
1867 if inlined {
1868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1869 inner_offset = next_offset;
1870 } else {
1871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1872 inner_depth.increment()?;
1873 }
1874 let val_ref = self.driver_specific_gauges.get_or_insert_with(
1875 || fidl::new_empty!(fidl::encoding::Vector<UnnamedGauge, 127>, D),
1876 );
1877 fidl::decode!(fidl::encoding::Vector<UnnamedGauge, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
1878 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1879 {
1880 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1881 }
1882 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1883 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1884 }
1885 }
1886
1887 next_offset += envelope_size;
1888 _next_ordinal_to_read += 1;
1889 if next_offset >= end_offset {
1890 return Ok(());
1891 }
1892
1893 while _next_ordinal_to_read < 4 {
1895 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1896 _next_ordinal_to_read += 1;
1897 next_offset += envelope_size;
1898 }
1899
1900 let next_out_of_line = decoder.next_out_of_line();
1901 let handles_before = decoder.remaining_handles();
1902 if let Some((inlined, num_bytes, num_handles)) =
1903 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1904 {
1905 let member_inline_size =
1906 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1907 if inlined != (member_inline_size <= 4) {
1908 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1909 }
1910 let inner_offset;
1911 let mut inner_depth = depth.clone();
1912 if inlined {
1913 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1914 inner_offset = next_offset;
1915 } else {
1916 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1917 inner_depth.increment()?;
1918 }
1919 let val_ref = self.rx_unicast_total.get_or_insert_with(|| fidl::new_empty!(u64, D));
1920 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1921 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1922 {
1923 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1924 }
1925 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1926 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1927 }
1928 }
1929
1930 next_offset += envelope_size;
1931 _next_ordinal_to_read += 1;
1932 if next_offset >= end_offset {
1933 return Ok(());
1934 }
1935
1936 while _next_ordinal_to_read < 5 {
1938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1939 _next_ordinal_to_read += 1;
1940 next_offset += envelope_size;
1941 }
1942
1943 let next_out_of_line = decoder.next_out_of_line();
1944 let handles_before = decoder.remaining_handles();
1945 if let Some((inlined, num_bytes, num_handles)) =
1946 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1947 {
1948 let member_inline_size =
1949 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1950 if inlined != (member_inline_size <= 4) {
1951 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1952 }
1953 let inner_offset;
1954 let mut inner_depth = depth.clone();
1955 if inlined {
1956 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1957 inner_offset = next_offset;
1958 } else {
1959 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1960 inner_depth.increment()?;
1961 }
1962 let val_ref = self.rx_unicast_drop.get_or_insert_with(|| fidl::new_empty!(u64, D));
1963 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1964 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1965 {
1966 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1967 }
1968 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1969 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1970 }
1971 }
1972
1973 next_offset += envelope_size;
1974 _next_ordinal_to_read += 1;
1975 if next_offset >= end_offset {
1976 return Ok(());
1977 }
1978
1979 while _next_ordinal_to_read < 6 {
1981 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1982 _next_ordinal_to_read += 1;
1983 next_offset += envelope_size;
1984 }
1985
1986 let next_out_of_line = decoder.next_out_of_line();
1987 let handles_before = decoder.remaining_handles();
1988 if let Some((inlined, num_bytes, num_handles)) =
1989 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1990 {
1991 let member_inline_size =
1992 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1993 if inlined != (member_inline_size <= 4) {
1994 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1995 }
1996 let inner_offset;
1997 let mut inner_depth = depth.clone();
1998 if inlined {
1999 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2000 inner_offset = next_offset;
2001 } else {
2002 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2003 inner_depth.increment()?;
2004 }
2005 let val_ref = self.rx_multicast.get_or_insert_with(|| fidl::new_empty!(u64, D));
2006 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2007 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2008 {
2009 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2010 }
2011 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2012 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2013 }
2014 }
2015
2016 next_offset += envelope_size;
2017 _next_ordinal_to_read += 1;
2018 if next_offset >= end_offset {
2019 return Ok(());
2020 }
2021
2022 while _next_ordinal_to_read < 7 {
2024 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2025 _next_ordinal_to_read += 1;
2026 next_offset += envelope_size;
2027 }
2028
2029 let next_out_of_line = decoder.next_out_of_line();
2030 let handles_before = decoder.remaining_handles();
2031 if let Some((inlined, num_bytes, num_handles)) =
2032 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2033 {
2034 let member_inline_size =
2035 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2036 if inlined != (member_inline_size <= 4) {
2037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2038 }
2039 let inner_offset;
2040 let mut inner_depth = depth.clone();
2041 if inlined {
2042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2043 inner_offset = next_offset;
2044 } else {
2045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2046 inner_depth.increment()?;
2047 }
2048 let val_ref = self.tx_total.get_or_insert_with(|| fidl::new_empty!(u64, D));
2049 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2050 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2051 {
2052 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2053 }
2054 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2055 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2056 }
2057 }
2058
2059 next_offset += envelope_size;
2060 _next_ordinal_to_read += 1;
2061 if next_offset >= end_offset {
2062 return Ok(());
2063 }
2064
2065 while _next_ordinal_to_read < 8 {
2067 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2068 _next_ordinal_to_read += 1;
2069 next_offset += envelope_size;
2070 }
2071
2072 let next_out_of_line = decoder.next_out_of_line();
2073 let handles_before = decoder.remaining_handles();
2074 if let Some((inlined, num_bytes, num_handles)) =
2075 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2076 {
2077 let member_inline_size =
2078 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2079 if inlined != (member_inline_size <= 4) {
2080 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2081 }
2082 let inner_offset;
2083 let mut inner_depth = depth.clone();
2084 if inlined {
2085 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2086 inner_offset = next_offset;
2087 } else {
2088 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2089 inner_depth.increment()?;
2090 }
2091 let val_ref = self.tx_drop.get_or_insert_with(|| fidl::new_empty!(u64, D));
2092 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2093 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2094 {
2095 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2096 }
2097 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2098 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2099 }
2100 }
2101
2102 next_offset += envelope_size;
2103
2104 while next_offset < end_offset {
2106 _next_ordinal_to_read += 1;
2107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2108 next_offset += envelope_size;
2109 }
2110
2111 Ok(())
2112 }
2113 }
2114
2115 impl IfaceHistogramStats {
2116 #[inline(always)]
2117 fn max_ordinal_present(&self) -> u64 {
2118 if let Some(_) = self.snr_histograms {
2119 return 4;
2120 }
2121 if let Some(_) = self.rx_rate_index_histograms {
2122 return 3;
2123 }
2124 if let Some(_) = self.rssi_histograms {
2125 return 2;
2126 }
2127 if let Some(_) = self.noise_floor_histograms {
2128 return 1;
2129 }
2130 0
2131 }
2132 }
2133
2134 impl fidl::encoding::ValueTypeMarker for IfaceHistogramStats {
2135 type Borrowed<'a> = &'a Self;
2136 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2137 value
2138 }
2139 }
2140
2141 unsafe impl fidl::encoding::TypeMarker for IfaceHistogramStats {
2142 type Owned = Self;
2143
2144 #[inline(always)]
2145 fn inline_align(_context: fidl::encoding::Context) -> usize {
2146 8
2147 }
2148
2149 #[inline(always)]
2150 fn inline_size(_context: fidl::encoding::Context) -> usize {
2151 16
2152 }
2153 }
2154
2155 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IfaceHistogramStats, D>
2156 for &IfaceHistogramStats
2157 {
2158 unsafe fn encode(
2159 self,
2160 encoder: &mut fidl::encoding::Encoder<'_, D>,
2161 offset: usize,
2162 mut depth: fidl::encoding::Depth,
2163 ) -> fidl::Result<()> {
2164 encoder.debug_check_bounds::<IfaceHistogramStats>(offset);
2165 let max_ordinal: u64 = self.max_ordinal_present();
2167 encoder.write_num(max_ordinal, offset);
2168 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2169 if max_ordinal == 0 {
2171 return Ok(());
2172 }
2173 depth.increment()?;
2174 let envelope_size = 8;
2175 let bytes_len = max_ordinal as usize * envelope_size;
2176 #[allow(unused_variables)]
2177 let offset = encoder.out_of_line_offset(bytes_len);
2178 let mut _prev_end_offset: usize = 0;
2179 if 1 > max_ordinal {
2180 return Ok(());
2181 }
2182
2183 let cur_offset: usize = (1 - 1) * envelope_size;
2186
2187 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2189
2190 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<NoiseFloorHistogram, 8>, D>(
2195 self.noise_floor_histograms.as_ref().map(<fidl::encoding::Vector<NoiseFloorHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2196 encoder, offset + cur_offset, depth
2197 )?;
2198
2199 _prev_end_offset = cur_offset + envelope_size;
2200 if 2 > max_ordinal {
2201 return Ok(());
2202 }
2203
2204 let cur_offset: usize = (2 - 1) * envelope_size;
2207
2208 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2210
2211 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<RssiHistogram, 8>, D>(
2216 self.rssi_histograms.as_ref().map(<fidl::encoding::Vector<RssiHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2217 encoder, offset + cur_offset, depth
2218 )?;
2219
2220 _prev_end_offset = cur_offset + envelope_size;
2221 if 3 > max_ordinal {
2222 return Ok(());
2223 }
2224
2225 let cur_offset: usize = (3 - 1) * envelope_size;
2228
2229 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2231
2232 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<RxRateIndexHistogram, 8>, D>(
2237 self.rx_rate_index_histograms.as_ref().map(<fidl::encoding::Vector<RxRateIndexHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2238 encoder, offset + cur_offset, depth
2239 )?;
2240
2241 _prev_end_offset = cur_offset + envelope_size;
2242 if 4 > max_ordinal {
2243 return Ok(());
2244 }
2245
2246 let cur_offset: usize = (4 - 1) * envelope_size;
2249
2250 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2252
2253 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SnrHistogram, 8>, D>(
2258 self.snr_histograms.as_ref().map(<fidl::encoding::Vector<SnrHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
2259 encoder, offset + cur_offset, depth
2260 )?;
2261
2262 _prev_end_offset = cur_offset + envelope_size;
2263
2264 Ok(())
2265 }
2266 }
2267
2268 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceHistogramStats {
2269 #[inline(always)]
2270 fn new_empty() -> Self {
2271 Self::default()
2272 }
2273
2274 unsafe fn decode(
2275 &mut self,
2276 decoder: &mut fidl::encoding::Decoder<'_, D>,
2277 offset: usize,
2278 mut depth: fidl::encoding::Depth,
2279 ) -> fidl::Result<()> {
2280 decoder.debug_check_bounds::<Self>(offset);
2281 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2282 None => return Err(fidl::Error::NotNullable),
2283 Some(len) => len,
2284 };
2285 if len == 0 {
2287 return Ok(());
2288 };
2289 depth.increment()?;
2290 let envelope_size = 8;
2291 let bytes_len = len * envelope_size;
2292 let offset = decoder.out_of_line_offset(bytes_len)?;
2293 let mut _next_ordinal_to_read = 0;
2295 let mut next_offset = offset;
2296 let end_offset = offset + bytes_len;
2297 _next_ordinal_to_read += 1;
2298 if next_offset >= end_offset {
2299 return Ok(());
2300 }
2301
2302 while _next_ordinal_to_read < 1 {
2304 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2305 _next_ordinal_to_read += 1;
2306 next_offset += envelope_size;
2307 }
2308
2309 let next_out_of_line = decoder.next_out_of_line();
2310 let handles_before = decoder.remaining_handles();
2311 if let Some((inlined, num_bytes, num_handles)) =
2312 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2313 {
2314 let member_inline_size = <fidl::encoding::Vector<NoiseFloorHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2315 if inlined != (member_inline_size <= 4) {
2316 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2317 }
2318 let inner_offset;
2319 let mut inner_depth = depth.clone();
2320 if inlined {
2321 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2322 inner_offset = next_offset;
2323 } else {
2324 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2325 inner_depth.increment()?;
2326 }
2327 let val_ref = self.noise_floor_histograms.get_or_insert_with(
2328 || fidl::new_empty!(fidl::encoding::Vector<NoiseFloorHistogram, 8>, D),
2329 );
2330 fidl::decode!(fidl::encoding::Vector<NoiseFloorHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2331 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2332 {
2333 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2334 }
2335 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2336 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2337 }
2338 }
2339
2340 next_offset += envelope_size;
2341 _next_ordinal_to_read += 1;
2342 if next_offset >= end_offset {
2343 return Ok(());
2344 }
2345
2346 while _next_ordinal_to_read < 2 {
2348 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2349 _next_ordinal_to_read += 1;
2350 next_offset += envelope_size;
2351 }
2352
2353 let next_out_of_line = decoder.next_out_of_line();
2354 let handles_before = decoder.remaining_handles();
2355 if let Some((inlined, num_bytes, num_handles)) =
2356 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2357 {
2358 let member_inline_size = <fidl::encoding::Vector<RssiHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2359 if inlined != (member_inline_size <= 4) {
2360 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2361 }
2362 let inner_offset;
2363 let mut inner_depth = depth.clone();
2364 if inlined {
2365 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2366 inner_offset = next_offset;
2367 } else {
2368 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2369 inner_depth.increment()?;
2370 }
2371 let val_ref = self.rssi_histograms.get_or_insert_with(
2372 || fidl::new_empty!(fidl::encoding::Vector<RssiHistogram, 8>, D),
2373 );
2374 fidl::decode!(fidl::encoding::Vector<RssiHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2375 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2376 {
2377 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2378 }
2379 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2380 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2381 }
2382 }
2383
2384 next_offset += envelope_size;
2385 _next_ordinal_to_read += 1;
2386 if next_offset >= end_offset {
2387 return Ok(());
2388 }
2389
2390 while _next_ordinal_to_read < 3 {
2392 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2393 _next_ordinal_to_read += 1;
2394 next_offset += envelope_size;
2395 }
2396
2397 let next_out_of_line = decoder.next_out_of_line();
2398 let handles_before = decoder.remaining_handles();
2399 if let Some((inlined, num_bytes, num_handles)) =
2400 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2401 {
2402 let member_inline_size = <fidl::encoding::Vector<RxRateIndexHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2403 if inlined != (member_inline_size <= 4) {
2404 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2405 }
2406 let inner_offset;
2407 let mut inner_depth = depth.clone();
2408 if inlined {
2409 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2410 inner_offset = next_offset;
2411 } else {
2412 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2413 inner_depth.increment()?;
2414 }
2415 let val_ref = self.rx_rate_index_histograms.get_or_insert_with(
2416 || fidl::new_empty!(fidl::encoding::Vector<RxRateIndexHistogram, 8>, D),
2417 );
2418 fidl::decode!(fidl::encoding::Vector<RxRateIndexHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2419 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2420 {
2421 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2422 }
2423 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2424 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2425 }
2426 }
2427
2428 next_offset += envelope_size;
2429 _next_ordinal_to_read += 1;
2430 if next_offset >= end_offset {
2431 return Ok(());
2432 }
2433
2434 while _next_ordinal_to_read < 4 {
2436 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2437 _next_ordinal_to_read += 1;
2438 next_offset += envelope_size;
2439 }
2440
2441 let next_out_of_line = decoder.next_out_of_line();
2442 let handles_before = decoder.remaining_handles();
2443 if let Some((inlined, num_bytes, num_handles)) =
2444 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2445 {
2446 let member_inline_size = <fidl::encoding::Vector<SnrHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2447 if inlined != (member_inline_size <= 4) {
2448 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2449 }
2450 let inner_offset;
2451 let mut inner_depth = depth.clone();
2452 if inlined {
2453 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2454 inner_offset = next_offset;
2455 } else {
2456 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2457 inner_depth.increment()?;
2458 }
2459 let val_ref = self.snr_histograms.get_or_insert_with(
2460 || fidl::new_empty!(fidl::encoding::Vector<SnrHistogram, 8>, D),
2461 );
2462 fidl::decode!(fidl::encoding::Vector<SnrHistogram, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
2463 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2464 {
2465 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2466 }
2467 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2468 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2469 }
2470 }
2471
2472 next_offset += envelope_size;
2473
2474 while next_offset < end_offset {
2476 _next_ordinal_to_read += 1;
2477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2478 next_offset += envelope_size;
2479 }
2480
2481 Ok(())
2482 }
2483 }
2484
2485 impl IfaceStats {
2486 #[inline(always)]
2487 fn max_ordinal_present(&self) -> u64 {
2488 if let Some(_) = self.driver_specific_gauges {
2489 return 3;
2490 }
2491 if let Some(_) = self.driver_specific_counters {
2492 return 2;
2493 }
2494 if let Some(_) = self.connection_stats {
2495 return 1;
2496 }
2497 0
2498 }
2499 }
2500
2501 impl fidl::encoding::ValueTypeMarker for IfaceStats {
2502 type Borrowed<'a> = &'a Self;
2503 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2504 value
2505 }
2506 }
2507
2508 unsafe impl fidl::encoding::TypeMarker for IfaceStats {
2509 type Owned = Self;
2510
2511 #[inline(always)]
2512 fn inline_align(_context: fidl::encoding::Context) -> usize {
2513 8
2514 }
2515
2516 #[inline(always)]
2517 fn inline_size(_context: fidl::encoding::Context) -> usize {
2518 16
2519 }
2520 }
2521
2522 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IfaceStats, D>
2523 for &IfaceStats
2524 {
2525 unsafe fn encode(
2526 self,
2527 encoder: &mut fidl::encoding::Encoder<'_, D>,
2528 offset: usize,
2529 mut depth: fidl::encoding::Depth,
2530 ) -> fidl::Result<()> {
2531 encoder.debug_check_bounds::<IfaceStats>(offset);
2532 let max_ordinal: u64 = self.max_ordinal_present();
2534 encoder.write_num(max_ordinal, offset);
2535 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2536 if max_ordinal == 0 {
2538 return Ok(());
2539 }
2540 depth.increment()?;
2541 let envelope_size = 8;
2542 let bytes_len = max_ordinal as usize * envelope_size;
2543 #[allow(unused_variables)]
2544 let offset = encoder.out_of_line_offset(bytes_len);
2545 let mut _prev_end_offset: usize = 0;
2546 if 1 > max_ordinal {
2547 return Ok(());
2548 }
2549
2550 let cur_offset: usize = (1 - 1) * envelope_size;
2553
2554 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2556
2557 fidl::encoding::encode_in_envelope_optional::<ConnectionStats, D>(
2562 self.connection_stats
2563 .as_ref()
2564 .map(<ConnectionStats as fidl::encoding::ValueTypeMarker>::borrow),
2565 encoder,
2566 offset + cur_offset,
2567 depth,
2568 )?;
2569
2570 _prev_end_offset = cur_offset + envelope_size;
2571 if 2 > max_ordinal {
2572 return Ok(());
2573 }
2574
2575 let cur_offset: usize = (2 - 1) * envelope_size;
2578
2579 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2581
2582 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedCounter, 127>, D>(
2587 self.driver_specific_counters.as_ref().map(<fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::ValueTypeMarker>::borrow),
2588 encoder, offset + cur_offset, depth
2589 )?;
2590
2591 _prev_end_offset = cur_offset + envelope_size;
2592 if 3 > max_ordinal {
2593 return Ok(());
2594 }
2595
2596 let cur_offset: usize = (3 - 1) * envelope_size;
2599
2600 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2602
2603 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UnnamedGauge, 127>, D>(
2608 self.driver_specific_gauges.as_ref().map(<fidl::encoding::Vector<UnnamedGauge, 127> as fidl::encoding::ValueTypeMarker>::borrow),
2609 encoder, offset + cur_offset, depth
2610 )?;
2611
2612 _prev_end_offset = cur_offset + envelope_size;
2613
2614 Ok(())
2615 }
2616 }
2617
2618 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceStats {
2619 #[inline(always)]
2620 fn new_empty() -> Self {
2621 Self::default()
2622 }
2623
2624 unsafe fn decode(
2625 &mut self,
2626 decoder: &mut fidl::encoding::Decoder<'_, D>,
2627 offset: usize,
2628 mut depth: fidl::encoding::Depth,
2629 ) -> fidl::Result<()> {
2630 decoder.debug_check_bounds::<Self>(offset);
2631 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2632 None => return Err(fidl::Error::NotNullable),
2633 Some(len) => len,
2634 };
2635 if len == 0 {
2637 return Ok(());
2638 };
2639 depth.increment()?;
2640 let envelope_size = 8;
2641 let bytes_len = len * envelope_size;
2642 let offset = decoder.out_of_line_offset(bytes_len)?;
2643 let mut _next_ordinal_to_read = 0;
2645 let mut next_offset = offset;
2646 let end_offset = offset + bytes_len;
2647 _next_ordinal_to_read += 1;
2648 if next_offset >= end_offset {
2649 return Ok(());
2650 }
2651
2652 while _next_ordinal_to_read < 1 {
2654 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2655 _next_ordinal_to_read += 1;
2656 next_offset += envelope_size;
2657 }
2658
2659 let next_out_of_line = decoder.next_out_of_line();
2660 let handles_before = decoder.remaining_handles();
2661 if let Some((inlined, num_bytes, num_handles)) =
2662 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2663 {
2664 let member_inline_size =
2665 <ConnectionStats as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2666 if inlined != (member_inline_size <= 4) {
2667 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2668 }
2669 let inner_offset;
2670 let mut inner_depth = depth.clone();
2671 if inlined {
2672 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2673 inner_offset = next_offset;
2674 } else {
2675 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2676 inner_depth.increment()?;
2677 }
2678 let val_ref = self
2679 .connection_stats
2680 .get_or_insert_with(|| fidl::new_empty!(ConnectionStats, D));
2681 fidl::decode!(ConnectionStats, D, val_ref, decoder, inner_offset, inner_depth)?;
2682 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2683 {
2684 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2685 }
2686 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2687 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2688 }
2689 }
2690
2691 next_offset += envelope_size;
2692 _next_ordinal_to_read += 1;
2693 if next_offset >= end_offset {
2694 return Ok(());
2695 }
2696
2697 while _next_ordinal_to_read < 2 {
2699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2700 _next_ordinal_to_read += 1;
2701 next_offset += envelope_size;
2702 }
2703
2704 let next_out_of_line = decoder.next_out_of_line();
2705 let handles_before = decoder.remaining_handles();
2706 if let Some((inlined, num_bytes, num_handles)) =
2707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2708 {
2709 let member_inline_size = <fidl::encoding::Vector<UnnamedCounter, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2710 if inlined != (member_inline_size <= 4) {
2711 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2712 }
2713 let inner_offset;
2714 let mut inner_depth = depth.clone();
2715 if inlined {
2716 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2717 inner_offset = next_offset;
2718 } else {
2719 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2720 inner_depth.increment()?;
2721 }
2722 let val_ref = self.driver_specific_counters.get_or_insert_with(
2723 || fidl::new_empty!(fidl::encoding::Vector<UnnamedCounter, 127>, D),
2724 );
2725 fidl::decode!(fidl::encoding::Vector<UnnamedCounter, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
2726 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2727 {
2728 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2729 }
2730 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2731 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2732 }
2733 }
2734
2735 next_offset += envelope_size;
2736 _next_ordinal_to_read += 1;
2737 if next_offset >= end_offset {
2738 return Ok(());
2739 }
2740
2741 while _next_ordinal_to_read < 3 {
2743 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2744 _next_ordinal_to_read += 1;
2745 next_offset += envelope_size;
2746 }
2747
2748 let next_out_of_line = decoder.next_out_of_line();
2749 let handles_before = decoder.remaining_handles();
2750 if let Some((inlined, num_bytes, num_handles)) =
2751 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2752 {
2753 let member_inline_size = <fidl::encoding::Vector<UnnamedGauge, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2754 if inlined != (member_inline_size <= 4) {
2755 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2756 }
2757 let inner_offset;
2758 let mut inner_depth = depth.clone();
2759 if inlined {
2760 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2761 inner_offset = next_offset;
2762 } else {
2763 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2764 inner_depth.increment()?;
2765 }
2766 let val_ref = self.driver_specific_gauges.get_or_insert_with(
2767 || fidl::new_empty!(fidl::encoding::Vector<UnnamedGauge, 127>, D),
2768 );
2769 fidl::decode!(fidl::encoding::Vector<UnnamedGauge, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
2770 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2771 {
2772 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2773 }
2774 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2775 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2776 }
2777 }
2778
2779 next_offset += envelope_size;
2780
2781 while next_offset < end_offset {
2783 _next_ordinal_to_read += 1;
2784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2785 next_offset += envelope_size;
2786 }
2787
2788 Ok(())
2789 }
2790 }
2791
2792 impl InspectCounterConfig {
2793 #[inline(always)]
2794 fn max_ordinal_present(&self) -> u64 {
2795 if let Some(_) = self.counter_name {
2796 return 2;
2797 }
2798 if let Some(_) = self.counter_id {
2799 return 1;
2800 }
2801 0
2802 }
2803 }
2804
2805 impl fidl::encoding::ValueTypeMarker for InspectCounterConfig {
2806 type Borrowed<'a> = &'a Self;
2807 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2808 value
2809 }
2810 }
2811
2812 unsafe impl fidl::encoding::TypeMarker for InspectCounterConfig {
2813 type Owned = Self;
2814
2815 #[inline(always)]
2816 fn inline_align(_context: fidl::encoding::Context) -> usize {
2817 8
2818 }
2819
2820 #[inline(always)]
2821 fn inline_size(_context: fidl::encoding::Context) -> usize {
2822 16
2823 }
2824 }
2825
2826 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InspectCounterConfig, D>
2827 for &InspectCounterConfig
2828 {
2829 unsafe fn encode(
2830 self,
2831 encoder: &mut fidl::encoding::Encoder<'_, D>,
2832 offset: usize,
2833 mut depth: fidl::encoding::Depth,
2834 ) -> fidl::Result<()> {
2835 encoder.debug_check_bounds::<InspectCounterConfig>(offset);
2836 let max_ordinal: u64 = self.max_ordinal_present();
2838 encoder.write_num(max_ordinal, offset);
2839 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2840 if max_ordinal == 0 {
2842 return Ok(());
2843 }
2844 depth.increment()?;
2845 let envelope_size = 8;
2846 let bytes_len = max_ordinal as usize * envelope_size;
2847 #[allow(unused_variables)]
2848 let offset = encoder.out_of_line_offset(bytes_len);
2849 let mut _prev_end_offset: usize = 0;
2850 if 1 > max_ordinal {
2851 return Ok(());
2852 }
2853
2854 let cur_offset: usize = (1 - 1) * envelope_size;
2857
2858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2860
2861 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2866 self.counter_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2867 encoder,
2868 offset + cur_offset,
2869 depth,
2870 )?;
2871
2872 _prev_end_offset = cur_offset + envelope_size;
2873 if 2 > max_ordinal {
2874 return Ok(());
2875 }
2876
2877 let cur_offset: usize = (2 - 1) * envelope_size;
2880
2881 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2883
2884 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<127>, D>(
2889 self.counter_name.as_ref().map(
2890 <fidl::encoding::BoundedString<127> as fidl::encoding::ValueTypeMarker>::borrow,
2891 ),
2892 encoder,
2893 offset + cur_offset,
2894 depth,
2895 )?;
2896
2897 _prev_end_offset = cur_offset + envelope_size;
2898
2899 Ok(())
2900 }
2901 }
2902
2903 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InspectCounterConfig {
2904 #[inline(always)]
2905 fn new_empty() -> Self {
2906 Self::default()
2907 }
2908
2909 unsafe fn decode(
2910 &mut self,
2911 decoder: &mut fidl::encoding::Decoder<'_, D>,
2912 offset: usize,
2913 mut depth: fidl::encoding::Depth,
2914 ) -> fidl::Result<()> {
2915 decoder.debug_check_bounds::<Self>(offset);
2916 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2917 None => return Err(fidl::Error::NotNullable),
2918 Some(len) => len,
2919 };
2920 if len == 0 {
2922 return Ok(());
2923 };
2924 depth.increment()?;
2925 let envelope_size = 8;
2926 let bytes_len = len * envelope_size;
2927 let offset = decoder.out_of_line_offset(bytes_len)?;
2928 let mut _next_ordinal_to_read = 0;
2930 let mut next_offset = offset;
2931 let end_offset = offset + bytes_len;
2932 _next_ordinal_to_read += 1;
2933 if next_offset >= end_offset {
2934 return Ok(());
2935 }
2936
2937 while _next_ordinal_to_read < 1 {
2939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2940 _next_ordinal_to_read += 1;
2941 next_offset += envelope_size;
2942 }
2943
2944 let next_out_of_line = decoder.next_out_of_line();
2945 let handles_before = decoder.remaining_handles();
2946 if let Some((inlined, num_bytes, num_handles)) =
2947 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2948 {
2949 let member_inline_size =
2950 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2951 if inlined != (member_inline_size <= 4) {
2952 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2953 }
2954 let inner_offset;
2955 let mut inner_depth = depth.clone();
2956 if inlined {
2957 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2958 inner_offset = next_offset;
2959 } else {
2960 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2961 inner_depth.increment()?;
2962 }
2963 let val_ref = self.counter_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
2964 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2966 {
2967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2968 }
2969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2971 }
2972 }
2973
2974 next_offset += envelope_size;
2975 _next_ordinal_to_read += 1;
2976 if next_offset >= end_offset {
2977 return Ok(());
2978 }
2979
2980 while _next_ordinal_to_read < 2 {
2982 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2983 _next_ordinal_to_read += 1;
2984 next_offset += envelope_size;
2985 }
2986
2987 let next_out_of_line = decoder.next_out_of_line();
2988 let handles_before = decoder.remaining_handles();
2989 if let Some((inlined, num_bytes, num_handles)) =
2990 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2991 {
2992 let member_inline_size =
2993 <fidl::encoding::BoundedString<127> as fidl::encoding::TypeMarker>::inline_size(
2994 decoder.context,
2995 );
2996 if inlined != (member_inline_size <= 4) {
2997 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2998 }
2999 let inner_offset;
3000 let mut inner_depth = depth.clone();
3001 if inlined {
3002 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3003 inner_offset = next_offset;
3004 } else {
3005 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3006 inner_depth.increment()?;
3007 }
3008 let val_ref = self
3009 .counter_name
3010 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<127>, D));
3011 fidl::decode!(
3012 fidl::encoding::BoundedString<127>,
3013 D,
3014 val_ref,
3015 decoder,
3016 inner_offset,
3017 inner_depth
3018 )?;
3019 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3020 {
3021 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3022 }
3023 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3024 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3025 }
3026 }
3027
3028 next_offset += envelope_size;
3029
3030 while next_offset < end_offset {
3032 _next_ordinal_to_read += 1;
3033 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3034 next_offset += envelope_size;
3035 }
3036
3037 Ok(())
3038 }
3039 }
3040
3041 impl InspectGaugeConfig {
3042 #[inline(always)]
3043 fn max_ordinal_present(&self) -> u64 {
3044 if let Some(_) = self.statistics {
3045 return 3;
3046 }
3047 if let Some(_) = self.gauge_name {
3048 return 2;
3049 }
3050 if let Some(_) = self.gauge_id {
3051 return 1;
3052 }
3053 0
3054 }
3055 }
3056
3057 impl fidl::encoding::ValueTypeMarker for InspectGaugeConfig {
3058 type Borrowed<'a> = &'a Self;
3059 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3060 value
3061 }
3062 }
3063
3064 unsafe impl fidl::encoding::TypeMarker for InspectGaugeConfig {
3065 type Owned = Self;
3066
3067 #[inline(always)]
3068 fn inline_align(_context: fidl::encoding::Context) -> usize {
3069 8
3070 }
3071
3072 #[inline(always)]
3073 fn inline_size(_context: fidl::encoding::Context) -> usize {
3074 16
3075 }
3076 }
3077
3078 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InspectGaugeConfig, D>
3079 for &InspectGaugeConfig
3080 {
3081 unsafe fn encode(
3082 self,
3083 encoder: &mut fidl::encoding::Encoder<'_, D>,
3084 offset: usize,
3085 mut depth: fidl::encoding::Depth,
3086 ) -> fidl::Result<()> {
3087 encoder.debug_check_bounds::<InspectGaugeConfig>(offset);
3088 let max_ordinal: u64 = self.max_ordinal_present();
3090 encoder.write_num(max_ordinal, offset);
3091 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3092 if max_ordinal == 0 {
3094 return Ok(());
3095 }
3096 depth.increment()?;
3097 let envelope_size = 8;
3098 let bytes_len = max_ordinal as usize * envelope_size;
3099 #[allow(unused_variables)]
3100 let offset = encoder.out_of_line_offset(bytes_len);
3101 let mut _prev_end_offset: usize = 0;
3102 if 1 > max_ordinal {
3103 return Ok(());
3104 }
3105
3106 let cur_offset: usize = (1 - 1) * envelope_size;
3109
3110 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3112
3113 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3118 self.gauge_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3119 encoder,
3120 offset + cur_offset,
3121 depth,
3122 )?;
3123
3124 _prev_end_offset = cur_offset + envelope_size;
3125 if 2 > max_ordinal {
3126 return Ok(());
3127 }
3128
3129 let cur_offset: usize = (2 - 1) * envelope_size;
3132
3133 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3135
3136 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<127>, D>(
3141 self.gauge_name.as_ref().map(
3142 <fidl::encoding::BoundedString<127> as fidl::encoding::ValueTypeMarker>::borrow,
3143 ),
3144 encoder,
3145 offset + cur_offset,
3146 depth,
3147 )?;
3148
3149 _prev_end_offset = cur_offset + envelope_size;
3150 if 3 > max_ordinal {
3151 return Ok(());
3152 }
3153
3154 let cur_offset: usize = (3 - 1) * envelope_size;
3157
3158 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3160
3161 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<GaugeStatistic, 5>, D>(
3166 self.statistics.as_ref().map(<fidl::encoding::Vector<GaugeStatistic, 5> as fidl::encoding::ValueTypeMarker>::borrow),
3167 encoder, offset + cur_offset, depth
3168 )?;
3169
3170 _prev_end_offset = cur_offset + envelope_size;
3171
3172 Ok(())
3173 }
3174 }
3175
3176 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InspectGaugeConfig {
3177 #[inline(always)]
3178 fn new_empty() -> Self {
3179 Self::default()
3180 }
3181
3182 unsafe fn decode(
3183 &mut self,
3184 decoder: &mut fidl::encoding::Decoder<'_, D>,
3185 offset: usize,
3186 mut depth: fidl::encoding::Depth,
3187 ) -> fidl::Result<()> {
3188 decoder.debug_check_bounds::<Self>(offset);
3189 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3190 None => return Err(fidl::Error::NotNullable),
3191 Some(len) => len,
3192 };
3193 if len == 0 {
3195 return Ok(());
3196 };
3197 depth.increment()?;
3198 let envelope_size = 8;
3199 let bytes_len = len * envelope_size;
3200 let offset = decoder.out_of_line_offset(bytes_len)?;
3201 let mut _next_ordinal_to_read = 0;
3203 let mut next_offset = offset;
3204 let end_offset = offset + bytes_len;
3205 _next_ordinal_to_read += 1;
3206 if next_offset >= end_offset {
3207 return Ok(());
3208 }
3209
3210 while _next_ordinal_to_read < 1 {
3212 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3213 _next_ordinal_to_read += 1;
3214 next_offset += envelope_size;
3215 }
3216
3217 let next_out_of_line = decoder.next_out_of_line();
3218 let handles_before = decoder.remaining_handles();
3219 if let Some((inlined, num_bytes, num_handles)) =
3220 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3221 {
3222 let member_inline_size =
3223 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3224 if inlined != (member_inline_size <= 4) {
3225 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3226 }
3227 let inner_offset;
3228 let mut inner_depth = depth.clone();
3229 if inlined {
3230 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3231 inner_offset = next_offset;
3232 } else {
3233 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3234 inner_depth.increment()?;
3235 }
3236 let val_ref = self.gauge_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
3237 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3238 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3239 {
3240 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3241 }
3242 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3243 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3244 }
3245 }
3246
3247 next_offset += envelope_size;
3248 _next_ordinal_to_read += 1;
3249 if next_offset >= end_offset {
3250 return Ok(());
3251 }
3252
3253 while _next_ordinal_to_read < 2 {
3255 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3256 _next_ordinal_to_read += 1;
3257 next_offset += envelope_size;
3258 }
3259
3260 let next_out_of_line = decoder.next_out_of_line();
3261 let handles_before = decoder.remaining_handles();
3262 if let Some((inlined, num_bytes, num_handles)) =
3263 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3264 {
3265 let member_inline_size =
3266 <fidl::encoding::BoundedString<127> as fidl::encoding::TypeMarker>::inline_size(
3267 decoder.context,
3268 );
3269 if inlined != (member_inline_size <= 4) {
3270 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3271 }
3272 let inner_offset;
3273 let mut inner_depth = depth.clone();
3274 if inlined {
3275 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3276 inner_offset = next_offset;
3277 } else {
3278 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3279 inner_depth.increment()?;
3280 }
3281 let val_ref = self
3282 .gauge_name
3283 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<127>, D));
3284 fidl::decode!(
3285 fidl::encoding::BoundedString<127>,
3286 D,
3287 val_ref,
3288 decoder,
3289 inner_offset,
3290 inner_depth
3291 )?;
3292 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3293 {
3294 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3295 }
3296 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3297 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3298 }
3299 }
3300
3301 next_offset += envelope_size;
3302 _next_ordinal_to_read += 1;
3303 if next_offset >= end_offset {
3304 return Ok(());
3305 }
3306
3307 while _next_ordinal_to_read < 3 {
3309 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3310 _next_ordinal_to_read += 1;
3311 next_offset += envelope_size;
3312 }
3313
3314 let next_out_of_line = decoder.next_out_of_line();
3315 let handles_before = decoder.remaining_handles();
3316 if let Some((inlined, num_bytes, num_handles)) =
3317 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3318 {
3319 let member_inline_size = <fidl::encoding::Vector<GaugeStatistic, 5> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3320 if inlined != (member_inline_size <= 4) {
3321 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3322 }
3323 let inner_offset;
3324 let mut inner_depth = depth.clone();
3325 if inlined {
3326 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3327 inner_offset = next_offset;
3328 } else {
3329 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3330 inner_depth.increment()?;
3331 }
3332 let val_ref = self.statistics.get_or_insert_with(
3333 || fidl::new_empty!(fidl::encoding::Vector<GaugeStatistic, 5>, D),
3334 );
3335 fidl::decode!(fidl::encoding::Vector<GaugeStatistic, 5>, D, val_ref, decoder, inner_offset, inner_depth)?;
3336 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3337 {
3338 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3339 }
3340 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3341 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3342 }
3343 }
3344
3345 next_offset += envelope_size;
3346
3347 while next_offset < end_offset {
3349 _next_ordinal_to_read += 1;
3350 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3351 next_offset += envelope_size;
3352 }
3353
3354 Ok(())
3355 }
3356 }
3357
3358 impl TelemetrySupport {
3359 #[inline(always)]
3360 fn max_ordinal_present(&self) -> u64 {
3361 if let Some(_) = self.inspect_gauge_configs {
3362 return 2;
3363 }
3364 if let Some(_) = self.inspect_counter_configs {
3365 return 1;
3366 }
3367 0
3368 }
3369 }
3370
3371 impl fidl::encoding::ValueTypeMarker for TelemetrySupport {
3372 type Borrowed<'a> = &'a Self;
3373 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3374 value
3375 }
3376 }
3377
3378 unsafe impl fidl::encoding::TypeMarker for TelemetrySupport {
3379 type Owned = Self;
3380
3381 #[inline(always)]
3382 fn inline_align(_context: fidl::encoding::Context) -> usize {
3383 8
3384 }
3385
3386 #[inline(always)]
3387 fn inline_size(_context: fidl::encoding::Context) -> usize {
3388 16
3389 }
3390 }
3391
3392 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TelemetrySupport, D>
3393 for &TelemetrySupport
3394 {
3395 unsafe fn encode(
3396 self,
3397 encoder: &mut fidl::encoding::Encoder<'_, D>,
3398 offset: usize,
3399 mut depth: fidl::encoding::Depth,
3400 ) -> fidl::Result<()> {
3401 encoder.debug_check_bounds::<TelemetrySupport>(offset);
3402 let max_ordinal: u64 = self.max_ordinal_present();
3404 encoder.write_num(max_ordinal, offset);
3405 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3406 if max_ordinal == 0 {
3408 return Ok(());
3409 }
3410 depth.increment()?;
3411 let envelope_size = 8;
3412 let bytes_len = max_ordinal as usize * envelope_size;
3413 #[allow(unused_variables)]
3414 let offset = encoder.out_of_line_offset(bytes_len);
3415 let mut _prev_end_offset: usize = 0;
3416 if 1 > max_ordinal {
3417 return Ok(());
3418 }
3419
3420 let cur_offset: usize = (1 - 1) * envelope_size;
3423
3424 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3426
3427 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InspectCounterConfig, 127>, D>(
3432 self.inspect_counter_configs.as_ref().map(<fidl::encoding::Vector<InspectCounterConfig, 127> as fidl::encoding::ValueTypeMarker>::borrow),
3433 encoder, offset + cur_offset, depth
3434 )?;
3435
3436 _prev_end_offset = cur_offset + envelope_size;
3437 if 2 > max_ordinal {
3438 return Ok(());
3439 }
3440
3441 let cur_offset: usize = (2 - 1) * envelope_size;
3444
3445 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3447
3448 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InspectGaugeConfig, 127>, D>(
3453 self.inspect_gauge_configs.as_ref().map(<fidl::encoding::Vector<InspectGaugeConfig, 127> as fidl::encoding::ValueTypeMarker>::borrow),
3454 encoder, offset + cur_offset, depth
3455 )?;
3456
3457 _prev_end_offset = cur_offset + envelope_size;
3458
3459 Ok(())
3460 }
3461 }
3462
3463 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TelemetrySupport {
3464 #[inline(always)]
3465 fn new_empty() -> Self {
3466 Self::default()
3467 }
3468
3469 unsafe fn decode(
3470 &mut self,
3471 decoder: &mut fidl::encoding::Decoder<'_, D>,
3472 offset: usize,
3473 mut depth: fidl::encoding::Depth,
3474 ) -> fidl::Result<()> {
3475 decoder.debug_check_bounds::<Self>(offset);
3476 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3477 None => return Err(fidl::Error::NotNullable),
3478 Some(len) => len,
3479 };
3480 if len == 0 {
3482 return Ok(());
3483 };
3484 depth.increment()?;
3485 let envelope_size = 8;
3486 let bytes_len = len * envelope_size;
3487 let offset = decoder.out_of_line_offset(bytes_len)?;
3488 let mut _next_ordinal_to_read = 0;
3490 let mut next_offset = offset;
3491 let end_offset = offset + bytes_len;
3492 _next_ordinal_to_read += 1;
3493 if next_offset >= end_offset {
3494 return Ok(());
3495 }
3496
3497 while _next_ordinal_to_read < 1 {
3499 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3500 _next_ordinal_to_read += 1;
3501 next_offset += envelope_size;
3502 }
3503
3504 let next_out_of_line = decoder.next_out_of_line();
3505 let handles_before = decoder.remaining_handles();
3506 if let Some((inlined, num_bytes, num_handles)) =
3507 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3508 {
3509 let member_inline_size = <fidl::encoding::Vector<InspectCounterConfig, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3510 if inlined != (member_inline_size <= 4) {
3511 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3512 }
3513 let inner_offset;
3514 let mut inner_depth = depth.clone();
3515 if inlined {
3516 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3517 inner_offset = next_offset;
3518 } else {
3519 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3520 inner_depth.increment()?;
3521 }
3522 let val_ref = self.inspect_counter_configs.get_or_insert_with(
3523 || fidl::new_empty!(fidl::encoding::Vector<InspectCounterConfig, 127>, D),
3524 );
3525 fidl::decode!(fidl::encoding::Vector<InspectCounterConfig, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
3526 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3527 {
3528 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3529 }
3530 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3531 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3532 }
3533 }
3534
3535 next_offset += envelope_size;
3536 _next_ordinal_to_read += 1;
3537 if next_offset >= end_offset {
3538 return Ok(());
3539 }
3540
3541 while _next_ordinal_to_read < 2 {
3543 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3544 _next_ordinal_to_read += 1;
3545 next_offset += envelope_size;
3546 }
3547
3548 let next_out_of_line = decoder.next_out_of_line();
3549 let handles_before = decoder.remaining_handles();
3550 if let Some((inlined, num_bytes, num_handles)) =
3551 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3552 {
3553 let member_inline_size = <fidl::encoding::Vector<InspectGaugeConfig, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3554 if inlined != (member_inline_size <= 4) {
3555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3556 }
3557 let inner_offset;
3558 let mut inner_depth = depth.clone();
3559 if inlined {
3560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3561 inner_offset = next_offset;
3562 } else {
3563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3564 inner_depth.increment()?;
3565 }
3566 let val_ref = self.inspect_gauge_configs.get_or_insert_with(
3567 || fidl::new_empty!(fidl::encoding::Vector<InspectGaugeConfig, 127>, D),
3568 );
3569 fidl::decode!(fidl::encoding::Vector<InspectGaugeConfig, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
3570 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3571 {
3572 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3573 }
3574 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3575 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3576 }
3577 }
3578
3579 next_offset += envelope_size;
3580
3581 while next_offset < end_offset {
3583 _next_ordinal_to_read += 1;
3584 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3585 next_offset += envelope_size;
3586 }
3587
3588 Ok(())
3589 }
3590 }
3591}