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