fidl_fuchsia_wlan_stats__common/
fidl_fuchsia_wlan_stats__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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
17/// For each histogram type (e.g. RSSI), there can be multiple histograms up to this limit. For
18/// example, an interface might have 1 histogram for station-wide RSSI, but also 1 for each of the
19/// antennas used by the interface.
20pub const MAX_HISTOGRAMS_PER_TYPE: u8 = 8;
21
22/// All histograms have a fixed number of buckets. To save space, each histogram type
23/// uses a vector to hold only non-empty buckets (a sparse histogram), with these constants as the
24/// max size of each vector.
25/// Noise floor values range from -255 to -1 dBm.
26pub const MAX_NOISE_FLOOR_SAMPLES: u8 = 255;
27
28/// RSSI values range from -255 to -1 dBm.
29pub const MAX_RSSI_SAMPLES: u8 = 255;
30
31/// Size of RxRateIndexHistogram lookup table (see comments in RxRateIndexHistogram).
32pub const MAX_RX_RATE_INDEX_SAMPLES: u8 = 196;
33
34/// SNR values range from 0 to 255 dB.
35pub const MAX_SNR_SAMPLES: u16 = 256;
36
37pub const STAT_NAME_MAX_LENGTH: u8 = 127;
38
39/// Antenna frequency.
40#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
41#[repr(u8)]
42pub enum AntennaFreq {
43    /// 2.4 GHz.
44    Antenna2G = 1,
45    /// 5 GHz.
46    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/// Statistics supported by the Gauge type.
66#[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/// Pattern that matches an unknown `GaugeStatistic` member.
80#[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/// The scope of the histogram, e.g. if the histogram contains data for the entire station, or has
139/// data for just a single antenna.
140#[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/// Identifier for antenna.
164#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
165pub struct AntennaId {
166    pub freq: AntennaFreq,
167    /// 0 indexed antenna number of freq.
168    pub index: u8,
169}
170
171impl fidl::Persistable for AntennaId {}
172
173/// Histogram bucket.
174#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
175#[repr(C)]
176pub struct HistBucket {
177    /// Index into a lookup table for each histogram type. The lookup table for each type is
178    /// described below in the comments for each type.
179    pub bucket_index: u16,
180    /// The count of samples in the bucket.
181    pub num_samples: u64,
182}
183
184impl fidl::Persistable for HistBucket {}
185
186/// Histogram for noise floor samples.
187#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
188pub struct NoiseFloorHistogram {
189    pub hist_scope: HistScope,
190    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
191    pub antenna_id: Option<Box<AntennaId>>,
192    /// Sparse histogram of noise floor of current channel in dBm. Each sample's bucket_index is an
193    /// index into this list of dBm values: [-255, -254, ... -1]. For example, if
194    /// noise_floor_samples contains a HistBucket with bucket_index = 165 and num_samples = 50, that
195    /// means there were 50 frames counted that had a noise floor of -90 dBm.
196    pub noise_floor_samples: Vec<HistBucket>,
197    /// Count of invalid samples encountered, if any.
198    pub invalid_samples: u64,
199}
200
201impl fidl::Persistable for NoiseFloorHistogram {}
202
203/// Histogram for received signal strength indicator (RSSI).
204#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
205pub struct RssiHistogram {
206    pub hist_scope: HistScope,
207    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
208    pub antenna_id: Option<Box<AntennaId>>,
209    /// Sparse histogram of RSSI of AP in dBm. Each sample's bucket_index is an index
210    /// into this list of dBm values: [-255, -254, ... -1]. For example, if rssi_samples
211    /// contains a HistBucket with bucket_index = 225 and num_samples = 50, that means
212    /// there were 50 frames counted that had a signal level of -30 dBm.
213    pub rssi_samples: Vec<HistBucket>,
214    /// Count of invalid samples encountered, if any.
215    pub invalid_samples: u64,
216}
217
218impl fidl::Persistable for RssiHistogram {}
219
220/// Histogram for received data rate.
221#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
222pub struct RxRateIndexHistogram {
223    pub hist_scope: HistScope,
224    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
225    pub antenna_id: Option<Box<AntennaId>>,
226    /// Sparse histogram of count of received frames for each rate. Each sample's bucket_index is an
227    /// index into this lookup table:
228    /// 0-3: B-MCS 0-3
229    /// 4-11: G-MCS 0-7
230    /// 12-27: N-MCS 0-15 (BW20)
231    /// 28-43: N-MCS 0-15 (BW40)
232    /// 44-59: N-MCS 0-15 (BW20:SGI)
233    /// 60-75: N-MCS 0-15 (BW40:SGI)
234    /// 76-85: AC-MCS 0-9 (VHT:BW20:NSS1)
235    /// 86-95: AC-MCS 0-9 (VHT:BW20:NSS2)
236    /// 96-105: AC-MCS 0-9 (VHT:BW40:NSS1)
237    /// 106-115: AC-MCS 0-9 (VHT:BW40:NSS2)
238    /// 116-125: AC-MCS 0-9 (VHT:BW80:NSS1)
239    /// 126-135: AC-MCS 0-9 (VHT:BW80:NSS2)
240    /// 136-145: AC-MCS 0-9 (VHT:BW20:NSS1:SGI)
241    /// 146-155: AC-MCS 0-9 (VHT:BW20:NSS2:SGI)
242    /// 156-165: AC-MCS 0-9 (VHT:BW40:NSS1:SGI)
243    /// 166-175: AC-MCS 0-9 (VHT:BW40:NSS2:SGI)
244    /// 176-185: AC-MCS 0-9 (VHT:BW80:NSS1:SGI)
245    /// 186-195: AC-MCS 0-9 (VHT:BW80:NSS2:SGI)
246    ///
247    /// For example, if rx_rate_index_samples contains a HistBucket with bucket_index = 75
248    /// and num_samples = 50, that means there were 50 frames counted that had a rate corresponding
249    /// to N-MCS 15 (BW40:SGI).
250    pub rx_rate_index_samples: Vec<HistBucket>,
251    /// Count of invalid samples encountered, if any.
252    pub invalid_samples: u64,
253}
254
255impl fidl::Persistable for RxRateIndexHistogram {}
256
257/// Histogram for signal to noise ratio (SNR).
258#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
259pub struct SnrHistogram {
260    pub hist_scope: HistScope,
261    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
262    pub antenna_id: Option<Box<AntennaId>>,
263    /// Sparse histogram of signal to noise ratio in dB. Each sample's bucket_index is an index
264    /// into this list of dB values: [0, 1, ... 255]. For example, if snr_samples contains a
265    /// HistBucket with value = 60 and num_samples = 50, that means there were 50 frames
266    /// counted that had a SNR of 60 dB.
267    pub snr_samples: Vec<HistBucket>,
268    /// Count of invalid samples encountered, if any.
269    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    /// ID of the current connection. Used by WLAN telemetry to determine whether
295    /// the current counters and the previous counters belong to the same connection.
296    /// If the counters belong to two different connections, telemetry will not diff
297    /// between them as it assumes that the driver/firmware has reset the counter
298    /// in between.
299    ///
300    /// The driver should set a new connection ID after a successful connection,
301    /// reconnection, or roaming attempt, as it's expected that the connection-
302    /// related counters would reset on a new connection.
303    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    /// Noise floor histogram(s).
320    pub noise_floor_histograms: Option<Vec<NoiseFloorHistogram>>,
321    /// Received signal strength indicator (RSSI) histogram(s).
322    pub rssi_histograms: Option<Vec<RssiHistogram>>,
323    /// Received rate index histogram(s).
324    pub rx_rate_index_histograms: Option<Vec<RxRateIndexHistogram>>,
325    /// Signal to noise ratio (SNR) histogram(s).
326    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    /// Stats related to the current connection. May not be set if the client is not connected.
336    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/// Config to associate a driver-specific counter ID with a counter name that is
346/// to be used in Inspect.
347#[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/// Config to associate a driver-specific gauge ID with a gauge name that is
358/// to be used in Inspect.
359#[derive(Clone, Debug, Default, PartialEq)]
360pub struct InspectGaugeConfig {
361    pub gauge_id: Option<u16>,
362    pub gauge_name: Option<String>,
363    /// An Inspect time series would be created per statistic.
364    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    /// Specifies counters that should be logged into Inspect time series
374    pub inspect_counter_configs: Option<Vec<InspectCounterConfig>>,
375    /// Specifies gauges that should be logged into Inspect time series
376    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            // Delegate to tuple encoding.
617            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            // Zero out padding regions. There's no need to apply masks
643            // because the unmasked parts will be overwritten by fields.
644            // Write the fields.
645            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            // Verify that padding bytes are zero.
666            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                // Copy the object into the buffer.
706                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
707                (buf_ptr as *mut HistBucket).write_unaligned((self as *const HistBucket).read());
708                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
709                // done second because the memcpy will write garbage to these bytes.
710                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            // Zero out padding regions. There's no need to apply masks
732            // because the unmasked parts will be overwritten by fields.
733            unsafe {
734                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
735                (ptr as *mut u64).write_unaligned(0);
736            }
737            // Write the fields.
738            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            // Verify that padding bytes are zero.
760            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            // Copy from the buffer into the object.
770            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            // Delegate to tuple encoding.
810            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            // Zero out padding regions. There's no need to apply masks
838            // because the unmasked parts will be overwritten by fields.
839            unsafe {
840                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
841                (ptr as *mut u64).write_unaligned(0);
842            }
843            // Write the fields.
844            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            // Verify that padding bytes are zero.
872            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            // Delegate to tuple encoding.
929            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            // Zero out padding regions. There's no need to apply masks
957            // because the unmasked parts will be overwritten by fields.
958            unsafe {
959                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
960                (ptr as *mut u64).write_unaligned(0);
961            }
962            // Write the fields.
963            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            // Verify that padding bytes are zero.
991            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            // Delegate to tuple encoding.
1048            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            // Zero out padding regions. There's no need to apply masks
1076            // because the unmasked parts will be overwritten by fields.
1077            unsafe {
1078                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1079                (ptr as *mut u64).write_unaligned(0);
1080            }
1081            // Write the fields.
1082            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            // Verify that padding bytes are zero.
1110            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            // Delegate to tuple encoding.
1167            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            // Zero out padding regions. There's no need to apply masks
1195            // because the unmasked parts will be overwritten by fields.
1196            unsafe {
1197                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1198                (ptr as *mut u64).write_unaligned(0);
1199            }
1200            // Write the fields.
1201            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            // Verify that padding bytes are zero.
1229            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                // Copy the object into the buffer.
1287                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1291                // done second because the memcpy will write garbage to these bytes.
1292                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            // Zero out padding regions. There's no need to apply masks
1314            // because the unmasked parts will be overwritten by fields.
1315            unsafe {
1316                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1317                (ptr as *mut u64).write_unaligned(0);
1318            }
1319            // Write the fields.
1320            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            // Verify that padding bytes are zero.
1342            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            // Copy from the buffer into the object.
1352            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                // Copy the object into the buffer.
1393                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1397                // done second because the memcpy will write garbage to these bytes.
1398                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            // Zero out padding regions. There's no need to apply masks
1420            // because the unmasked parts will be overwritten by fields.
1421            unsafe {
1422                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1423                (ptr as *mut u64).write_unaligned(0);
1424            }
1425            // Write the fields.
1426            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            // Verify that padding bytes are zero.
1448            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            // Copy from the buffer into the object.
1458            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            // Vector header
1528            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1532            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1546            // are envelope_size bytes.
1547            let cur_offset: usize = (1 - 1) * envelope_size;
1548
1549            // Zero reserved fields.
1550            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1551
1552            // Safety:
1553            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1554            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1555            //   envelope_size bytes, there is always sufficient room.
1556            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1569            // are envelope_size bytes.
1570            let cur_offset: usize = (2 - 1) * envelope_size;
1571
1572            // Zero reserved fields.
1573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1574
1575            // Safety:
1576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1578            //   envelope_size bytes, there is always sufficient room.
1579            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1590            // are envelope_size bytes.
1591            let cur_offset: usize = (3 - 1) * envelope_size;
1592
1593            // Zero reserved fields.
1594            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1595
1596            // Safety:
1597            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1598            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1599            //   envelope_size bytes, there is always sufficient room.
1600            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1611            // are envelope_size bytes.
1612            let cur_offset: usize = (4 - 1) * envelope_size;
1613
1614            // Zero reserved fields.
1615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1616
1617            // Safety:
1618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1620            //   envelope_size bytes, there is always sufficient room.
1621            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1636            // are envelope_size bytes.
1637            let cur_offset: usize = (5 - 1) * envelope_size;
1638
1639            // Zero reserved fields.
1640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1641
1642            // Safety:
1643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1645            //   envelope_size bytes, there is always sufficient room.
1646            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1659            // are envelope_size bytes.
1660            let cur_offset: usize = (6 - 1) * envelope_size;
1661
1662            // Zero reserved fields.
1663            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1664
1665            // Safety:
1666            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1667            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1668            //   envelope_size bytes, there is always sufficient room.
1669            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1682            // are envelope_size bytes.
1683            let cur_offset: usize = (7 - 1) * envelope_size;
1684
1685            // Zero reserved fields.
1686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1687
1688            // Safety:
1689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1691            //   envelope_size bytes, there is always sufficient room.
1692            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1705            // are envelope_size bytes.
1706            let cur_offset: usize = (8 - 1) * envelope_size;
1707
1708            // Zero reserved fields.
1709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1710
1711            // Safety:
1712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1714            //   envelope_size bytes, there is always sufficient room.
1715            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1746            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            // Decode the envelope for each type.
1754            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            // Decode unknown envelopes for gaps in ordinals.
1763            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            // Decode unknown envelopes for gaps in ordinals.
1806            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            // Decode unknown envelopes for gaps in ordinals.
1850            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            // Decode unknown envelopes for gaps in ordinals.
1894            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            // Decode unknown envelopes for gaps in ordinals.
1937            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            // Decode unknown envelopes for gaps in ordinals.
1980            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            // Decode unknown envelopes for gaps in ordinals.
2023            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            // Decode unknown envelopes for gaps in ordinals.
2066            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            // Decode the remaining unknown envelopes.
2105            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            // Vector header
2166            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2170            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2184            // are envelope_size bytes.
2185            let cur_offset: usize = (1 - 1) * envelope_size;
2186
2187            // Zero reserved fields.
2188            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2189
2190            // Safety:
2191            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2192            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2193            //   envelope_size bytes, there is always sufficient room.
2194            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2205            // are envelope_size bytes.
2206            let cur_offset: usize = (2 - 1) * envelope_size;
2207
2208            // Zero reserved fields.
2209            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2210
2211            // Safety:
2212            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2213            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2214            //   envelope_size bytes, there is always sufficient room.
2215            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2226            // are envelope_size bytes.
2227            let cur_offset: usize = (3 - 1) * envelope_size;
2228
2229            // Zero reserved fields.
2230            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2231
2232            // Safety:
2233            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2234            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2235            //   envelope_size bytes, there is always sufficient room.
2236            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2247            // are envelope_size bytes.
2248            let cur_offset: usize = (4 - 1) * envelope_size;
2249
2250            // Zero reserved fields.
2251            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2252
2253            // Safety:
2254            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2255            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2256            //   envelope_size bytes, there is always sufficient room.
2257            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2286            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            // Decode the envelope for each type.
2294            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            // Decode unknown envelopes for gaps in ordinals.
2303            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            // Decode unknown envelopes for gaps in ordinals.
2347            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            // Decode unknown envelopes for gaps in ordinals.
2391            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            // Decode unknown envelopes for gaps in ordinals.
2435            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            // Decode the remaining unknown envelopes.
2475            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            // Vector header
2533            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2537            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2551            // are envelope_size bytes.
2552            let cur_offset: usize = (1 - 1) * envelope_size;
2553
2554            // Zero reserved fields.
2555            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2556
2557            // Safety:
2558            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2559            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2560            //   envelope_size bytes, there is always sufficient room.
2561            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2576            // are envelope_size bytes.
2577            let cur_offset: usize = (2 - 1) * envelope_size;
2578
2579            // Zero reserved fields.
2580            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2581
2582            // Safety:
2583            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2584            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2585            //   envelope_size bytes, there is always sufficient room.
2586            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2597            // are envelope_size bytes.
2598            let cur_offset: usize = (3 - 1) * envelope_size;
2599
2600            // Zero reserved fields.
2601            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2602
2603            // Safety:
2604            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2605            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2606            //   envelope_size bytes, there is always sufficient room.
2607            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2636            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            // Decode the envelope for each type.
2644            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            // Decode unknown envelopes for gaps in ordinals.
2653            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            // Decode unknown envelopes for gaps in ordinals.
2698            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            // Decode unknown envelopes for gaps in ordinals.
2742            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            // Decode the remaining unknown envelopes.
2782            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            // Vector header
2837            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2841            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2855            // are envelope_size bytes.
2856            let cur_offset: usize = (1 - 1) * envelope_size;
2857
2858            // Zero reserved fields.
2859            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2860
2861            // Safety:
2862            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2863            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2864            //   envelope_size bytes, there is always sufficient room.
2865            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2878            // are envelope_size bytes.
2879            let cur_offset: usize = (2 - 1) * envelope_size;
2880
2881            // Zero reserved fields.
2882            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2883
2884            // Safety:
2885            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2886            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2887            //   envelope_size bytes, there is always sufficient room.
2888            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2921            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            // Decode the envelope for each type.
2929            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            // Decode unknown envelopes for gaps in ordinals.
2938            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            // Decode unknown envelopes for gaps in ordinals.
2981            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            // Decode the remaining unknown envelopes.
3031            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            // Vector header
3089            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3093            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3107            // are envelope_size bytes.
3108            let cur_offset: usize = (1 - 1) * envelope_size;
3109
3110            // Zero reserved fields.
3111            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3112
3113            // Safety:
3114            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3115            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3116            //   envelope_size bytes, there is always sufficient room.
3117            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3130            // are envelope_size bytes.
3131            let cur_offset: usize = (2 - 1) * envelope_size;
3132
3133            // Zero reserved fields.
3134            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3135
3136            // Safety:
3137            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3138            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3139            //   envelope_size bytes, there is always sufficient room.
3140            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3155            // are envelope_size bytes.
3156            let cur_offset: usize = (3 - 1) * envelope_size;
3157
3158            // Zero reserved fields.
3159            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3160
3161            // Safety:
3162            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3163            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3164            //   envelope_size bytes, there is always sufficient room.
3165            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3194            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            // Decode the envelope for each type.
3202            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            // Decode unknown envelopes for gaps in ordinals.
3211            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            // Decode unknown envelopes for gaps in ordinals.
3254            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            // Decode unknown envelopes for gaps in ordinals.
3308            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            // Decode the remaining unknown envelopes.
3348            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            // Vector header
3403            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3407            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3421            // are envelope_size bytes.
3422            let cur_offset: usize = (1 - 1) * envelope_size;
3423
3424            // Zero reserved fields.
3425            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3426
3427            // Safety:
3428            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3429            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3430            //   envelope_size bytes, there is always sufficient room.
3431            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3442            // are envelope_size bytes.
3443            let cur_offset: usize = (2 - 1) * envelope_size;
3444
3445            // Zero reserved fields.
3446            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3447
3448            // Safety:
3449            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3450            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3451            //   envelope_size bytes, there is always sufficient room.
3452            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3481            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            // Decode the envelope for each type.
3489            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            // Decode unknown envelopes for gaps in ordinals.
3498            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            // Decode unknown envelopes for gaps in ordinals.
3542            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            // Decode the remaining unknown envelopes.
3582            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}