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