fidl_fuchsia_net_tun__common/
fidl_fuchsia_net_tun__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// The TX and RX FIFO Depths used by tun devices.
12pub const FIFO_DEPTH: u16 = 128;
13
14/// Maximum supported MTU.
15pub const MAX_MTU: u32 = 16384;
16
17/// Maximum number of multicast filters that a device holds in `MacState`.
18pub const MAX_MULTICAST_FILTERS: u32 = 64;
19
20/// Maximum number of pending [`fuchsia.net.tun/Device.WriteFrame`] or
21/// [`fuchsia.net.tun/Device.ReadFrame`] that are allowed.
22pub const MAX_PENDING_OPERATIONS: u32 = 32;
23
24bitflags! {
25    /// Signals set in the `eventpair` returned by
26    /// [`fuchsia.net.tun/Device.GetSignals`].
27    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
28    pub struct Signals: u32 {
29        /// Indicates that write buffers are available to be used through
30        /// [`fuchsia.net.tun/Device.WriteFrame`].
31        const WRITABLE = 16777216;
32        /// Indicates that read buffers are available to be used through
33        /// [`fuchsia.net.tun/Device.ReadFrame`].
34        const READABLE = 33554432;
35    }
36}
37
38impl Signals {}
39
40#[derive(Clone, Debug, PartialEq)]
41pub struct DevicePairAddPortRequest {
42    pub config: DevicePairPortConfig,
43}
44
45impl fidl::Persistable for DevicePairAddPortRequest {}
46
47#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
48#[repr(C)]
49pub struct DevicePairRemovePortRequest {
50    pub id: u8,
51}
52
53impl fidl::Persistable for DevicePairRemovePortRequest {}
54
55#[derive(Clone, Debug, PartialEq)]
56pub struct DeviceWriteFrameRequest {
57    pub frame: Frame,
58}
59
60impl fidl::Persistable for DeviceWriteFrameRequest {}
61
62#[derive(Clone, Debug, PartialEq)]
63pub struct DeviceReadFrameResponse {
64    pub frame: Frame,
65}
66
67impl fidl::Persistable for DeviceReadFrameResponse {}
68
69#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70pub struct FrameMetadata {
71    /// Additional frame information type.
72    ///
73    /// If not set, interpreted as
74    /// [`fuchsia.hardware.network/InfoType.NO_INFO`].
75    pub info_type: fidl_fuchsia_hardware_network__common::InfoType,
76    /// Additional frame information value.
77    ///
78    /// If not set, interpreted as empty bytes.
79    pub info: Vec<u8>,
80    /// Frame flags. `RxFlags` for `WriteFrame` and `TxFlags` for
81    /// `ReadFrame`.
82    ///
83    /// If not set, interpreted as zero.
84    pub flags: u32,
85}
86
87impl fidl::Persistable for FrameMetadata {}
88
89#[derive(Clone, Debug, PartialEq)]
90pub struct PortGetStateResponse {
91    pub state: InternalState,
92}
93
94impl fidl::Persistable for PortGetStateResponse {}
95
96#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
97pub struct PortSetOnlineRequest {
98    pub online: bool,
99}
100
101impl fidl::Persistable for PortSetOnlineRequest {}
102
103#[derive(Clone, Debug, PartialEq)]
104pub struct PortWatchStateResponse {
105    pub state: InternalState,
106}
107
108impl fidl::Persistable for PortWatchStateResponse {}
109
110/// Base device configuration.
111#[derive(Clone, Debug, Default, PartialEq)]
112pub struct BaseDeviceConfig {
113    /// Report frame metadata on receiving frames.
114    ///
115    /// If not set, Interpreted as `false`.
116    pub report_metadata: Option<bool>,
117    /// Minimum requested TX buffer length, in bytes.
118    ///
119    /// If not set, interpreted as zero.
120    pub min_tx_buffer_length: Option<u32>,
121    /// Minimum requested RX buffer length, in bytes.
122    ///
123    /// If not set, interpreted as zero.
124    pub min_rx_buffer_length: Option<u32>,
125    #[doc(hidden)]
126    pub __source_breaking: fidl::marker::SourceBreaking,
127}
128
129impl fidl::Persistable for BaseDeviceConfig {}
130
131/// Logical device port configuration.
132#[derive(Clone, Debug, Default, PartialEq)]
133pub struct BasePortConfig {
134    /// Port identifier.
135    ///
136    /// Required.
137    pub id: Option<u8>,
138    /// Device MTU (maximum transmit unit).
139    ///
140    /// Valid iff less than or equal to [`MAX_MTU`].
141    ///
142    /// If not set, interpreted as [`MAX_MTU`].
143    pub mtu: Option<u32>,
144    /// Supported Rx frame types for port.
145    ///
146    /// Valid iff non-empty.
147    ///
148    /// Required.
149    pub rx_types: Option<Vec<fidl_fuchsia_hardware_network__common::FrameType>>,
150    /// Supported Tx frame types on port.
151    ///
152    /// Valid iff non-empty.
153    ///
154    /// Required.
155    pub tx_types: Option<Vec<fidl_fuchsia_hardware_network__common::FrameTypeSupport>>,
156    /// Port class.
157    ///
158    /// If not set, interpreted as `VIRTUAL`.
159    pub port_class: Option<fidl_fuchsia_hardware_network__common::PortClass>,
160    #[doc(hidden)]
161    pub __source_breaking: fidl::marker::SourceBreaking,
162}
163
164impl fidl::Persistable for BasePortConfig {}
165
166#[derive(Clone, Debug, Default, PartialEq)]
167pub struct DeviceConfig {
168    /// Base device configuration.
169    ///
170    /// It not set, interpreted as an empty table.
171    pub base: Option<BaseDeviceConfig>,
172    /// If `true`, [`fuchsia.net.tun/Device.WriteFrame`] and
173    /// [`fuchsia.net.tun/Device.ReadFrame`] blocks returning until the
174    /// corresponding buffers are available to complete the call.
175    ///
176    /// It not set, interpreted as `false`.
177    pub blocking: Option<bool>,
178    #[doc(hidden)]
179    pub __source_breaking: fidl::marker::SourceBreaking,
180}
181
182impl fidl::Persistable for DeviceConfig {}
183
184#[derive(Clone, Debug, Default, PartialEq)]
185pub struct DevicePairConfig {
186    /// Base device configuration.
187    ///
188    /// It not set, interpreted as an empty table.
189    pub base: Option<BaseDeviceConfig>,
190    /// If `true`, transmit buffers on the left end are dropped if no
191    /// receive buffers are available on the right end to receive it.
192    /// Otherwise, transmit buffers wait until a receive buffer is
193    /// available to copy them to.
194    ///
195    /// It not set, interpreted as `false`.
196    pub fallible_transmit_left: Option<bool>,
197    /// Like `fallible_transmit_left` but allows writes to the right end
198    /// to be fallible.
199    ///
200    /// It not set, interpreted as `false`.
201    pub fallible_transmit_right: Option<bool>,
202    #[doc(hidden)]
203    pub __source_breaking: fidl::marker::SourceBreaking,
204}
205
206impl fidl::Persistable for DevicePairConfig {}
207
208#[derive(Clone, Debug, Default, PartialEq)]
209pub struct DevicePairPortConfig {
210    /// Base port configuration.
211    ///
212    /// Required.
213    pub base: Option<BasePortConfig>,
214    /// MAC address to report.
215    ///
216    /// If set, left port provides a
217    /// [`fuchsia.hardware.network/MacAddressing`] implementation
218    /// through [`fuchsia.hardware.network/Port.GetMac`].
219    pub mac_left: Option<fidl_fuchsia_net__common::MacAddress>,
220    /// MAC address to report.
221    ///
222    /// If set, right port provides a
223    /// [`fuchsia.hardware.network/MacAddressing`] implementation
224    /// through [`fuchsia.hardware.network/Port.GetMac`].
225    pub mac_right: Option<fidl_fuchsia_net__common::MacAddress>,
226    #[doc(hidden)]
227    pub __source_breaking: fidl::marker::SourceBreaking,
228}
229
230impl fidl::Persistable for DevicePairPortConfig {}
231
232#[derive(Clone, Debug, Default, PartialEq)]
233pub struct DevicePortConfig {
234    /// Base port configuration.
235    ///
236    /// Required.
237    pub base: Option<BasePortConfig>,
238    /// Start port with link online.
239    ///
240    /// If not set, interpreted as `false`.
241    pub online: Option<bool>,
242    /// MAC address to report.
243    ///
244    /// If set, the port provides a
245    /// [`fuchsia.hardware.network/MacAddressing`] implementation /
246    /// through [`fuchsia.hardware.network/Port.GetMac`].
247    pub mac: Option<fidl_fuchsia_net__common::MacAddress>,
248    #[doc(hidden)]
249    pub __source_breaking: fidl::marker::SourceBreaking,
250}
251
252impl fidl::Persistable for DevicePortConfig {}
253
254/// A frame written to or read from a [`fuchsia.net.tun/Device`].
255///
256/// Required fields must always be provided to
257/// [`fuchsia.net.tun/Port.WriteFrame`] and are always present when returned by
258/// [`fuchsia.net.tun/Port.ReadFrame`].
259#[derive(Clone, Debug, Default, PartialEq)]
260pub struct Frame {
261    /// The type identifying this frame's payload.
262    ///
263    /// Required.
264    pub frame_type: Option<fidl_fuchsia_hardware_network__common::FrameType>,
265    /// The frame's payload.
266    ///
267    /// Valid iff non-empty.
268    ///
269    /// Required.
270    pub data: Option<Vec<u8>>,
271    /// Extra frame metadata.
272    ///
273    /// This is an opaque holder for extra information that is associated with
274    /// Network Device data frames.
275    ///
276    /// If not set, interpreted as empty.
277    pub meta: Option<FrameMetadata>,
278    /// Frame's destination or source port identifier.
279    ///
280    /// Required.
281    pub port: Option<u8>,
282    #[doc(hidden)]
283    pub __source_breaking: fidl::marker::SourceBreaking,
284}
285
286impl fidl::Persistable for Frame {}
287
288/// Internal device state.
289#[derive(Clone, Debug, Default, PartialEq)]
290pub struct InternalState {
291    /// State associated with Mac Address filtering.
292    ///
293    /// Devices never perform any MAC address filtering, but they implement the
294    /// [`fuchsia.hardware.network/MacAddressing`] interface and store the
295    /// values to be retrieved through the [`fuchsia.net.tun/InternalState`]
296    /// structure.
297    ///
298    /// Set iff `mac` is provided in the [`DevicePortConfig`] or
299    /// [`DevicePairPortConfig`] structures upon creation of the port.
300    pub mac: Option<MacState>,
301    /// Whether there is a session currently opened and running with the `Port`.
302    ///
303    /// Required.
304    pub has_session: Option<bool>,
305    #[doc(hidden)]
306    pub __source_breaking: fidl::marker::SourceBreaking,
307}
308
309impl fidl::Persistable for InternalState {}
310
311#[derive(Clone, Debug, Default, PartialEq)]
312pub struct MacState {
313    /// The currently configured MAC Address filtering mode.
314    ///
315    /// Required.
316    pub mode: Option<fidl_fuchsia_hardware_network__common::MacFilterMode>,
317    /// The full list of configured multicast address filtering.
318    ///
319    /// Required.
320    pub multicast_filters: Option<Vec<fidl_fuchsia_net__common::MacAddress>>,
321    #[doc(hidden)]
322    pub __source_breaking: fidl::marker::SourceBreaking,
323}
324
325impl fidl::Persistable for MacState {}
326
327pub mod control_ordinals {
328    pub const CREATE_DEVICE: u64 = 0x2aace38c0c1cd187;
329    pub const CREATE_PAIR: u64 = 0x2c8884060cc29d18;
330}
331
332pub mod device_ordinals {
333    pub const WRITE_FRAME: u64 = 0x2d19e24e149bf6db;
334    pub const READ_FRAME: u64 = 0x6ebc56b8427e1571;
335    pub const GET_SIGNALS: u64 = 0x4d1ca50fc53606b9;
336    pub const ADD_PORT: u64 = 0x6b56b238f04ee3d4;
337    pub const GET_DEVICE: u64 = 0x2e8c81fdcdd99d26;
338    pub const DELEGATE_RX_LEASE: u64 = 0x660137a0e680b4c0;
339}
340
341pub mod device_pair_ordinals {
342    pub const ADD_PORT: u64 = 0x362f4856a075e1f8;
343    pub const REMOVE_PORT: u64 = 0x33bb45cc1d3fbe1e;
344    pub const GET_LEFT: u64 = 0x1357a771a6ccb303;
345    pub const GET_RIGHT: u64 = 0x45ebce063223b60f;
346    pub const GET_LEFT_PORT: u64 = 0x6e3038d75096ab77;
347    pub const GET_RIGHT_PORT: u64 = 0x7fc4716601eb987c;
348}
349
350pub mod port_ordinals {
351    pub const GET_STATE: u64 = 0x5022630816212ed;
352    pub const WATCH_STATE: u64 = 0x74d3c94c96e2b605;
353    pub const SET_ONLINE: u64 = 0x734f83793ce86e6c;
354    pub const GET_PORT: u64 = 0x1998638c1d97eed2;
355    pub const REMOVE: u64 = 0x4f45201ed5719261;
356}
357
358mod internal {
359    use super::*;
360    unsafe impl fidl::encoding::TypeMarker for Signals {
361        type Owned = Self;
362
363        #[inline(always)]
364        fn inline_align(_context: fidl::encoding::Context) -> usize {
365            4
366        }
367
368        #[inline(always)]
369        fn inline_size(_context: fidl::encoding::Context) -> usize {
370            4
371        }
372    }
373
374    impl fidl::encoding::ValueTypeMarker for Signals {
375        type Borrowed<'a> = Self;
376        #[inline(always)]
377        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
378            *value
379        }
380    }
381
382    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Signals {
383        #[inline]
384        unsafe fn encode(
385            self,
386            encoder: &mut fidl::encoding::Encoder<'_, D>,
387            offset: usize,
388            _depth: fidl::encoding::Depth,
389        ) -> fidl::Result<()> {
390            encoder.debug_check_bounds::<Self>(offset);
391            if self.bits() & Self::all().bits() != self.bits() {
392                return Err(fidl::Error::InvalidBitsValue);
393            }
394            encoder.write_num(self.bits(), offset);
395            Ok(())
396        }
397    }
398
399    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Signals {
400        #[inline(always)]
401        fn new_empty() -> Self {
402            Self::empty()
403        }
404
405        #[inline]
406        unsafe fn decode(
407            &mut self,
408            decoder: &mut fidl::encoding::Decoder<'_, D>,
409            offset: usize,
410            _depth: fidl::encoding::Depth,
411        ) -> fidl::Result<()> {
412            decoder.debug_check_bounds::<Self>(offset);
413            let prim = decoder.read_num::<u32>(offset);
414            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
415            Ok(())
416        }
417    }
418
419    impl fidl::encoding::ValueTypeMarker for DevicePairAddPortRequest {
420        type Borrowed<'a> = &'a Self;
421        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
422            value
423        }
424    }
425
426    unsafe impl fidl::encoding::TypeMarker for DevicePairAddPortRequest {
427        type Owned = Self;
428
429        #[inline(always)]
430        fn inline_align(_context: fidl::encoding::Context) -> usize {
431            8
432        }
433
434        #[inline(always)]
435        fn inline_size(_context: fidl::encoding::Context) -> usize {
436            16
437        }
438    }
439
440    unsafe impl<D: fidl::encoding::ResourceDialect>
441        fidl::encoding::Encode<DevicePairAddPortRequest, D> for &DevicePairAddPortRequest
442    {
443        #[inline]
444        unsafe fn encode(
445            self,
446            encoder: &mut fidl::encoding::Encoder<'_, D>,
447            offset: usize,
448            _depth: fidl::encoding::Depth,
449        ) -> fidl::Result<()> {
450            encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
451            // Delegate to tuple encoding.
452            fidl::encoding::Encode::<DevicePairAddPortRequest, D>::encode(
453                (<DevicePairPortConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
454                encoder,
455                offset,
456                _depth,
457            )
458        }
459    }
460    unsafe impl<
461            D: fidl::encoding::ResourceDialect,
462            T0: fidl::encoding::Encode<DevicePairPortConfig, D>,
463        > fidl::encoding::Encode<DevicePairAddPortRequest, D> for (T0,)
464    {
465        #[inline]
466        unsafe fn encode(
467            self,
468            encoder: &mut fidl::encoding::Encoder<'_, D>,
469            offset: usize,
470            depth: fidl::encoding::Depth,
471        ) -> fidl::Result<()> {
472            encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
473            // Zero out padding regions. There's no need to apply masks
474            // because the unmasked parts will be overwritten by fields.
475            // Write the fields.
476            self.0.encode(encoder, offset + 0, depth)?;
477            Ok(())
478        }
479    }
480
481    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
482        for DevicePairAddPortRequest
483    {
484        #[inline(always)]
485        fn new_empty() -> Self {
486            Self { config: fidl::new_empty!(DevicePairPortConfig, D) }
487        }
488
489        #[inline]
490        unsafe fn decode(
491            &mut self,
492            decoder: &mut fidl::encoding::Decoder<'_, D>,
493            offset: usize,
494            _depth: fidl::encoding::Depth,
495        ) -> fidl::Result<()> {
496            decoder.debug_check_bounds::<Self>(offset);
497            // Verify that padding bytes are zero.
498            fidl::decode!(DevicePairPortConfig, D, &mut self.config, decoder, offset + 0, _depth)?;
499            Ok(())
500        }
501    }
502
503    impl fidl::encoding::ValueTypeMarker for DevicePairRemovePortRequest {
504        type Borrowed<'a> = &'a Self;
505        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
506            value
507        }
508    }
509
510    unsafe impl fidl::encoding::TypeMarker for DevicePairRemovePortRequest {
511        type Owned = Self;
512
513        #[inline(always)]
514        fn inline_align(_context: fidl::encoding::Context) -> usize {
515            1
516        }
517
518        #[inline(always)]
519        fn inline_size(_context: fidl::encoding::Context) -> usize {
520            1
521        }
522        #[inline(always)]
523        fn encode_is_copy() -> bool {
524            true
525        }
526
527        #[inline(always)]
528        fn decode_is_copy() -> bool {
529            true
530        }
531    }
532
533    unsafe impl<D: fidl::encoding::ResourceDialect>
534        fidl::encoding::Encode<DevicePairRemovePortRequest, D> for &DevicePairRemovePortRequest
535    {
536        #[inline]
537        unsafe fn encode(
538            self,
539            encoder: &mut fidl::encoding::Encoder<'_, D>,
540            offset: usize,
541            _depth: fidl::encoding::Depth,
542        ) -> fidl::Result<()> {
543            encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
544            unsafe {
545                // Copy the object into the buffer.
546                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
547                (buf_ptr as *mut DevicePairRemovePortRequest)
548                    .write_unaligned((self as *const DevicePairRemovePortRequest).read());
549                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
550                // done second because the memcpy will write garbage to these bytes.
551            }
552            Ok(())
553        }
554    }
555    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
556        fidl::encoding::Encode<DevicePairRemovePortRequest, D> for (T0,)
557    {
558        #[inline]
559        unsafe fn encode(
560            self,
561            encoder: &mut fidl::encoding::Encoder<'_, D>,
562            offset: usize,
563            depth: fidl::encoding::Depth,
564        ) -> fidl::Result<()> {
565            encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
566            // Zero out padding regions. There's no need to apply masks
567            // because the unmasked parts will be overwritten by fields.
568            // Write the fields.
569            self.0.encode(encoder, offset + 0, depth)?;
570            Ok(())
571        }
572    }
573
574    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
575        for DevicePairRemovePortRequest
576    {
577        #[inline(always)]
578        fn new_empty() -> Self {
579            Self { id: fidl::new_empty!(u8, D) }
580        }
581
582        #[inline]
583        unsafe fn decode(
584            &mut self,
585            decoder: &mut fidl::encoding::Decoder<'_, D>,
586            offset: usize,
587            _depth: fidl::encoding::Depth,
588        ) -> fidl::Result<()> {
589            decoder.debug_check_bounds::<Self>(offset);
590            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
591            // Verify that padding bytes are zero.
592            // Copy from the buffer into the object.
593            unsafe {
594                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
595            }
596            Ok(())
597        }
598    }
599
600    impl fidl::encoding::ValueTypeMarker for DeviceWriteFrameRequest {
601        type Borrowed<'a> = &'a Self;
602        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
603            value
604        }
605    }
606
607    unsafe impl fidl::encoding::TypeMarker for DeviceWriteFrameRequest {
608        type Owned = Self;
609
610        #[inline(always)]
611        fn inline_align(_context: fidl::encoding::Context) -> usize {
612            8
613        }
614
615        #[inline(always)]
616        fn inline_size(_context: fidl::encoding::Context) -> usize {
617            16
618        }
619    }
620
621    unsafe impl<D: fidl::encoding::ResourceDialect>
622        fidl::encoding::Encode<DeviceWriteFrameRequest, D> for &DeviceWriteFrameRequest
623    {
624        #[inline]
625        unsafe fn encode(
626            self,
627            encoder: &mut fidl::encoding::Encoder<'_, D>,
628            offset: usize,
629            _depth: fidl::encoding::Depth,
630        ) -> fidl::Result<()> {
631            encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
632            // Delegate to tuple encoding.
633            fidl::encoding::Encode::<DeviceWriteFrameRequest, D>::encode(
634                (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
635                encoder,
636                offset,
637                _depth,
638            )
639        }
640    }
641    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
642        fidl::encoding::Encode<DeviceWriteFrameRequest, D> for (T0,)
643    {
644        #[inline]
645        unsafe fn encode(
646            self,
647            encoder: &mut fidl::encoding::Encoder<'_, D>,
648            offset: usize,
649            depth: fidl::encoding::Depth,
650        ) -> fidl::Result<()> {
651            encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
652            // Zero out padding regions. There's no need to apply masks
653            // because the unmasked parts will be overwritten by fields.
654            // Write the fields.
655            self.0.encode(encoder, offset + 0, depth)?;
656            Ok(())
657        }
658    }
659
660    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
661        for DeviceWriteFrameRequest
662    {
663        #[inline(always)]
664        fn new_empty() -> Self {
665            Self { frame: fidl::new_empty!(Frame, D) }
666        }
667
668        #[inline]
669        unsafe fn decode(
670            &mut self,
671            decoder: &mut fidl::encoding::Decoder<'_, D>,
672            offset: usize,
673            _depth: fidl::encoding::Depth,
674        ) -> fidl::Result<()> {
675            decoder.debug_check_bounds::<Self>(offset);
676            // Verify that padding bytes are zero.
677            fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
678            Ok(())
679        }
680    }
681
682    impl fidl::encoding::ValueTypeMarker for DeviceReadFrameResponse {
683        type Borrowed<'a> = &'a Self;
684        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
685            value
686        }
687    }
688
689    unsafe impl fidl::encoding::TypeMarker for DeviceReadFrameResponse {
690        type Owned = Self;
691
692        #[inline(always)]
693        fn inline_align(_context: fidl::encoding::Context) -> usize {
694            8
695        }
696
697        #[inline(always)]
698        fn inline_size(_context: fidl::encoding::Context) -> usize {
699            16
700        }
701    }
702
703    unsafe impl<D: fidl::encoding::ResourceDialect>
704        fidl::encoding::Encode<DeviceReadFrameResponse, D> for &DeviceReadFrameResponse
705    {
706        #[inline]
707        unsafe fn encode(
708            self,
709            encoder: &mut fidl::encoding::Encoder<'_, D>,
710            offset: usize,
711            _depth: fidl::encoding::Depth,
712        ) -> fidl::Result<()> {
713            encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
714            // Delegate to tuple encoding.
715            fidl::encoding::Encode::<DeviceReadFrameResponse, D>::encode(
716                (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
717                encoder,
718                offset,
719                _depth,
720            )
721        }
722    }
723    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
724        fidl::encoding::Encode<DeviceReadFrameResponse, D> for (T0,)
725    {
726        #[inline]
727        unsafe fn encode(
728            self,
729            encoder: &mut fidl::encoding::Encoder<'_, D>,
730            offset: usize,
731            depth: fidl::encoding::Depth,
732        ) -> fidl::Result<()> {
733            encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
734            // Zero out padding regions. There's no need to apply masks
735            // because the unmasked parts will be overwritten by fields.
736            // Write the fields.
737            self.0.encode(encoder, offset + 0, depth)?;
738            Ok(())
739        }
740    }
741
742    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
743        for DeviceReadFrameResponse
744    {
745        #[inline(always)]
746        fn new_empty() -> Self {
747            Self { frame: fidl::new_empty!(Frame, D) }
748        }
749
750        #[inline]
751        unsafe fn decode(
752            &mut self,
753            decoder: &mut fidl::encoding::Decoder<'_, D>,
754            offset: usize,
755            _depth: fidl::encoding::Depth,
756        ) -> fidl::Result<()> {
757            decoder.debug_check_bounds::<Self>(offset);
758            // Verify that padding bytes are zero.
759            fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
760            Ok(())
761        }
762    }
763
764    impl fidl::encoding::ValueTypeMarker for FrameMetadata {
765        type Borrowed<'a> = &'a Self;
766        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
767            value
768        }
769    }
770
771    unsafe impl fidl::encoding::TypeMarker for FrameMetadata {
772        type Owned = Self;
773
774        #[inline(always)]
775        fn inline_align(_context: fidl::encoding::Context) -> usize {
776            8
777        }
778
779        #[inline(always)]
780        fn inline_size(_context: fidl::encoding::Context) -> usize {
781            32
782        }
783    }
784
785    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameMetadata, D>
786        for &FrameMetadata
787    {
788        #[inline]
789        unsafe fn encode(
790            self,
791            encoder: &mut fidl::encoding::Encoder<'_, D>,
792            offset: usize,
793            _depth: fidl::encoding::Depth,
794        ) -> fidl::Result<()> {
795            encoder.debug_check_bounds::<FrameMetadata>(offset);
796            // Delegate to tuple encoding.
797            fidl::encoding::Encode::<FrameMetadata, D>::encode(
798                (
799                    <fidl_fuchsia_hardware_network__common::InfoType as fidl::encoding::ValueTypeMarker>::borrow(&self.info_type),
800                    <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
801                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
802                ),
803                encoder, offset, _depth
804            )
805        }
806    }
807    unsafe impl<
808            D: fidl::encoding::ResourceDialect,
809            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_network__common::InfoType, D>,
810            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4096>, D>,
811            T2: fidl::encoding::Encode<u32, D>,
812        > fidl::encoding::Encode<FrameMetadata, D> for (T0, T1, T2)
813    {
814        #[inline]
815        unsafe fn encode(
816            self,
817            encoder: &mut fidl::encoding::Encoder<'_, D>,
818            offset: usize,
819            depth: fidl::encoding::Depth,
820        ) -> fidl::Result<()> {
821            encoder.debug_check_bounds::<FrameMetadata>(offset);
822            // Zero out padding regions. There's no need to apply masks
823            // because the unmasked parts will be overwritten by fields.
824            unsafe {
825                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
826                (ptr as *mut u64).write_unaligned(0);
827            }
828            unsafe {
829                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
830                (ptr as *mut u64).write_unaligned(0);
831            }
832            // Write the fields.
833            self.0.encode(encoder, offset + 0, depth)?;
834            self.1.encode(encoder, offset + 8, depth)?;
835            self.2.encode(encoder, offset + 24, depth)?;
836            Ok(())
837        }
838    }
839
840    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameMetadata {
841        #[inline(always)]
842        fn new_empty() -> Self {
843            Self {
844                info_type: fidl::new_empty!(fidl_fuchsia_hardware_network__common::InfoType, D),
845                info: fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D),
846                flags: fidl::new_empty!(u32, D),
847            }
848        }
849
850        #[inline]
851        unsafe fn decode(
852            &mut self,
853            decoder: &mut fidl::encoding::Decoder<'_, D>,
854            offset: usize,
855            _depth: fidl::encoding::Depth,
856        ) -> fidl::Result<()> {
857            decoder.debug_check_bounds::<Self>(offset);
858            // Verify that padding bytes are zero.
859            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
860            let padval = unsafe { (ptr as *const u64).read_unaligned() };
861            let mask = 0xffffffff00000000u64;
862            let maskedval = padval & mask;
863            if maskedval != 0 {
864                return Err(fidl::Error::NonZeroPadding {
865                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
866                });
867            }
868            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
869            let padval = unsafe { (ptr as *const u64).read_unaligned() };
870            let mask = 0xffffffff00000000u64;
871            let maskedval = padval & mask;
872            if maskedval != 0 {
873                return Err(fidl::Error::NonZeroPadding {
874                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
875                });
876            }
877            fidl::decode!(
878                fidl_fuchsia_hardware_network__common::InfoType,
879                D,
880                &mut self.info_type,
881                decoder,
882                offset + 0,
883                _depth
884            )?;
885            fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, &mut self.info, decoder, offset + 8, _depth)?;
886            fidl::decode!(u32, D, &mut self.flags, decoder, offset + 24, _depth)?;
887            Ok(())
888        }
889    }
890
891    impl fidl::encoding::ValueTypeMarker for PortGetStateResponse {
892        type Borrowed<'a> = &'a Self;
893        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
894            value
895        }
896    }
897
898    unsafe impl fidl::encoding::TypeMarker for PortGetStateResponse {
899        type Owned = Self;
900
901        #[inline(always)]
902        fn inline_align(_context: fidl::encoding::Context) -> usize {
903            8
904        }
905
906        #[inline(always)]
907        fn inline_size(_context: fidl::encoding::Context) -> usize {
908            16
909        }
910    }
911
912    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortGetStateResponse, D>
913        for &PortGetStateResponse
914    {
915        #[inline]
916        unsafe fn encode(
917            self,
918            encoder: &mut fidl::encoding::Encoder<'_, D>,
919            offset: usize,
920            _depth: fidl::encoding::Depth,
921        ) -> fidl::Result<()> {
922            encoder.debug_check_bounds::<PortGetStateResponse>(offset);
923            // Delegate to tuple encoding.
924            fidl::encoding::Encode::<PortGetStateResponse, D>::encode(
925                (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
926                encoder,
927                offset,
928                _depth,
929            )
930        }
931    }
932    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
933        fidl::encoding::Encode<PortGetStateResponse, D> for (T0,)
934    {
935        #[inline]
936        unsafe fn encode(
937            self,
938            encoder: &mut fidl::encoding::Encoder<'_, D>,
939            offset: usize,
940            depth: fidl::encoding::Depth,
941        ) -> fidl::Result<()> {
942            encoder.debug_check_bounds::<PortGetStateResponse>(offset);
943            // Zero out padding regions. There's no need to apply masks
944            // because the unmasked parts will be overwritten by fields.
945            // Write the fields.
946            self.0.encode(encoder, offset + 0, depth)?;
947            Ok(())
948        }
949    }
950
951    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortGetStateResponse {
952        #[inline(always)]
953        fn new_empty() -> Self {
954            Self { state: fidl::new_empty!(InternalState, D) }
955        }
956
957        #[inline]
958        unsafe fn decode(
959            &mut self,
960            decoder: &mut fidl::encoding::Decoder<'_, D>,
961            offset: usize,
962            _depth: fidl::encoding::Depth,
963        ) -> fidl::Result<()> {
964            decoder.debug_check_bounds::<Self>(offset);
965            // Verify that padding bytes are zero.
966            fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
967            Ok(())
968        }
969    }
970
971    impl fidl::encoding::ValueTypeMarker for PortSetOnlineRequest {
972        type Borrowed<'a> = &'a Self;
973        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
974            value
975        }
976    }
977
978    unsafe impl fidl::encoding::TypeMarker for PortSetOnlineRequest {
979        type Owned = Self;
980
981        #[inline(always)]
982        fn inline_align(_context: fidl::encoding::Context) -> usize {
983            1
984        }
985
986        #[inline(always)]
987        fn inline_size(_context: fidl::encoding::Context) -> usize {
988            1
989        }
990    }
991
992    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortSetOnlineRequest, D>
993        for &PortSetOnlineRequest
994    {
995        #[inline]
996        unsafe fn encode(
997            self,
998            encoder: &mut fidl::encoding::Encoder<'_, D>,
999            offset: usize,
1000            _depth: fidl::encoding::Depth,
1001        ) -> fidl::Result<()> {
1002            encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
1003            // Delegate to tuple encoding.
1004            fidl::encoding::Encode::<PortSetOnlineRequest, D>::encode(
1005                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.online),),
1006                encoder,
1007                offset,
1008                _depth,
1009            )
1010        }
1011    }
1012    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1013        fidl::encoding::Encode<PortSetOnlineRequest, D> for (T0,)
1014    {
1015        #[inline]
1016        unsafe fn encode(
1017            self,
1018            encoder: &mut fidl::encoding::Encoder<'_, D>,
1019            offset: usize,
1020            depth: fidl::encoding::Depth,
1021        ) -> fidl::Result<()> {
1022            encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
1023            // Zero out padding regions. There's no need to apply masks
1024            // because the unmasked parts will be overwritten by fields.
1025            // Write the fields.
1026            self.0.encode(encoder, offset + 0, depth)?;
1027            Ok(())
1028        }
1029    }
1030
1031    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortSetOnlineRequest {
1032        #[inline(always)]
1033        fn new_empty() -> Self {
1034            Self { online: fidl::new_empty!(bool, D) }
1035        }
1036
1037        #[inline]
1038        unsafe fn decode(
1039            &mut self,
1040            decoder: &mut fidl::encoding::Decoder<'_, D>,
1041            offset: usize,
1042            _depth: fidl::encoding::Depth,
1043        ) -> fidl::Result<()> {
1044            decoder.debug_check_bounds::<Self>(offset);
1045            // Verify that padding bytes are zero.
1046            fidl::decode!(bool, D, &mut self.online, decoder, offset + 0, _depth)?;
1047            Ok(())
1048        }
1049    }
1050
1051    impl fidl::encoding::ValueTypeMarker for PortWatchStateResponse {
1052        type Borrowed<'a> = &'a Self;
1053        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1054            value
1055        }
1056    }
1057
1058    unsafe impl fidl::encoding::TypeMarker for PortWatchStateResponse {
1059        type Owned = Self;
1060
1061        #[inline(always)]
1062        fn inline_align(_context: fidl::encoding::Context) -> usize {
1063            8
1064        }
1065
1066        #[inline(always)]
1067        fn inline_size(_context: fidl::encoding::Context) -> usize {
1068            16
1069        }
1070    }
1071
1072    unsafe impl<D: fidl::encoding::ResourceDialect>
1073        fidl::encoding::Encode<PortWatchStateResponse, D> for &PortWatchStateResponse
1074    {
1075        #[inline]
1076        unsafe fn encode(
1077            self,
1078            encoder: &mut fidl::encoding::Encoder<'_, D>,
1079            offset: usize,
1080            _depth: fidl::encoding::Depth,
1081        ) -> fidl::Result<()> {
1082            encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1083            // Delegate to tuple encoding.
1084            fidl::encoding::Encode::<PortWatchStateResponse, D>::encode(
1085                (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
1086                encoder,
1087                offset,
1088                _depth,
1089            )
1090        }
1091    }
1092    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
1093        fidl::encoding::Encode<PortWatchStateResponse, D> for (T0,)
1094    {
1095        #[inline]
1096        unsafe fn encode(
1097            self,
1098            encoder: &mut fidl::encoding::Encoder<'_, D>,
1099            offset: usize,
1100            depth: fidl::encoding::Depth,
1101        ) -> fidl::Result<()> {
1102            encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1103            // Zero out padding regions. There's no need to apply masks
1104            // because the unmasked parts will be overwritten by fields.
1105            // Write the fields.
1106            self.0.encode(encoder, offset + 0, depth)?;
1107            Ok(())
1108        }
1109    }
1110
1111    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1112        for PortWatchStateResponse
1113    {
1114        #[inline(always)]
1115        fn new_empty() -> Self {
1116            Self { state: fidl::new_empty!(InternalState, D) }
1117        }
1118
1119        #[inline]
1120        unsafe fn decode(
1121            &mut self,
1122            decoder: &mut fidl::encoding::Decoder<'_, D>,
1123            offset: usize,
1124            _depth: fidl::encoding::Depth,
1125        ) -> fidl::Result<()> {
1126            decoder.debug_check_bounds::<Self>(offset);
1127            // Verify that padding bytes are zero.
1128            fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
1129            Ok(())
1130        }
1131    }
1132
1133    impl BaseDeviceConfig {
1134        #[inline(always)]
1135        fn max_ordinal_present(&self) -> u64 {
1136            if let Some(_) = self.min_rx_buffer_length {
1137                return 3;
1138            }
1139            if let Some(_) = self.min_tx_buffer_length {
1140                return 2;
1141            }
1142            if let Some(_) = self.report_metadata {
1143                return 1;
1144            }
1145            0
1146        }
1147    }
1148
1149    impl fidl::encoding::ValueTypeMarker for BaseDeviceConfig {
1150        type Borrowed<'a> = &'a Self;
1151        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1152            value
1153        }
1154    }
1155
1156    unsafe impl fidl::encoding::TypeMarker for BaseDeviceConfig {
1157        type Owned = Self;
1158
1159        #[inline(always)]
1160        fn inline_align(_context: fidl::encoding::Context) -> usize {
1161            8
1162        }
1163
1164        #[inline(always)]
1165        fn inline_size(_context: fidl::encoding::Context) -> usize {
1166            16
1167        }
1168    }
1169
1170    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BaseDeviceConfig, D>
1171        for &BaseDeviceConfig
1172    {
1173        unsafe fn encode(
1174            self,
1175            encoder: &mut fidl::encoding::Encoder<'_, D>,
1176            offset: usize,
1177            mut depth: fidl::encoding::Depth,
1178        ) -> fidl::Result<()> {
1179            encoder.debug_check_bounds::<BaseDeviceConfig>(offset);
1180            // Vector header
1181            let max_ordinal: u64 = self.max_ordinal_present();
1182            encoder.write_num(max_ordinal, offset);
1183            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1184            // Calling encoder.out_of_line_offset(0) is not allowed.
1185            if max_ordinal == 0 {
1186                return Ok(());
1187            }
1188            depth.increment()?;
1189            let envelope_size = 8;
1190            let bytes_len = max_ordinal as usize * envelope_size;
1191            #[allow(unused_variables)]
1192            let offset = encoder.out_of_line_offset(bytes_len);
1193            let mut _prev_end_offset: usize = 0;
1194            if 1 > max_ordinal {
1195                return Ok(());
1196            }
1197
1198            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1199            // are envelope_size bytes.
1200            let cur_offset: usize = (1 - 1) * envelope_size;
1201
1202            // Zero reserved fields.
1203            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1204
1205            // Safety:
1206            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1207            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1208            //   envelope_size bytes, there is always sufficient room.
1209            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1210                self.report_metadata
1211                    .as_ref()
1212                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1213                encoder,
1214                offset + cur_offset,
1215                depth,
1216            )?;
1217
1218            _prev_end_offset = cur_offset + envelope_size;
1219            if 2 > max_ordinal {
1220                return Ok(());
1221            }
1222
1223            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1224            // are envelope_size bytes.
1225            let cur_offset: usize = (2 - 1) * envelope_size;
1226
1227            // Zero reserved fields.
1228            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1229
1230            // Safety:
1231            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1232            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1233            //   envelope_size bytes, there is always sufficient room.
1234            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1235                self.min_tx_buffer_length
1236                    .as_ref()
1237                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1238                encoder,
1239                offset + cur_offset,
1240                depth,
1241            )?;
1242
1243            _prev_end_offset = cur_offset + envelope_size;
1244            if 3 > max_ordinal {
1245                return Ok(());
1246            }
1247
1248            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1249            // are envelope_size bytes.
1250            let cur_offset: usize = (3 - 1) * envelope_size;
1251
1252            // Zero reserved fields.
1253            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1254
1255            // Safety:
1256            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1257            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1258            //   envelope_size bytes, there is always sufficient room.
1259            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1260                self.min_rx_buffer_length
1261                    .as_ref()
1262                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1263                encoder,
1264                offset + cur_offset,
1265                depth,
1266            )?;
1267
1268            _prev_end_offset = cur_offset + envelope_size;
1269
1270            Ok(())
1271        }
1272    }
1273
1274    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BaseDeviceConfig {
1275        #[inline(always)]
1276        fn new_empty() -> Self {
1277            Self::default()
1278        }
1279
1280        unsafe fn decode(
1281            &mut self,
1282            decoder: &mut fidl::encoding::Decoder<'_, D>,
1283            offset: usize,
1284            mut depth: fidl::encoding::Depth,
1285        ) -> fidl::Result<()> {
1286            decoder.debug_check_bounds::<Self>(offset);
1287            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1288                None => return Err(fidl::Error::NotNullable),
1289                Some(len) => len,
1290            };
1291            // Calling decoder.out_of_line_offset(0) is not allowed.
1292            if len == 0 {
1293                return Ok(());
1294            };
1295            depth.increment()?;
1296            let envelope_size = 8;
1297            let bytes_len = len * envelope_size;
1298            let offset = decoder.out_of_line_offset(bytes_len)?;
1299            // Decode the envelope for each type.
1300            let mut _next_ordinal_to_read = 0;
1301            let mut next_offset = offset;
1302            let end_offset = offset + bytes_len;
1303            _next_ordinal_to_read += 1;
1304            if next_offset >= end_offset {
1305                return Ok(());
1306            }
1307
1308            // Decode unknown envelopes for gaps in ordinals.
1309            while _next_ordinal_to_read < 1 {
1310                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1311                _next_ordinal_to_read += 1;
1312                next_offset += envelope_size;
1313            }
1314
1315            let next_out_of_line = decoder.next_out_of_line();
1316            let handles_before = decoder.remaining_handles();
1317            if let Some((inlined, num_bytes, num_handles)) =
1318                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1319            {
1320                let member_inline_size =
1321                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1322                if inlined != (member_inline_size <= 4) {
1323                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1324                }
1325                let inner_offset;
1326                let mut inner_depth = depth.clone();
1327                if inlined {
1328                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1329                    inner_offset = next_offset;
1330                } else {
1331                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1332                    inner_depth.increment()?;
1333                }
1334                let val_ref = self.report_metadata.get_or_insert_with(|| fidl::new_empty!(bool, D));
1335                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1336                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1337                {
1338                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1339                }
1340                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1341                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1342                }
1343            }
1344
1345            next_offset += envelope_size;
1346            _next_ordinal_to_read += 1;
1347            if next_offset >= end_offset {
1348                return Ok(());
1349            }
1350
1351            // Decode unknown envelopes for gaps in ordinals.
1352            while _next_ordinal_to_read < 2 {
1353                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1354                _next_ordinal_to_read += 1;
1355                next_offset += envelope_size;
1356            }
1357
1358            let next_out_of_line = decoder.next_out_of_line();
1359            let handles_before = decoder.remaining_handles();
1360            if let Some((inlined, num_bytes, num_handles)) =
1361                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1362            {
1363                let member_inline_size =
1364                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1365                if inlined != (member_inline_size <= 4) {
1366                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1367                }
1368                let inner_offset;
1369                let mut inner_depth = depth.clone();
1370                if inlined {
1371                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1372                    inner_offset = next_offset;
1373                } else {
1374                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1375                    inner_depth.increment()?;
1376                }
1377                let val_ref =
1378                    self.min_tx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1379                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1380                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1381                {
1382                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1383                }
1384                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1385                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1386                }
1387            }
1388
1389            next_offset += envelope_size;
1390            _next_ordinal_to_read += 1;
1391            if next_offset >= end_offset {
1392                return Ok(());
1393            }
1394
1395            // Decode unknown envelopes for gaps in ordinals.
1396            while _next_ordinal_to_read < 3 {
1397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1398                _next_ordinal_to_read += 1;
1399                next_offset += envelope_size;
1400            }
1401
1402            let next_out_of_line = decoder.next_out_of_line();
1403            let handles_before = decoder.remaining_handles();
1404            if let Some((inlined, num_bytes, num_handles)) =
1405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1406            {
1407                let member_inline_size =
1408                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1409                if inlined != (member_inline_size <= 4) {
1410                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1411                }
1412                let inner_offset;
1413                let mut inner_depth = depth.clone();
1414                if inlined {
1415                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1416                    inner_offset = next_offset;
1417                } else {
1418                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1419                    inner_depth.increment()?;
1420                }
1421                let val_ref =
1422                    self.min_rx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1423                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1424                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1425                {
1426                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1427                }
1428                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1429                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1430                }
1431            }
1432
1433            next_offset += envelope_size;
1434
1435            // Decode the remaining unknown envelopes.
1436            while next_offset < end_offset {
1437                _next_ordinal_to_read += 1;
1438                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1439                next_offset += envelope_size;
1440            }
1441
1442            Ok(())
1443        }
1444    }
1445
1446    impl BasePortConfig {
1447        #[inline(always)]
1448        fn max_ordinal_present(&self) -> u64 {
1449            if let Some(_) = self.port_class {
1450                return 5;
1451            }
1452            if let Some(_) = self.tx_types {
1453                return 4;
1454            }
1455            if let Some(_) = self.rx_types {
1456                return 3;
1457            }
1458            if let Some(_) = self.mtu {
1459                return 2;
1460            }
1461            if let Some(_) = self.id {
1462                return 1;
1463            }
1464            0
1465        }
1466    }
1467
1468    impl fidl::encoding::ValueTypeMarker for BasePortConfig {
1469        type Borrowed<'a> = &'a Self;
1470        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1471            value
1472        }
1473    }
1474
1475    unsafe impl fidl::encoding::TypeMarker for BasePortConfig {
1476        type Owned = Self;
1477
1478        #[inline(always)]
1479        fn inline_align(_context: fidl::encoding::Context) -> usize {
1480            8
1481        }
1482
1483        #[inline(always)]
1484        fn inline_size(_context: fidl::encoding::Context) -> usize {
1485            16
1486        }
1487    }
1488
1489    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BasePortConfig, D>
1490        for &BasePortConfig
1491    {
1492        unsafe fn encode(
1493            self,
1494            encoder: &mut fidl::encoding::Encoder<'_, D>,
1495            offset: usize,
1496            mut depth: fidl::encoding::Depth,
1497        ) -> fidl::Result<()> {
1498            encoder.debug_check_bounds::<BasePortConfig>(offset);
1499            // Vector header
1500            let max_ordinal: u64 = self.max_ordinal_present();
1501            encoder.write_num(max_ordinal, offset);
1502            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1503            // Calling encoder.out_of_line_offset(0) is not allowed.
1504            if max_ordinal == 0 {
1505                return Ok(());
1506            }
1507            depth.increment()?;
1508            let envelope_size = 8;
1509            let bytes_len = max_ordinal as usize * envelope_size;
1510            #[allow(unused_variables)]
1511            let offset = encoder.out_of_line_offset(bytes_len);
1512            let mut _prev_end_offset: usize = 0;
1513            if 1 > max_ordinal {
1514                return Ok(());
1515            }
1516
1517            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1518            // are envelope_size bytes.
1519            let cur_offset: usize = (1 - 1) * envelope_size;
1520
1521            // Zero reserved fields.
1522            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1523
1524            // Safety:
1525            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1526            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1527            //   envelope_size bytes, there is always sufficient room.
1528            fidl::encoding::encode_in_envelope_optional::<u8, D>(
1529                self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1530                encoder,
1531                offset + cur_offset,
1532                depth,
1533            )?;
1534
1535            _prev_end_offset = cur_offset + envelope_size;
1536            if 2 > max_ordinal {
1537                return Ok(());
1538            }
1539
1540            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1541            // are envelope_size bytes.
1542            let cur_offset: usize = (2 - 1) * envelope_size;
1543
1544            // Zero reserved fields.
1545            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1546
1547            // Safety:
1548            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1549            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1550            //   envelope_size bytes, there is always sufficient room.
1551            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1552                self.mtu.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1553                encoder,
1554                offset + cur_offset,
1555                depth,
1556            )?;
1557
1558            _prev_end_offset = cur_offset + envelope_size;
1559            if 3 > max_ordinal {
1560                return Ok(());
1561            }
1562
1563            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1564            // are envelope_size bytes.
1565            let cur_offset: usize = (3 - 1) * envelope_size;
1566
1567            // Zero reserved fields.
1568            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1569
1570            // Safety:
1571            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1572            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1573            //   envelope_size bytes, there is always sufficient room.
1574            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D>(
1575            self.rx_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4> as fidl::encoding::ValueTypeMarker>::borrow),
1576            encoder, offset + cur_offset, depth
1577        )?;
1578
1579            _prev_end_offset = cur_offset + envelope_size;
1580            if 4 > max_ordinal {
1581                return Ok(());
1582            }
1583
1584            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1585            // are envelope_size bytes.
1586            let cur_offset: usize = (4 - 1) * envelope_size;
1587
1588            // Zero reserved fields.
1589            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1590
1591            // Safety:
1592            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1593            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1594            //   envelope_size bytes, there is always sufficient room.
1595            fidl::encoding::encode_in_envelope_optional::<
1596                fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>,
1597                D,
1598            >(
1599                self.tx_types.as_ref().map(
1600                    <fidl::encoding::Vector<
1601                        fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1602                        4,
1603                    > as fidl::encoding::ValueTypeMarker>::borrow,
1604                ),
1605                encoder,
1606                offset + cur_offset,
1607                depth,
1608            )?;
1609
1610            _prev_end_offset = cur_offset + envelope_size;
1611            if 5 > max_ordinal {
1612                return Ok(());
1613            }
1614
1615            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1616            // are envelope_size bytes.
1617            let cur_offset: usize = (5 - 1) * envelope_size;
1618
1619            // Zero reserved fields.
1620            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1621
1622            // Safety:
1623            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1624            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1625            //   envelope_size bytes, there is always sufficient room.
1626            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::PortClass, D>(
1627            self.port_class.as_ref().map(<fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::ValueTypeMarker>::borrow),
1628            encoder, offset + cur_offset, depth
1629        )?;
1630
1631            _prev_end_offset = cur_offset + envelope_size;
1632
1633            Ok(())
1634        }
1635    }
1636
1637    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BasePortConfig {
1638        #[inline(always)]
1639        fn new_empty() -> Self {
1640            Self::default()
1641        }
1642
1643        unsafe fn decode(
1644            &mut self,
1645            decoder: &mut fidl::encoding::Decoder<'_, D>,
1646            offset: usize,
1647            mut depth: fidl::encoding::Depth,
1648        ) -> fidl::Result<()> {
1649            decoder.debug_check_bounds::<Self>(offset);
1650            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1651                None => return Err(fidl::Error::NotNullable),
1652                Some(len) => len,
1653            };
1654            // Calling decoder.out_of_line_offset(0) is not allowed.
1655            if len == 0 {
1656                return Ok(());
1657            };
1658            depth.increment()?;
1659            let envelope_size = 8;
1660            let bytes_len = len * envelope_size;
1661            let offset = decoder.out_of_line_offset(bytes_len)?;
1662            // Decode the envelope for each type.
1663            let mut _next_ordinal_to_read = 0;
1664            let mut next_offset = offset;
1665            let end_offset = offset + bytes_len;
1666            _next_ordinal_to_read += 1;
1667            if next_offset >= end_offset {
1668                return Ok(());
1669            }
1670
1671            // Decode unknown envelopes for gaps in ordinals.
1672            while _next_ordinal_to_read < 1 {
1673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1674                _next_ordinal_to_read += 1;
1675                next_offset += envelope_size;
1676            }
1677
1678            let next_out_of_line = decoder.next_out_of_line();
1679            let handles_before = decoder.remaining_handles();
1680            if let Some((inlined, num_bytes, num_handles)) =
1681                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1682            {
1683                let member_inline_size =
1684                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1685                if inlined != (member_inline_size <= 4) {
1686                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1687                }
1688                let inner_offset;
1689                let mut inner_depth = depth.clone();
1690                if inlined {
1691                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1692                    inner_offset = next_offset;
1693                } else {
1694                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1695                    inner_depth.increment()?;
1696                }
1697                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1698                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1699                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1700                {
1701                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1702                }
1703                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1704                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1705                }
1706            }
1707
1708            next_offset += envelope_size;
1709            _next_ordinal_to_read += 1;
1710            if next_offset >= end_offset {
1711                return Ok(());
1712            }
1713
1714            // Decode unknown envelopes for gaps in ordinals.
1715            while _next_ordinal_to_read < 2 {
1716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1717                _next_ordinal_to_read += 1;
1718                next_offset += envelope_size;
1719            }
1720
1721            let next_out_of_line = decoder.next_out_of_line();
1722            let handles_before = decoder.remaining_handles();
1723            if let Some((inlined, num_bytes, num_handles)) =
1724                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1725            {
1726                let member_inline_size =
1727                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1728                if inlined != (member_inline_size <= 4) {
1729                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1730                }
1731                let inner_offset;
1732                let mut inner_depth = depth.clone();
1733                if inlined {
1734                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1735                    inner_offset = next_offset;
1736                } else {
1737                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1738                    inner_depth.increment()?;
1739                }
1740                let val_ref = self.mtu.get_or_insert_with(|| fidl::new_empty!(u32, D));
1741                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1742                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1743                {
1744                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1745                }
1746                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1747                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1748                }
1749            }
1750
1751            next_offset += envelope_size;
1752            _next_ordinal_to_read += 1;
1753            if next_offset >= end_offset {
1754                return Ok(());
1755            }
1756
1757            // Decode unknown envelopes for gaps in ordinals.
1758            while _next_ordinal_to_read < 3 {
1759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1760                _next_ordinal_to_read += 1;
1761                next_offset += envelope_size;
1762            }
1763
1764            let next_out_of_line = decoder.next_out_of_line();
1765            let handles_before = decoder.remaining_handles();
1766            if let Some((inlined, num_bytes, num_handles)) =
1767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1768            {
1769                let member_inline_size = <fidl::encoding::Vector<
1770                    fidl_fuchsia_hardware_network__common::FrameType,
1771                    4,
1772                > as fidl::encoding::TypeMarker>::inline_size(
1773                    decoder.context
1774                );
1775                if inlined != (member_inline_size <= 4) {
1776                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1777                }
1778                let inner_offset;
1779                let mut inner_depth = depth.clone();
1780                if inlined {
1781                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1782                    inner_offset = next_offset;
1783                } else {
1784                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1785                    inner_depth.increment()?;
1786                }
1787                let val_ref =
1788                self.rx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D));
1789                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1791                {
1792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1793                }
1794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1796                }
1797            }
1798
1799            next_offset += envelope_size;
1800            _next_ordinal_to_read += 1;
1801            if next_offset >= end_offset {
1802                return Ok(());
1803            }
1804
1805            // Decode unknown envelopes for gaps in ordinals.
1806            while _next_ordinal_to_read < 4 {
1807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1808                _next_ordinal_to_read += 1;
1809                next_offset += envelope_size;
1810            }
1811
1812            let next_out_of_line = decoder.next_out_of_line();
1813            let handles_before = decoder.remaining_handles();
1814            if let Some((inlined, num_bytes, num_handles)) =
1815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1816            {
1817                let member_inline_size = <fidl::encoding::Vector<
1818                    fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1819                    4,
1820                > as fidl::encoding::TypeMarker>::inline_size(
1821                    decoder.context
1822                );
1823                if inlined != (member_inline_size <= 4) {
1824                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1825                }
1826                let inner_offset;
1827                let mut inner_depth = depth.clone();
1828                if inlined {
1829                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1830                    inner_offset = next_offset;
1831                } else {
1832                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1833                    inner_depth.increment()?;
1834                }
1835                let val_ref =
1836                self.tx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D));
1837                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1838                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1839                {
1840                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1841                }
1842                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1843                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1844                }
1845            }
1846
1847            next_offset += envelope_size;
1848            _next_ordinal_to_read += 1;
1849            if next_offset >= end_offset {
1850                return Ok(());
1851            }
1852
1853            // Decode unknown envelopes for gaps in ordinals.
1854            while _next_ordinal_to_read < 5 {
1855                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1856                _next_ordinal_to_read += 1;
1857                next_offset += envelope_size;
1858            }
1859
1860            let next_out_of_line = decoder.next_out_of_line();
1861            let handles_before = decoder.remaining_handles();
1862            if let Some((inlined, num_bytes, num_handles)) =
1863                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1864            {
1865                let member_inline_size = <fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1866                if inlined != (member_inline_size <= 4) {
1867                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1868                }
1869                let inner_offset;
1870                let mut inner_depth = depth.clone();
1871                if inlined {
1872                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1873                    inner_offset = next_offset;
1874                } else {
1875                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1876                    inner_depth.increment()?;
1877                }
1878                let val_ref = self.port_class.get_or_insert_with(|| {
1879                    fidl::new_empty!(fidl_fuchsia_hardware_network__common::PortClass, D)
1880                });
1881                fidl::decode!(
1882                    fidl_fuchsia_hardware_network__common::PortClass,
1883                    D,
1884                    val_ref,
1885                    decoder,
1886                    inner_offset,
1887                    inner_depth
1888                )?;
1889                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1890                {
1891                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1892                }
1893                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1894                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1895                }
1896            }
1897
1898            next_offset += envelope_size;
1899
1900            // Decode the remaining unknown envelopes.
1901            while next_offset < end_offset {
1902                _next_ordinal_to_read += 1;
1903                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1904                next_offset += envelope_size;
1905            }
1906
1907            Ok(())
1908        }
1909    }
1910
1911    impl DeviceConfig {
1912        #[inline(always)]
1913        fn max_ordinal_present(&self) -> u64 {
1914            if let Some(_) = self.blocking {
1915                return 2;
1916            }
1917            if let Some(_) = self.base {
1918                return 1;
1919            }
1920            0
1921        }
1922    }
1923
1924    impl fidl::encoding::ValueTypeMarker for DeviceConfig {
1925        type Borrowed<'a> = &'a Self;
1926        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1927            value
1928        }
1929    }
1930
1931    unsafe impl fidl::encoding::TypeMarker for DeviceConfig {
1932        type Owned = Self;
1933
1934        #[inline(always)]
1935        fn inline_align(_context: fidl::encoding::Context) -> usize {
1936            8
1937        }
1938
1939        #[inline(always)]
1940        fn inline_size(_context: fidl::encoding::Context) -> usize {
1941            16
1942        }
1943    }
1944
1945    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceConfig, D>
1946        for &DeviceConfig
1947    {
1948        unsafe fn encode(
1949            self,
1950            encoder: &mut fidl::encoding::Encoder<'_, D>,
1951            offset: usize,
1952            mut depth: fidl::encoding::Depth,
1953        ) -> fidl::Result<()> {
1954            encoder.debug_check_bounds::<DeviceConfig>(offset);
1955            // Vector header
1956            let max_ordinal: u64 = self.max_ordinal_present();
1957            encoder.write_num(max_ordinal, offset);
1958            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1959            // Calling encoder.out_of_line_offset(0) is not allowed.
1960            if max_ordinal == 0 {
1961                return Ok(());
1962            }
1963            depth.increment()?;
1964            let envelope_size = 8;
1965            let bytes_len = max_ordinal as usize * envelope_size;
1966            #[allow(unused_variables)]
1967            let offset = encoder.out_of_line_offset(bytes_len);
1968            let mut _prev_end_offset: usize = 0;
1969            if 1 > max_ordinal {
1970                return Ok(());
1971            }
1972
1973            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1974            // are envelope_size bytes.
1975            let cur_offset: usize = (1 - 1) * envelope_size;
1976
1977            // Zero reserved fields.
1978            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1979
1980            // Safety:
1981            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1982            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1983            //   envelope_size bytes, there is always sufficient room.
1984            fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
1985                self.base
1986                    .as_ref()
1987                    .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
1988                encoder,
1989                offset + cur_offset,
1990                depth,
1991            )?;
1992
1993            _prev_end_offset = cur_offset + envelope_size;
1994            if 2 > max_ordinal {
1995                return Ok(());
1996            }
1997
1998            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1999            // are envelope_size bytes.
2000            let cur_offset: usize = (2 - 1) * envelope_size;
2001
2002            // Zero reserved fields.
2003            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2004
2005            // Safety:
2006            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2007            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2008            //   envelope_size bytes, there is always sufficient room.
2009            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2010                self.blocking.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2011                encoder,
2012                offset + cur_offset,
2013                depth,
2014            )?;
2015
2016            _prev_end_offset = cur_offset + envelope_size;
2017
2018            Ok(())
2019        }
2020    }
2021
2022    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceConfig {
2023        #[inline(always)]
2024        fn new_empty() -> Self {
2025            Self::default()
2026        }
2027
2028        unsafe fn decode(
2029            &mut self,
2030            decoder: &mut fidl::encoding::Decoder<'_, D>,
2031            offset: usize,
2032            mut depth: fidl::encoding::Depth,
2033        ) -> fidl::Result<()> {
2034            decoder.debug_check_bounds::<Self>(offset);
2035            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2036                None => return Err(fidl::Error::NotNullable),
2037                Some(len) => len,
2038            };
2039            // Calling decoder.out_of_line_offset(0) is not allowed.
2040            if len == 0 {
2041                return Ok(());
2042            };
2043            depth.increment()?;
2044            let envelope_size = 8;
2045            let bytes_len = len * envelope_size;
2046            let offset = decoder.out_of_line_offset(bytes_len)?;
2047            // Decode the envelope for each type.
2048            let mut _next_ordinal_to_read = 0;
2049            let mut next_offset = offset;
2050            let end_offset = offset + bytes_len;
2051            _next_ordinal_to_read += 1;
2052            if next_offset >= end_offset {
2053                return Ok(());
2054            }
2055
2056            // Decode unknown envelopes for gaps in ordinals.
2057            while _next_ordinal_to_read < 1 {
2058                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2059                _next_ordinal_to_read += 1;
2060                next_offset += envelope_size;
2061            }
2062
2063            let next_out_of_line = decoder.next_out_of_line();
2064            let handles_before = decoder.remaining_handles();
2065            if let Some((inlined, num_bytes, num_handles)) =
2066                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2067            {
2068                let member_inline_size =
2069                    <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2070                if inlined != (member_inline_size <= 4) {
2071                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2072                }
2073                let inner_offset;
2074                let mut inner_depth = depth.clone();
2075                if inlined {
2076                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2077                    inner_offset = next_offset;
2078                } else {
2079                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2080                    inner_depth.increment()?;
2081                }
2082                let val_ref =
2083                    self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2084                fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2085                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2086                {
2087                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2088                }
2089                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2090                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2091                }
2092            }
2093
2094            next_offset += envelope_size;
2095            _next_ordinal_to_read += 1;
2096            if next_offset >= end_offset {
2097                return Ok(());
2098            }
2099
2100            // Decode unknown envelopes for gaps in ordinals.
2101            while _next_ordinal_to_read < 2 {
2102                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2103                _next_ordinal_to_read += 1;
2104                next_offset += envelope_size;
2105            }
2106
2107            let next_out_of_line = decoder.next_out_of_line();
2108            let handles_before = decoder.remaining_handles();
2109            if let Some((inlined, num_bytes, num_handles)) =
2110                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2111            {
2112                let member_inline_size =
2113                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2114                if inlined != (member_inline_size <= 4) {
2115                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2116                }
2117                let inner_offset;
2118                let mut inner_depth = depth.clone();
2119                if inlined {
2120                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2121                    inner_offset = next_offset;
2122                } else {
2123                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2124                    inner_depth.increment()?;
2125                }
2126                let val_ref = self.blocking.get_or_insert_with(|| fidl::new_empty!(bool, D));
2127                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2128                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2129                {
2130                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2131                }
2132                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2133                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2134                }
2135            }
2136
2137            next_offset += envelope_size;
2138
2139            // Decode the remaining unknown envelopes.
2140            while next_offset < end_offset {
2141                _next_ordinal_to_read += 1;
2142                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2143                next_offset += envelope_size;
2144            }
2145
2146            Ok(())
2147        }
2148    }
2149
2150    impl DevicePairConfig {
2151        #[inline(always)]
2152        fn max_ordinal_present(&self) -> u64 {
2153            if let Some(_) = self.fallible_transmit_right {
2154                return 3;
2155            }
2156            if let Some(_) = self.fallible_transmit_left {
2157                return 2;
2158            }
2159            if let Some(_) = self.base {
2160                return 1;
2161            }
2162            0
2163        }
2164    }
2165
2166    impl fidl::encoding::ValueTypeMarker for DevicePairConfig {
2167        type Borrowed<'a> = &'a Self;
2168        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2169            value
2170        }
2171    }
2172
2173    unsafe impl fidl::encoding::TypeMarker for DevicePairConfig {
2174        type Owned = Self;
2175
2176        #[inline(always)]
2177        fn inline_align(_context: fidl::encoding::Context) -> usize {
2178            8
2179        }
2180
2181        #[inline(always)]
2182        fn inline_size(_context: fidl::encoding::Context) -> usize {
2183            16
2184        }
2185    }
2186
2187    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairConfig, D>
2188        for &DevicePairConfig
2189    {
2190        unsafe fn encode(
2191            self,
2192            encoder: &mut fidl::encoding::Encoder<'_, D>,
2193            offset: usize,
2194            mut depth: fidl::encoding::Depth,
2195        ) -> fidl::Result<()> {
2196            encoder.debug_check_bounds::<DevicePairConfig>(offset);
2197            // Vector header
2198            let max_ordinal: u64 = self.max_ordinal_present();
2199            encoder.write_num(max_ordinal, offset);
2200            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2201            // Calling encoder.out_of_line_offset(0) is not allowed.
2202            if max_ordinal == 0 {
2203                return Ok(());
2204            }
2205            depth.increment()?;
2206            let envelope_size = 8;
2207            let bytes_len = max_ordinal as usize * envelope_size;
2208            #[allow(unused_variables)]
2209            let offset = encoder.out_of_line_offset(bytes_len);
2210            let mut _prev_end_offset: usize = 0;
2211            if 1 > max_ordinal {
2212                return Ok(());
2213            }
2214
2215            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2216            // are envelope_size bytes.
2217            let cur_offset: usize = (1 - 1) * envelope_size;
2218
2219            // Zero reserved fields.
2220            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2221
2222            // Safety:
2223            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2224            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2225            //   envelope_size bytes, there is always sufficient room.
2226            fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
2227                self.base
2228                    .as_ref()
2229                    .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
2230                encoder,
2231                offset + cur_offset,
2232                depth,
2233            )?;
2234
2235            _prev_end_offset = cur_offset + envelope_size;
2236            if 2 > max_ordinal {
2237                return Ok(());
2238            }
2239
2240            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2241            // are envelope_size bytes.
2242            let cur_offset: usize = (2 - 1) * envelope_size;
2243
2244            // Zero reserved fields.
2245            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2246
2247            // Safety:
2248            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2249            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2250            //   envelope_size bytes, there is always sufficient room.
2251            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2252                self.fallible_transmit_left
2253                    .as_ref()
2254                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2255                encoder,
2256                offset + cur_offset,
2257                depth,
2258            )?;
2259
2260            _prev_end_offset = cur_offset + envelope_size;
2261            if 3 > max_ordinal {
2262                return Ok(());
2263            }
2264
2265            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2266            // are envelope_size bytes.
2267            let cur_offset: usize = (3 - 1) * envelope_size;
2268
2269            // Zero reserved fields.
2270            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2271
2272            // Safety:
2273            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2274            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2275            //   envelope_size bytes, there is always sufficient room.
2276            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2277                self.fallible_transmit_right
2278                    .as_ref()
2279                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2280                encoder,
2281                offset + cur_offset,
2282                depth,
2283            )?;
2284
2285            _prev_end_offset = cur_offset + envelope_size;
2286
2287            Ok(())
2288        }
2289    }
2290
2291    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairConfig {
2292        #[inline(always)]
2293        fn new_empty() -> Self {
2294            Self::default()
2295        }
2296
2297        unsafe fn decode(
2298            &mut self,
2299            decoder: &mut fidl::encoding::Decoder<'_, D>,
2300            offset: usize,
2301            mut depth: fidl::encoding::Depth,
2302        ) -> fidl::Result<()> {
2303            decoder.debug_check_bounds::<Self>(offset);
2304            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2305                None => return Err(fidl::Error::NotNullable),
2306                Some(len) => len,
2307            };
2308            // Calling decoder.out_of_line_offset(0) is not allowed.
2309            if len == 0 {
2310                return Ok(());
2311            };
2312            depth.increment()?;
2313            let envelope_size = 8;
2314            let bytes_len = len * envelope_size;
2315            let offset = decoder.out_of_line_offset(bytes_len)?;
2316            // Decode the envelope for each type.
2317            let mut _next_ordinal_to_read = 0;
2318            let mut next_offset = offset;
2319            let end_offset = offset + bytes_len;
2320            _next_ordinal_to_read += 1;
2321            if next_offset >= end_offset {
2322                return Ok(());
2323            }
2324
2325            // Decode unknown envelopes for gaps in ordinals.
2326            while _next_ordinal_to_read < 1 {
2327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2328                _next_ordinal_to_read += 1;
2329                next_offset += envelope_size;
2330            }
2331
2332            let next_out_of_line = decoder.next_out_of_line();
2333            let handles_before = decoder.remaining_handles();
2334            if let Some((inlined, num_bytes, num_handles)) =
2335                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2336            {
2337                let member_inline_size =
2338                    <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2339                if inlined != (member_inline_size <= 4) {
2340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2341                }
2342                let inner_offset;
2343                let mut inner_depth = depth.clone();
2344                if inlined {
2345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2346                    inner_offset = next_offset;
2347                } else {
2348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2349                    inner_depth.increment()?;
2350                }
2351                let val_ref =
2352                    self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2353                fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2355                {
2356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2357                }
2358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2360                }
2361            }
2362
2363            next_offset += envelope_size;
2364            _next_ordinal_to_read += 1;
2365            if next_offset >= end_offset {
2366                return Ok(());
2367            }
2368
2369            // Decode unknown envelopes for gaps in ordinals.
2370            while _next_ordinal_to_read < 2 {
2371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2372                _next_ordinal_to_read += 1;
2373                next_offset += envelope_size;
2374            }
2375
2376            let next_out_of_line = decoder.next_out_of_line();
2377            let handles_before = decoder.remaining_handles();
2378            if let Some((inlined, num_bytes, num_handles)) =
2379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2380            {
2381                let member_inline_size =
2382                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2383                if inlined != (member_inline_size <= 4) {
2384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2385                }
2386                let inner_offset;
2387                let mut inner_depth = depth.clone();
2388                if inlined {
2389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2390                    inner_offset = next_offset;
2391                } else {
2392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2393                    inner_depth.increment()?;
2394                }
2395                let val_ref =
2396                    self.fallible_transmit_left.get_or_insert_with(|| fidl::new_empty!(bool, D));
2397                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2399                {
2400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2401                }
2402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2404                }
2405            }
2406
2407            next_offset += envelope_size;
2408            _next_ordinal_to_read += 1;
2409            if next_offset >= end_offset {
2410                return Ok(());
2411            }
2412
2413            // Decode unknown envelopes for gaps in ordinals.
2414            while _next_ordinal_to_read < 3 {
2415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2416                _next_ordinal_to_read += 1;
2417                next_offset += envelope_size;
2418            }
2419
2420            let next_out_of_line = decoder.next_out_of_line();
2421            let handles_before = decoder.remaining_handles();
2422            if let Some((inlined, num_bytes, num_handles)) =
2423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2424            {
2425                let member_inline_size =
2426                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2427                if inlined != (member_inline_size <= 4) {
2428                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2429                }
2430                let inner_offset;
2431                let mut inner_depth = depth.clone();
2432                if inlined {
2433                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2434                    inner_offset = next_offset;
2435                } else {
2436                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2437                    inner_depth.increment()?;
2438                }
2439                let val_ref =
2440                    self.fallible_transmit_right.get_or_insert_with(|| fidl::new_empty!(bool, D));
2441                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2442                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2443                {
2444                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2445                }
2446                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2447                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2448                }
2449            }
2450
2451            next_offset += envelope_size;
2452
2453            // Decode the remaining unknown envelopes.
2454            while next_offset < end_offset {
2455                _next_ordinal_to_read += 1;
2456                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2457                next_offset += envelope_size;
2458            }
2459
2460            Ok(())
2461        }
2462    }
2463
2464    impl DevicePairPortConfig {
2465        #[inline(always)]
2466        fn max_ordinal_present(&self) -> u64 {
2467            if let Some(_) = self.mac_right {
2468                return 3;
2469            }
2470            if let Some(_) = self.mac_left {
2471                return 2;
2472            }
2473            if let Some(_) = self.base {
2474                return 1;
2475            }
2476            0
2477        }
2478    }
2479
2480    impl fidl::encoding::ValueTypeMarker for DevicePairPortConfig {
2481        type Borrowed<'a> = &'a Self;
2482        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2483            value
2484        }
2485    }
2486
2487    unsafe impl fidl::encoding::TypeMarker for DevicePairPortConfig {
2488        type Owned = Self;
2489
2490        #[inline(always)]
2491        fn inline_align(_context: fidl::encoding::Context) -> usize {
2492            8
2493        }
2494
2495        #[inline(always)]
2496        fn inline_size(_context: fidl::encoding::Context) -> usize {
2497            16
2498        }
2499    }
2500
2501    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairPortConfig, D>
2502        for &DevicePairPortConfig
2503    {
2504        unsafe fn encode(
2505            self,
2506            encoder: &mut fidl::encoding::Encoder<'_, D>,
2507            offset: usize,
2508            mut depth: fidl::encoding::Depth,
2509        ) -> fidl::Result<()> {
2510            encoder.debug_check_bounds::<DevicePairPortConfig>(offset);
2511            // Vector header
2512            let max_ordinal: u64 = self.max_ordinal_present();
2513            encoder.write_num(max_ordinal, offset);
2514            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2515            // Calling encoder.out_of_line_offset(0) is not allowed.
2516            if max_ordinal == 0 {
2517                return Ok(());
2518            }
2519            depth.increment()?;
2520            let envelope_size = 8;
2521            let bytes_len = max_ordinal as usize * envelope_size;
2522            #[allow(unused_variables)]
2523            let offset = encoder.out_of_line_offset(bytes_len);
2524            let mut _prev_end_offset: usize = 0;
2525            if 1 > max_ordinal {
2526                return Ok(());
2527            }
2528
2529            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2530            // are envelope_size bytes.
2531            let cur_offset: usize = (1 - 1) * envelope_size;
2532
2533            // Zero reserved fields.
2534            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2535
2536            // Safety:
2537            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2538            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2539            //   envelope_size bytes, there is always sufficient room.
2540            fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2541                self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2542                encoder,
2543                offset + cur_offset,
2544                depth,
2545            )?;
2546
2547            _prev_end_offset = cur_offset + envelope_size;
2548            if 2 > max_ordinal {
2549                return Ok(());
2550            }
2551
2552            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2553            // are envelope_size bytes.
2554            let cur_offset: usize = (2 - 1) * envelope_size;
2555
2556            // Zero reserved fields.
2557            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2558
2559            // Safety:
2560            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2561            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2562            //   envelope_size bytes, there is always sufficient room.
2563            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2564            self.mac_left.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2565            encoder, offset + cur_offset, depth
2566        )?;
2567
2568            _prev_end_offset = cur_offset + envelope_size;
2569            if 3 > max_ordinal {
2570                return Ok(());
2571            }
2572
2573            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2574            // are envelope_size bytes.
2575            let cur_offset: usize = (3 - 1) * envelope_size;
2576
2577            // Zero reserved fields.
2578            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2579
2580            // Safety:
2581            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2582            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2583            //   envelope_size bytes, there is always sufficient room.
2584            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2585            self.mac_right.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2586            encoder, offset + cur_offset, depth
2587        )?;
2588
2589            _prev_end_offset = cur_offset + envelope_size;
2590
2591            Ok(())
2592        }
2593    }
2594
2595    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairPortConfig {
2596        #[inline(always)]
2597        fn new_empty() -> Self {
2598            Self::default()
2599        }
2600
2601        unsafe fn decode(
2602            &mut self,
2603            decoder: &mut fidl::encoding::Decoder<'_, D>,
2604            offset: usize,
2605            mut depth: fidl::encoding::Depth,
2606        ) -> fidl::Result<()> {
2607            decoder.debug_check_bounds::<Self>(offset);
2608            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2609                None => return Err(fidl::Error::NotNullable),
2610                Some(len) => len,
2611            };
2612            // Calling decoder.out_of_line_offset(0) is not allowed.
2613            if len == 0 {
2614                return Ok(());
2615            };
2616            depth.increment()?;
2617            let envelope_size = 8;
2618            let bytes_len = len * envelope_size;
2619            let offset = decoder.out_of_line_offset(bytes_len)?;
2620            // Decode the envelope for each type.
2621            let mut _next_ordinal_to_read = 0;
2622            let mut next_offset = offset;
2623            let end_offset = offset + bytes_len;
2624            _next_ordinal_to_read += 1;
2625            if next_offset >= end_offset {
2626                return Ok(());
2627            }
2628
2629            // Decode unknown envelopes for gaps in ordinals.
2630            while _next_ordinal_to_read < 1 {
2631                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2632                _next_ordinal_to_read += 1;
2633                next_offset += envelope_size;
2634            }
2635
2636            let next_out_of_line = decoder.next_out_of_line();
2637            let handles_before = decoder.remaining_handles();
2638            if let Some((inlined, num_bytes, num_handles)) =
2639                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2640            {
2641                let member_inline_size =
2642                    <BasePortConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2643                if inlined != (member_inline_size <= 4) {
2644                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2645                }
2646                let inner_offset;
2647                let mut inner_depth = depth.clone();
2648                if inlined {
2649                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2650                    inner_offset = next_offset;
2651                } else {
2652                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2653                    inner_depth.increment()?;
2654                }
2655                let val_ref = self.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2656                fidl::decode!(BasePortConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2657                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2658                {
2659                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2660                }
2661                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2662                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2663                }
2664            }
2665
2666            next_offset += envelope_size;
2667            _next_ordinal_to_read += 1;
2668            if next_offset >= end_offset {
2669                return Ok(());
2670            }
2671
2672            // Decode unknown envelopes for gaps in ordinals.
2673            while _next_ordinal_to_read < 2 {
2674                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2675                _next_ordinal_to_read += 1;
2676                next_offset += envelope_size;
2677            }
2678
2679            let next_out_of_line = decoder.next_out_of_line();
2680            let handles_before = decoder.remaining_handles();
2681            if let Some((inlined, num_bytes, num_handles)) =
2682                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2683            {
2684                let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2685                if inlined != (member_inline_size <= 4) {
2686                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2687                }
2688                let inner_offset;
2689                let mut inner_depth = depth.clone();
2690                if inlined {
2691                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2692                    inner_offset = next_offset;
2693                } else {
2694                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2695                    inner_depth.increment()?;
2696                }
2697                let val_ref = self.mac_left.get_or_insert_with(|| {
2698                    fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2699                });
2700                fidl::decode!(
2701                    fidl_fuchsia_net__common::MacAddress,
2702                    D,
2703                    val_ref,
2704                    decoder,
2705                    inner_offset,
2706                    inner_depth
2707                )?;
2708                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2709                {
2710                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2711                }
2712                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2713                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2714                }
2715            }
2716
2717            next_offset += envelope_size;
2718            _next_ordinal_to_read += 1;
2719            if next_offset >= end_offset {
2720                return Ok(());
2721            }
2722
2723            // Decode unknown envelopes for gaps in ordinals.
2724            while _next_ordinal_to_read < 3 {
2725                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2726                _next_ordinal_to_read += 1;
2727                next_offset += envelope_size;
2728            }
2729
2730            let next_out_of_line = decoder.next_out_of_line();
2731            let handles_before = decoder.remaining_handles();
2732            if let Some((inlined, num_bytes, num_handles)) =
2733                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2734            {
2735                let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2736                if inlined != (member_inline_size <= 4) {
2737                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2738                }
2739                let inner_offset;
2740                let mut inner_depth = depth.clone();
2741                if inlined {
2742                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2743                    inner_offset = next_offset;
2744                } else {
2745                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2746                    inner_depth.increment()?;
2747                }
2748                let val_ref = self.mac_right.get_or_insert_with(|| {
2749                    fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2750                });
2751                fidl::decode!(
2752                    fidl_fuchsia_net__common::MacAddress,
2753                    D,
2754                    val_ref,
2755                    decoder,
2756                    inner_offset,
2757                    inner_depth
2758                )?;
2759                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2760                {
2761                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2762                }
2763                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2764                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2765                }
2766            }
2767
2768            next_offset += envelope_size;
2769
2770            // Decode the remaining unknown envelopes.
2771            while next_offset < end_offset {
2772                _next_ordinal_to_read += 1;
2773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2774                next_offset += envelope_size;
2775            }
2776
2777            Ok(())
2778        }
2779    }
2780
2781    impl DevicePortConfig {
2782        #[inline(always)]
2783        fn max_ordinal_present(&self) -> u64 {
2784            if let Some(_) = self.mac {
2785                return 3;
2786            }
2787            if let Some(_) = self.online {
2788                return 2;
2789            }
2790            if let Some(_) = self.base {
2791                return 1;
2792            }
2793            0
2794        }
2795    }
2796
2797    impl fidl::encoding::ValueTypeMarker for DevicePortConfig {
2798        type Borrowed<'a> = &'a Self;
2799        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2800            value
2801        }
2802    }
2803
2804    unsafe impl fidl::encoding::TypeMarker for DevicePortConfig {
2805        type Owned = Self;
2806
2807        #[inline(always)]
2808        fn inline_align(_context: fidl::encoding::Context) -> usize {
2809            8
2810        }
2811
2812        #[inline(always)]
2813        fn inline_size(_context: fidl::encoding::Context) -> usize {
2814            16
2815        }
2816    }
2817
2818    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePortConfig, D>
2819        for &DevicePortConfig
2820    {
2821        unsafe fn encode(
2822            self,
2823            encoder: &mut fidl::encoding::Encoder<'_, D>,
2824            offset: usize,
2825            mut depth: fidl::encoding::Depth,
2826        ) -> fidl::Result<()> {
2827            encoder.debug_check_bounds::<DevicePortConfig>(offset);
2828            // Vector header
2829            let max_ordinal: u64 = self.max_ordinal_present();
2830            encoder.write_num(max_ordinal, offset);
2831            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2832            // Calling encoder.out_of_line_offset(0) is not allowed.
2833            if max_ordinal == 0 {
2834                return Ok(());
2835            }
2836            depth.increment()?;
2837            let envelope_size = 8;
2838            let bytes_len = max_ordinal as usize * envelope_size;
2839            #[allow(unused_variables)]
2840            let offset = encoder.out_of_line_offset(bytes_len);
2841            let mut _prev_end_offset: usize = 0;
2842            if 1 > max_ordinal {
2843                return Ok(());
2844            }
2845
2846            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2847            // are envelope_size bytes.
2848            let cur_offset: usize = (1 - 1) * envelope_size;
2849
2850            // Zero reserved fields.
2851            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2852
2853            // Safety:
2854            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2855            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2856            //   envelope_size bytes, there is always sufficient room.
2857            fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2858                self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2859                encoder,
2860                offset + cur_offset,
2861                depth,
2862            )?;
2863
2864            _prev_end_offset = cur_offset + envelope_size;
2865            if 2 > max_ordinal {
2866                return Ok(());
2867            }
2868
2869            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2870            // are envelope_size bytes.
2871            let cur_offset: usize = (2 - 1) * envelope_size;
2872
2873            // Zero reserved fields.
2874            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2875
2876            // Safety:
2877            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2878            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2879            //   envelope_size bytes, there is always sufficient room.
2880            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2881                self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2882                encoder,
2883                offset + cur_offset,
2884                depth,
2885            )?;
2886
2887            _prev_end_offset = cur_offset + envelope_size;
2888            if 3 > max_ordinal {
2889                return Ok(());
2890            }
2891
2892            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2893            // are envelope_size bytes.
2894            let cur_offset: usize = (3 - 1) * envelope_size;
2895
2896            // Zero reserved fields.
2897            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2898
2899            // Safety:
2900            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2901            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2902            //   envelope_size bytes, there is always sufficient room.
2903            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2904            self.mac.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2905            encoder, offset + cur_offset, depth
2906        )?;
2907
2908            _prev_end_offset = cur_offset + envelope_size;
2909
2910            Ok(())
2911        }
2912    }
2913
2914    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePortConfig {
2915        #[inline(always)]
2916        fn new_empty() -> Self {
2917            Self::default()
2918        }
2919
2920        unsafe fn decode(
2921            &mut self,
2922            decoder: &mut fidl::encoding::Decoder<'_, D>,
2923            offset: usize,
2924            mut depth: fidl::encoding::Depth,
2925        ) -> fidl::Result<()> {
2926            decoder.debug_check_bounds::<Self>(offset);
2927            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2928                None => return Err(fidl::Error::NotNullable),
2929                Some(len) => len,
2930            };
2931            // Calling decoder.out_of_line_offset(0) is not allowed.
2932            if len == 0 {
2933                return Ok(());
2934            };
2935            depth.increment()?;
2936            let envelope_size = 8;
2937            let bytes_len = len * envelope_size;
2938            let offset = decoder.out_of_line_offset(bytes_len)?;
2939            // Decode the envelope for each type.
2940            let mut _next_ordinal_to_read = 0;
2941            let mut next_offset = offset;
2942            let end_offset = offset + bytes_len;
2943            _next_ordinal_to_read += 1;
2944            if next_offset >= end_offset {
2945                return Ok(());
2946            }
2947
2948            // Decode unknown envelopes for gaps in ordinals.
2949            while _next_ordinal_to_read < 1 {
2950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2951                _next_ordinal_to_read += 1;
2952                next_offset += envelope_size;
2953            }
2954
2955            let next_out_of_line = decoder.next_out_of_line();
2956            let handles_before = decoder.remaining_handles();
2957            if let Some((inlined, num_bytes, num_handles)) =
2958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2959            {
2960                let member_inline_size =
2961                    <BasePortConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2962                if inlined != (member_inline_size <= 4) {
2963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2964                }
2965                let inner_offset;
2966                let mut inner_depth = depth.clone();
2967                if inlined {
2968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2969                    inner_offset = next_offset;
2970                } else {
2971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2972                    inner_depth.increment()?;
2973                }
2974                let val_ref = self.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2975                fidl::decode!(BasePortConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2976                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2977                {
2978                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2979                }
2980                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2981                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2982                }
2983            }
2984
2985            next_offset += envelope_size;
2986            _next_ordinal_to_read += 1;
2987            if next_offset >= end_offset {
2988                return Ok(());
2989            }
2990
2991            // Decode unknown envelopes for gaps in ordinals.
2992            while _next_ordinal_to_read < 2 {
2993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2994                _next_ordinal_to_read += 1;
2995                next_offset += envelope_size;
2996            }
2997
2998            let next_out_of_line = decoder.next_out_of_line();
2999            let handles_before = decoder.remaining_handles();
3000            if let Some((inlined, num_bytes, num_handles)) =
3001                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3002            {
3003                let member_inline_size =
3004                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3005                if inlined != (member_inline_size <= 4) {
3006                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3007                }
3008                let inner_offset;
3009                let mut inner_depth = depth.clone();
3010                if inlined {
3011                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3012                    inner_offset = next_offset;
3013                } else {
3014                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3015                    inner_depth.increment()?;
3016                }
3017                let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
3018                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3019                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3020                {
3021                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3022                }
3023                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3024                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3025                }
3026            }
3027
3028            next_offset += envelope_size;
3029            _next_ordinal_to_read += 1;
3030            if next_offset >= end_offset {
3031                return Ok(());
3032            }
3033
3034            // Decode unknown envelopes for gaps in ordinals.
3035            while _next_ordinal_to_read < 3 {
3036                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3037                _next_ordinal_to_read += 1;
3038                next_offset += envelope_size;
3039            }
3040
3041            let next_out_of_line = decoder.next_out_of_line();
3042            let handles_before = decoder.remaining_handles();
3043            if let Some((inlined, num_bytes, num_handles)) =
3044                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3045            {
3046                let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3047                if inlined != (member_inline_size <= 4) {
3048                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3049                }
3050                let inner_offset;
3051                let mut inner_depth = depth.clone();
3052                if inlined {
3053                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3054                    inner_offset = next_offset;
3055                } else {
3056                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3057                    inner_depth.increment()?;
3058                }
3059                let val_ref = self.mac.get_or_insert_with(|| {
3060                    fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
3061                });
3062                fidl::decode!(
3063                    fidl_fuchsia_net__common::MacAddress,
3064                    D,
3065                    val_ref,
3066                    decoder,
3067                    inner_offset,
3068                    inner_depth
3069                )?;
3070                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3071                {
3072                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3073                }
3074                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3075                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3076                }
3077            }
3078
3079            next_offset += envelope_size;
3080
3081            // Decode the remaining unknown envelopes.
3082            while next_offset < end_offset {
3083                _next_ordinal_to_read += 1;
3084                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3085                next_offset += envelope_size;
3086            }
3087
3088            Ok(())
3089        }
3090    }
3091
3092    impl Frame {
3093        #[inline(always)]
3094        fn max_ordinal_present(&self) -> u64 {
3095            if let Some(_) = self.port {
3096                return 4;
3097            }
3098            if let Some(_) = self.meta {
3099                return 3;
3100            }
3101            if let Some(_) = self.data {
3102                return 2;
3103            }
3104            if let Some(_) = self.frame_type {
3105                return 1;
3106            }
3107            0
3108        }
3109    }
3110
3111    impl fidl::encoding::ValueTypeMarker for Frame {
3112        type Borrowed<'a> = &'a Self;
3113        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3114            value
3115        }
3116    }
3117
3118    unsafe impl fidl::encoding::TypeMarker for Frame {
3119        type Owned = Self;
3120
3121        #[inline(always)]
3122        fn inline_align(_context: fidl::encoding::Context) -> usize {
3123            8
3124        }
3125
3126        #[inline(always)]
3127        fn inline_size(_context: fidl::encoding::Context) -> usize {
3128            16
3129        }
3130    }
3131
3132    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Frame, D> for &Frame {
3133        unsafe fn encode(
3134            self,
3135            encoder: &mut fidl::encoding::Encoder<'_, D>,
3136            offset: usize,
3137            mut depth: fidl::encoding::Depth,
3138        ) -> fidl::Result<()> {
3139            encoder.debug_check_bounds::<Frame>(offset);
3140            // Vector header
3141            let max_ordinal: u64 = self.max_ordinal_present();
3142            encoder.write_num(max_ordinal, offset);
3143            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3144            // Calling encoder.out_of_line_offset(0) is not allowed.
3145            if max_ordinal == 0 {
3146                return Ok(());
3147            }
3148            depth.increment()?;
3149            let envelope_size = 8;
3150            let bytes_len = max_ordinal as usize * envelope_size;
3151            #[allow(unused_variables)]
3152            let offset = encoder.out_of_line_offset(bytes_len);
3153            let mut _prev_end_offset: usize = 0;
3154            if 1 > max_ordinal {
3155                return Ok(());
3156            }
3157
3158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3159            // are envelope_size bytes.
3160            let cur_offset: usize = (1 - 1) * envelope_size;
3161
3162            // Zero reserved fields.
3163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3164
3165            // Safety:
3166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3168            //   envelope_size bytes, there is always sufficient room.
3169            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::FrameType, D>(
3170            self.frame_type.as_ref().map(<fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::ValueTypeMarker>::borrow),
3171            encoder, offset + cur_offset, depth
3172        )?;
3173
3174            _prev_end_offset = cur_offset + envelope_size;
3175            if 2 > max_ordinal {
3176                return Ok(());
3177            }
3178
3179            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3180            // are envelope_size bytes.
3181            let cur_offset: usize = (2 - 1) * envelope_size;
3182
3183            // Zero reserved fields.
3184            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3185
3186            // Safety:
3187            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3188            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3189            //   envelope_size bytes, there is always sufficient room.
3190            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16384>, D>(
3191                self.data.as_ref().map(
3192                    <fidl::encoding::Vector<u8, 16384> as fidl::encoding::ValueTypeMarker>::borrow,
3193                ),
3194                encoder,
3195                offset + cur_offset,
3196                depth,
3197            )?;
3198
3199            _prev_end_offset = cur_offset + envelope_size;
3200            if 3 > max_ordinal {
3201                return Ok(());
3202            }
3203
3204            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3205            // are envelope_size bytes.
3206            let cur_offset: usize = (3 - 1) * envelope_size;
3207
3208            // Zero reserved fields.
3209            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3210
3211            // Safety:
3212            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3213            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3214            //   envelope_size bytes, there is always sufficient room.
3215            fidl::encoding::encode_in_envelope_optional::<FrameMetadata, D>(
3216                self.meta.as_ref().map(<FrameMetadata as fidl::encoding::ValueTypeMarker>::borrow),
3217                encoder,
3218                offset + cur_offset,
3219                depth,
3220            )?;
3221
3222            _prev_end_offset = cur_offset + envelope_size;
3223            if 4 > max_ordinal {
3224                return Ok(());
3225            }
3226
3227            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3228            // are envelope_size bytes.
3229            let cur_offset: usize = (4 - 1) * envelope_size;
3230
3231            // Zero reserved fields.
3232            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3233
3234            // Safety:
3235            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3236            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3237            //   envelope_size bytes, there is always sufficient room.
3238            fidl::encoding::encode_in_envelope_optional::<u8, D>(
3239                self.port.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3240                encoder,
3241                offset + cur_offset,
3242                depth,
3243            )?;
3244
3245            _prev_end_offset = cur_offset + envelope_size;
3246
3247            Ok(())
3248        }
3249    }
3250
3251    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Frame {
3252        #[inline(always)]
3253        fn new_empty() -> Self {
3254            Self::default()
3255        }
3256
3257        unsafe fn decode(
3258            &mut self,
3259            decoder: &mut fidl::encoding::Decoder<'_, D>,
3260            offset: usize,
3261            mut depth: fidl::encoding::Depth,
3262        ) -> fidl::Result<()> {
3263            decoder.debug_check_bounds::<Self>(offset);
3264            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3265                None => return Err(fidl::Error::NotNullable),
3266                Some(len) => len,
3267            };
3268            // Calling decoder.out_of_line_offset(0) is not allowed.
3269            if len == 0 {
3270                return Ok(());
3271            };
3272            depth.increment()?;
3273            let envelope_size = 8;
3274            let bytes_len = len * envelope_size;
3275            let offset = decoder.out_of_line_offset(bytes_len)?;
3276            // Decode the envelope for each type.
3277            let mut _next_ordinal_to_read = 0;
3278            let mut next_offset = offset;
3279            let end_offset = offset + bytes_len;
3280            _next_ordinal_to_read += 1;
3281            if next_offset >= end_offset {
3282                return Ok(());
3283            }
3284
3285            // Decode unknown envelopes for gaps in ordinals.
3286            while _next_ordinal_to_read < 1 {
3287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3288                _next_ordinal_to_read += 1;
3289                next_offset += envelope_size;
3290            }
3291
3292            let next_out_of_line = decoder.next_out_of_line();
3293            let handles_before = decoder.remaining_handles();
3294            if let Some((inlined, num_bytes, num_handles)) =
3295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3296            {
3297                let member_inline_size = <fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3298                if inlined != (member_inline_size <= 4) {
3299                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3300                }
3301                let inner_offset;
3302                let mut inner_depth = depth.clone();
3303                if inlined {
3304                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3305                    inner_offset = next_offset;
3306                } else {
3307                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3308                    inner_depth.increment()?;
3309                }
3310                let val_ref = self.frame_type.get_or_insert_with(|| {
3311                    fidl::new_empty!(fidl_fuchsia_hardware_network__common::FrameType, D)
3312                });
3313                fidl::decode!(
3314                    fidl_fuchsia_hardware_network__common::FrameType,
3315                    D,
3316                    val_ref,
3317                    decoder,
3318                    inner_offset,
3319                    inner_depth
3320                )?;
3321                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3322                {
3323                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3324                }
3325                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3326                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3327                }
3328            }
3329
3330            next_offset += envelope_size;
3331            _next_ordinal_to_read += 1;
3332            if next_offset >= end_offset {
3333                return Ok(());
3334            }
3335
3336            // Decode unknown envelopes for gaps in ordinals.
3337            while _next_ordinal_to_read < 2 {
3338                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3339                _next_ordinal_to_read += 1;
3340                next_offset += envelope_size;
3341            }
3342
3343            let next_out_of_line = decoder.next_out_of_line();
3344            let handles_before = decoder.remaining_handles();
3345            if let Some((inlined, num_bytes, num_handles)) =
3346                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3347            {
3348                let member_inline_size =
3349                    <fidl::encoding::Vector<u8, 16384> as fidl::encoding::TypeMarker>::inline_size(
3350                        decoder.context,
3351                    );
3352                if inlined != (member_inline_size <= 4) {
3353                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3354                }
3355                let inner_offset;
3356                let mut inner_depth = depth.clone();
3357                if inlined {
3358                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3359                    inner_offset = next_offset;
3360                } else {
3361                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3362                    inner_depth.increment()?;
3363                }
3364                let val_ref = self
3365                    .data
3366                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16384>, D));
3367                fidl::decode!(fidl::encoding::Vector<u8, 16384>, D, val_ref, decoder, inner_offset, inner_depth)?;
3368                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3369                {
3370                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3371                }
3372                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3373                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3374                }
3375            }
3376
3377            next_offset += envelope_size;
3378            _next_ordinal_to_read += 1;
3379            if next_offset >= end_offset {
3380                return Ok(());
3381            }
3382
3383            // Decode unknown envelopes for gaps in ordinals.
3384            while _next_ordinal_to_read < 3 {
3385                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3386                _next_ordinal_to_read += 1;
3387                next_offset += envelope_size;
3388            }
3389
3390            let next_out_of_line = decoder.next_out_of_line();
3391            let handles_before = decoder.remaining_handles();
3392            if let Some((inlined, num_bytes, num_handles)) =
3393                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3394            {
3395                let member_inline_size =
3396                    <FrameMetadata as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3397                if inlined != (member_inline_size <= 4) {
3398                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3399                }
3400                let inner_offset;
3401                let mut inner_depth = depth.clone();
3402                if inlined {
3403                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3404                    inner_offset = next_offset;
3405                } else {
3406                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3407                    inner_depth.increment()?;
3408                }
3409                let val_ref = self.meta.get_or_insert_with(|| fidl::new_empty!(FrameMetadata, D));
3410                fidl::decode!(FrameMetadata, D, val_ref, decoder, inner_offset, inner_depth)?;
3411                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3412                {
3413                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3414                }
3415                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3416                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3417                }
3418            }
3419
3420            next_offset += envelope_size;
3421            _next_ordinal_to_read += 1;
3422            if next_offset >= end_offset {
3423                return Ok(());
3424            }
3425
3426            // Decode unknown envelopes for gaps in ordinals.
3427            while _next_ordinal_to_read < 4 {
3428                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3429                _next_ordinal_to_read += 1;
3430                next_offset += envelope_size;
3431            }
3432
3433            let next_out_of_line = decoder.next_out_of_line();
3434            let handles_before = decoder.remaining_handles();
3435            if let Some((inlined, num_bytes, num_handles)) =
3436                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3437            {
3438                let member_inline_size =
3439                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3440                if inlined != (member_inline_size <= 4) {
3441                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3442                }
3443                let inner_offset;
3444                let mut inner_depth = depth.clone();
3445                if inlined {
3446                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3447                    inner_offset = next_offset;
3448                } else {
3449                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3450                    inner_depth.increment()?;
3451                }
3452                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u8, D));
3453                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3454                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3455                {
3456                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3457                }
3458                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3459                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3460                }
3461            }
3462
3463            next_offset += envelope_size;
3464
3465            // Decode the remaining unknown envelopes.
3466            while next_offset < end_offset {
3467                _next_ordinal_to_read += 1;
3468                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3469                next_offset += envelope_size;
3470            }
3471
3472            Ok(())
3473        }
3474    }
3475
3476    impl InternalState {
3477        #[inline(always)]
3478        fn max_ordinal_present(&self) -> u64 {
3479            if let Some(_) = self.has_session {
3480                return 2;
3481            }
3482            if let Some(_) = self.mac {
3483                return 1;
3484            }
3485            0
3486        }
3487    }
3488
3489    impl fidl::encoding::ValueTypeMarker for InternalState {
3490        type Borrowed<'a> = &'a Self;
3491        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3492            value
3493        }
3494    }
3495
3496    unsafe impl fidl::encoding::TypeMarker for InternalState {
3497        type Owned = Self;
3498
3499        #[inline(always)]
3500        fn inline_align(_context: fidl::encoding::Context) -> usize {
3501            8
3502        }
3503
3504        #[inline(always)]
3505        fn inline_size(_context: fidl::encoding::Context) -> usize {
3506            16
3507        }
3508    }
3509
3510    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalState, D>
3511        for &InternalState
3512    {
3513        unsafe fn encode(
3514            self,
3515            encoder: &mut fidl::encoding::Encoder<'_, D>,
3516            offset: usize,
3517            mut depth: fidl::encoding::Depth,
3518        ) -> fidl::Result<()> {
3519            encoder.debug_check_bounds::<InternalState>(offset);
3520            // Vector header
3521            let max_ordinal: u64 = self.max_ordinal_present();
3522            encoder.write_num(max_ordinal, offset);
3523            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3524            // Calling encoder.out_of_line_offset(0) is not allowed.
3525            if max_ordinal == 0 {
3526                return Ok(());
3527            }
3528            depth.increment()?;
3529            let envelope_size = 8;
3530            let bytes_len = max_ordinal as usize * envelope_size;
3531            #[allow(unused_variables)]
3532            let offset = encoder.out_of_line_offset(bytes_len);
3533            let mut _prev_end_offset: usize = 0;
3534            if 1 > max_ordinal {
3535                return Ok(());
3536            }
3537
3538            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3539            // are envelope_size bytes.
3540            let cur_offset: usize = (1 - 1) * envelope_size;
3541
3542            // Zero reserved fields.
3543            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3544
3545            // Safety:
3546            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3547            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3548            //   envelope_size bytes, there is always sufficient room.
3549            fidl::encoding::encode_in_envelope_optional::<MacState, D>(
3550                self.mac.as_ref().map(<MacState as fidl::encoding::ValueTypeMarker>::borrow),
3551                encoder,
3552                offset + cur_offset,
3553                depth,
3554            )?;
3555
3556            _prev_end_offset = cur_offset + envelope_size;
3557            if 2 > max_ordinal {
3558                return Ok(());
3559            }
3560
3561            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3562            // are envelope_size bytes.
3563            let cur_offset: usize = (2 - 1) * envelope_size;
3564
3565            // Zero reserved fields.
3566            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3567
3568            // Safety:
3569            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3570            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3571            //   envelope_size bytes, there is always sufficient room.
3572            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3573                self.has_session.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3574                encoder,
3575                offset + cur_offset,
3576                depth,
3577            )?;
3578
3579            _prev_end_offset = cur_offset + envelope_size;
3580
3581            Ok(())
3582        }
3583    }
3584
3585    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalState {
3586        #[inline(always)]
3587        fn new_empty() -> Self {
3588            Self::default()
3589        }
3590
3591        unsafe fn decode(
3592            &mut self,
3593            decoder: &mut fidl::encoding::Decoder<'_, D>,
3594            offset: usize,
3595            mut depth: fidl::encoding::Depth,
3596        ) -> fidl::Result<()> {
3597            decoder.debug_check_bounds::<Self>(offset);
3598            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3599                None => return Err(fidl::Error::NotNullable),
3600                Some(len) => len,
3601            };
3602            // Calling decoder.out_of_line_offset(0) is not allowed.
3603            if len == 0 {
3604                return Ok(());
3605            };
3606            depth.increment()?;
3607            let envelope_size = 8;
3608            let bytes_len = len * envelope_size;
3609            let offset = decoder.out_of_line_offset(bytes_len)?;
3610            // Decode the envelope for each type.
3611            let mut _next_ordinal_to_read = 0;
3612            let mut next_offset = offset;
3613            let end_offset = offset + bytes_len;
3614            _next_ordinal_to_read += 1;
3615            if next_offset >= end_offset {
3616                return Ok(());
3617            }
3618
3619            // Decode unknown envelopes for gaps in ordinals.
3620            while _next_ordinal_to_read < 1 {
3621                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3622                _next_ordinal_to_read += 1;
3623                next_offset += envelope_size;
3624            }
3625
3626            let next_out_of_line = decoder.next_out_of_line();
3627            let handles_before = decoder.remaining_handles();
3628            if let Some((inlined, num_bytes, num_handles)) =
3629                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3630            {
3631                let member_inline_size =
3632                    <MacState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3633                if inlined != (member_inline_size <= 4) {
3634                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3635                }
3636                let inner_offset;
3637                let mut inner_depth = depth.clone();
3638                if inlined {
3639                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3640                    inner_offset = next_offset;
3641                } else {
3642                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3643                    inner_depth.increment()?;
3644                }
3645                let val_ref = self.mac.get_or_insert_with(|| fidl::new_empty!(MacState, D));
3646                fidl::decode!(MacState, D, val_ref, decoder, inner_offset, inner_depth)?;
3647                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3648                {
3649                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3650                }
3651                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3652                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3653                }
3654            }
3655
3656            next_offset += envelope_size;
3657            _next_ordinal_to_read += 1;
3658            if next_offset >= end_offset {
3659                return Ok(());
3660            }
3661
3662            // Decode unknown envelopes for gaps in ordinals.
3663            while _next_ordinal_to_read < 2 {
3664                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3665                _next_ordinal_to_read += 1;
3666                next_offset += envelope_size;
3667            }
3668
3669            let next_out_of_line = decoder.next_out_of_line();
3670            let handles_before = decoder.remaining_handles();
3671            if let Some((inlined, num_bytes, num_handles)) =
3672                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3673            {
3674                let member_inline_size =
3675                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3676                if inlined != (member_inline_size <= 4) {
3677                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3678                }
3679                let inner_offset;
3680                let mut inner_depth = depth.clone();
3681                if inlined {
3682                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3683                    inner_offset = next_offset;
3684                } else {
3685                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3686                    inner_depth.increment()?;
3687                }
3688                let val_ref = self.has_session.get_or_insert_with(|| fidl::new_empty!(bool, D));
3689                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3690                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3691                {
3692                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3693                }
3694                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3695                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3696                }
3697            }
3698
3699            next_offset += envelope_size;
3700
3701            // Decode the remaining unknown envelopes.
3702            while next_offset < end_offset {
3703                _next_ordinal_to_read += 1;
3704                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3705                next_offset += envelope_size;
3706            }
3707
3708            Ok(())
3709        }
3710    }
3711
3712    impl MacState {
3713        #[inline(always)]
3714        fn max_ordinal_present(&self) -> u64 {
3715            if let Some(_) = self.multicast_filters {
3716                return 2;
3717            }
3718            if let Some(_) = self.mode {
3719                return 1;
3720            }
3721            0
3722        }
3723    }
3724
3725    impl fidl::encoding::ValueTypeMarker for MacState {
3726        type Borrowed<'a> = &'a Self;
3727        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3728            value
3729        }
3730    }
3731
3732    unsafe impl fidl::encoding::TypeMarker for MacState {
3733        type Owned = Self;
3734
3735        #[inline(always)]
3736        fn inline_align(_context: fidl::encoding::Context) -> usize {
3737            8
3738        }
3739
3740        #[inline(always)]
3741        fn inline_size(_context: fidl::encoding::Context) -> usize {
3742            16
3743        }
3744    }
3745
3746    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacState, D> for &MacState {
3747        unsafe fn encode(
3748            self,
3749            encoder: &mut fidl::encoding::Encoder<'_, D>,
3750            offset: usize,
3751            mut depth: fidl::encoding::Depth,
3752        ) -> fidl::Result<()> {
3753            encoder.debug_check_bounds::<MacState>(offset);
3754            // Vector header
3755            let max_ordinal: u64 = self.max_ordinal_present();
3756            encoder.write_num(max_ordinal, offset);
3757            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3758            // Calling encoder.out_of_line_offset(0) is not allowed.
3759            if max_ordinal == 0 {
3760                return Ok(());
3761            }
3762            depth.increment()?;
3763            let envelope_size = 8;
3764            let bytes_len = max_ordinal as usize * envelope_size;
3765            #[allow(unused_variables)]
3766            let offset = encoder.out_of_line_offset(bytes_len);
3767            let mut _prev_end_offset: usize = 0;
3768            if 1 > max_ordinal {
3769                return Ok(());
3770            }
3771
3772            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3773            // are envelope_size bytes.
3774            let cur_offset: usize = (1 - 1) * envelope_size;
3775
3776            // Zero reserved fields.
3777            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3778
3779            // Safety:
3780            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3781            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3782            //   envelope_size bytes, there is always sufficient room.
3783            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::MacFilterMode, D>(
3784            self.mode.as_ref().map(<fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::ValueTypeMarker>::borrow),
3785            encoder, offset + cur_offset, depth
3786        )?;
3787
3788            _prev_end_offset = cur_offset + envelope_size;
3789            if 2 > max_ordinal {
3790                return Ok(());
3791            }
3792
3793            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3794            // are envelope_size bytes.
3795            let cur_offset: usize = (2 - 1) * envelope_size;
3796
3797            // Zero reserved fields.
3798            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3799
3800            // Safety:
3801            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3802            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3803            //   envelope_size bytes, there is always sufficient room.
3804            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D>(
3805            self.multicast_filters.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3806            encoder, offset + cur_offset, depth
3807        )?;
3808
3809            _prev_end_offset = cur_offset + envelope_size;
3810
3811            Ok(())
3812        }
3813    }
3814
3815    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacState {
3816        #[inline(always)]
3817        fn new_empty() -> Self {
3818            Self::default()
3819        }
3820
3821        unsafe fn decode(
3822            &mut self,
3823            decoder: &mut fidl::encoding::Decoder<'_, D>,
3824            offset: usize,
3825            mut depth: fidl::encoding::Depth,
3826        ) -> fidl::Result<()> {
3827            decoder.debug_check_bounds::<Self>(offset);
3828            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3829                None => return Err(fidl::Error::NotNullable),
3830                Some(len) => len,
3831            };
3832            // Calling decoder.out_of_line_offset(0) is not allowed.
3833            if len == 0 {
3834                return Ok(());
3835            };
3836            depth.increment()?;
3837            let envelope_size = 8;
3838            let bytes_len = len * envelope_size;
3839            let offset = decoder.out_of_line_offset(bytes_len)?;
3840            // Decode the envelope for each type.
3841            let mut _next_ordinal_to_read = 0;
3842            let mut next_offset = offset;
3843            let end_offset = offset + bytes_len;
3844            _next_ordinal_to_read += 1;
3845            if next_offset >= end_offset {
3846                return Ok(());
3847            }
3848
3849            // Decode unknown envelopes for gaps in ordinals.
3850            while _next_ordinal_to_read < 1 {
3851                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3852                _next_ordinal_to_read += 1;
3853                next_offset += envelope_size;
3854            }
3855
3856            let next_out_of_line = decoder.next_out_of_line();
3857            let handles_before = decoder.remaining_handles();
3858            if let Some((inlined, num_bytes, num_handles)) =
3859                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3860            {
3861                let member_inline_size = <fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3862                if inlined != (member_inline_size <= 4) {
3863                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3864                }
3865                let inner_offset;
3866                let mut inner_depth = depth.clone();
3867                if inlined {
3868                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3869                    inner_offset = next_offset;
3870                } else {
3871                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3872                    inner_depth.increment()?;
3873                }
3874                let val_ref = self.mode.get_or_insert_with(|| {
3875                    fidl::new_empty!(fidl_fuchsia_hardware_network__common::MacFilterMode, D)
3876                });
3877                fidl::decode!(
3878                    fidl_fuchsia_hardware_network__common::MacFilterMode,
3879                    D,
3880                    val_ref,
3881                    decoder,
3882                    inner_offset,
3883                    inner_depth
3884                )?;
3885                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3886                {
3887                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3888                }
3889                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3890                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3891                }
3892            }
3893
3894            next_offset += envelope_size;
3895            _next_ordinal_to_read += 1;
3896            if next_offset >= end_offset {
3897                return Ok(());
3898            }
3899
3900            // Decode unknown envelopes for gaps in ordinals.
3901            while _next_ordinal_to_read < 2 {
3902                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3903                _next_ordinal_to_read += 1;
3904                next_offset += envelope_size;
3905            }
3906
3907            let next_out_of_line = decoder.next_out_of_line();
3908            let handles_before = decoder.remaining_handles();
3909            if let Some((inlined, num_bytes, num_handles)) =
3910                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3911            {
3912                let member_inline_size = <fidl::encoding::Vector<
3913                    fidl_fuchsia_net__common::MacAddress,
3914                    64,
3915                > as fidl::encoding::TypeMarker>::inline_size(
3916                    decoder.context
3917                );
3918                if inlined != (member_inline_size <= 4) {
3919                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3920                }
3921                let inner_offset;
3922                let mut inner_depth = depth.clone();
3923                if inlined {
3924                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3925                    inner_offset = next_offset;
3926                } else {
3927                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3928                    inner_depth.increment()?;
3929                }
3930                let val_ref =
3931                self.multicast_filters.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D));
3932                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3934                {
3935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3936                }
3937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3939                }
3940            }
3941
3942            next_offset += envelope_size;
3943
3944            // Decode the remaining unknown envelopes.
3945            while next_offset < end_offset {
3946                _next_ordinal_to_read += 1;
3947                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3948                next_offset += envelope_size;
3949            }
3950
3951            Ok(())
3952        }
3953    }
3954}