fidl_fuchsia_net_interfaces_common/
fidl_fuchsia_net_interfaces_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/// An interface name as a sequence of bytes.
12pub type Name = String;
13
14/// The maximum length of an interface name.
15pub const INTERFACE_NAME_LENGTH: u8 = 15;
16
17bitflags! {
18    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
19    pub struct AddressPropertiesInterest: u64 {
20        const VALID_UNTIL = 1;
21        const PREFERRED_LIFETIME_INFO = 2;
22    }
23}
24
25impl AddressPropertiesInterest {
26    #[inline(always)]
27    pub fn from_bits_allow_unknown(bits: u64) -> Self {
28        Self::from_bits_retain(bits)
29    }
30
31    #[inline(always)]
32    pub fn has_unknown_bits(&self) -> bool {
33        self.get_unknown_bits() != 0
34    }
35
36    #[inline(always)]
37    pub fn get_unknown_bits(&self) -> u64 {
38        self.bits() & !Self::all().bits()
39    }
40}
41
42/// Assignment state of an IP address.
43#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
44#[repr(u32)]
45pub enum AddressAssignmentState {
46    /// Address assignment is in progress, e.g. Duplicate Address Detection
47    /// is being performed. The address cannot be used when in this state
48    /// (cannot bind to it yet or receive packets destined to it).
49    ///
50    /// The Duplicate Address Detection mechanism is described in
51    /// [RFC 4862, section 5.4](https://tools.ietf.org/html/rfc4862#section-5.4)
52    Tentative = 1,
53    /// The address is assigned to an interface.
54    Assigned = 2,
55    /// The address is unavailable, e.g. if the interface holding the address
56    /// is offline.
57    Unavailable = 3,
58}
59
60impl AddressAssignmentState {
61    #[inline]
62    pub fn from_primitive(prim: u32) -> Option<Self> {
63        match prim {
64            1 => Some(Self::Tentative),
65            2 => Some(Self::Assigned),
66            3 => Some(Self::Unavailable),
67            _ => None,
68        }
69    }
70
71    #[inline]
72    pub const fn into_primitive(self) -> u32 {
73        self as u32
74    }
75}
76
77#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
78pub struct Empty;
79
80impl fidl::Persistable for Empty {}
81
82#[derive(Clone, Debug, PartialEq)]
83pub struct WatcherWatchResponse {
84    pub event: Event,
85}
86
87impl fidl::Persistable for WatcherWatchResponse {}
88
89#[derive(Clone, Debug, Default, PartialEq)]
90pub struct Address {
91    /// The address and prefix length.
92    ///
93    /// Required.
94    pub addr: Option<fidl_fuchsia_net::Subnet>,
95    /// The time after which the address will no longer be valid.
96    ///
97    /// Its value must be greater than 0. A value of `ZX_TIME_INFINITE`
98    /// indicates that the address will always be valid. The value is
99    /// derived from the monotonic clock.
100    ///
101    /// As a `zx.Time`, the value has
102    /// [monotonic clock semantics](https://fuchsia.dev/fuchsia-src/concepts/time/monotonic),
103    /// which implies that it has no meaning outside of the host on which it
104    /// was generated and no meaning across host restarts.
105    ///
106    /// Optional; may be omitted due to disinterest.
107    pub valid_until: Option<i64>,
108    /// Preferred lifetime information.
109    ///
110    /// Optional; may be omitted due to disinterest.
111    pub preferred_lifetime_info: Option<PreferredLifetimeInfo>,
112    /// The address's assignment state.
113    ///
114    /// Required.
115    pub assignment_state: Option<AddressAssignmentState>,
116    #[doc(hidden)]
117    pub __source_breaking: fidl::marker::SourceBreaking,
118}
119
120impl fidl::Persistable for Address {}
121
122/// Properties of a network interface.
123#[derive(Clone, Debug, Default, PartialEq)]
124pub struct Properties {
125    /// An opaque identifier for the interface. Its value will not be reused
126    /// even if the device is removed and subsequently re-added. Immutable.
127    pub id: Option<u64>,
128    /// The addresses currently installed on the interface.
129    ///
130    /// Addresses are sorted on [`Address.addr`], and no two addresses can have
131    /// the same `Address.addr` value.
132    ///
133    /// Only assigned addresses are included unless the watcher was created with
134    /// [`WatcherOptions.include_non_assigned_addresses`] set to `true`.
135    pub addresses: Option<Vec<Address>>,
136    /// The device is enabled and its physical state is online.
137    pub online: Option<bool>,
138    /// The device class of the interface. Immutable.
139    ///
140    /// # Deprecation
141    ///
142    /// Replaced by `port_class`. Scheduled for removal in 2025.
143    pub device_class: Option<DeviceClass>,
144    /// Whether there is a default IPv4 route through this interface.
145    pub has_default_ipv4_route: Option<bool>,
146    /// Whether there is a default IPv6 route through this interface.
147    pub has_default_ipv6_route: Option<bool>,
148    /// The name of the interface. Immutable.
149    pub name: Option<String>,
150    /// The port class of the interface. Immutable.
151    pub port_class: Option<PortClass>,
152    #[doc(hidden)]
153    pub __source_breaking: fidl::marker::SourceBreaking,
154}
155
156impl fidl::Persistable for Properties {}
157
158#[derive(Clone, Debug, Default, PartialEq)]
159pub struct WatcherOptions {
160    /// Bitfield for registering interest in address properties.
161    ///
162    /// Optional; interpreted as all bits set to 0 if not present.
163    pub address_properties_interest: Option<AddressPropertiesInterest>,
164    /// Flag to determine if only assigned addresses are returned (where
165    /// the assignment state is [`AddressAssignmentState::Assigned`]) or
166    /// all addresses are returned.
167    ///
168    /// Optional; interpreted as false if not present.
169    pub include_non_assigned_addresses: Option<bool>,
170    #[doc(hidden)]
171    pub __source_breaking: fidl::marker::SourceBreaking,
172}
173
174impl fidl::Persistable for WatcherOptions {}
175
176#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
177pub enum DeviceClass {
178    /// The interface is loopback.
179    Loopback(Empty),
180    Device(fidl_fuchsia_hardware_network::DeviceClass),
181}
182
183impl DeviceClass {
184    #[inline]
185    pub fn ordinal(&self) -> u64 {
186        match *self {
187            Self::Loopback(_) => 1,
188            Self::Device(_) => 2,
189        }
190    }
191}
192
193impl fidl::Persistable for DeviceClass {}
194
195#[derive(Clone, Debug, PartialEq)]
196pub enum Event {
197    /// Properties of an interface that existed when watching started.
198    ///
199    /// All interested fields and [`Properties.id`] are set.
200    Existing(Properties),
201    /// Properties of an interface that was added while watching.
202    ///
203    /// All interested fields and [`Properties.id`] are set.
204    Added(Properties),
205    /// ID of an interface that was removed while watching.
206    Removed(u64),
207    /// Properties of an interface that changed while watching.
208    ///
209    /// Only [`Properties.id`] and interested fields which have changed
210    /// are set with the new values.
211    Changed(Properties),
212    /// Sentinel value indicating no more [`existing`] events will be
213    /// sent.
214    Idle(Empty),
215}
216
217impl Event {
218    #[inline]
219    pub fn ordinal(&self) -> u64 {
220        match *self {
221            Self::Existing(_) => 1,
222            Self::Added(_) => 2,
223            Self::Removed(_) => 3,
224            Self::Changed(_) => 4,
225            Self::Idle(_) => 5,
226        }
227    }
228}
229
230impl fidl::Persistable for Event {}
231
232/// The port class of an interface.
233#[derive(Clone, Debug)]
234pub enum PortClass {
235    /// The interface is loopback.
236    Loopback(Empty),
237    /// The interface's network device port class.
238    Device(fidl_fuchsia_hardware_network::PortClass),
239    /// The interface is a blackhole interface.
240    Blackhole(Empty),
241    #[doc(hidden)]
242    __SourceBreaking { unknown_ordinal: u64 },
243}
244
245/// Pattern that matches an unknown `PortClass` member.
246#[macro_export]
247macro_rules! PortClassUnknown {
248    () => {
249        _
250    };
251}
252
253// Custom PartialEq so that unknown variants are not equal to themselves.
254impl PartialEq for PortClass {
255    fn eq(&self, other: &Self) -> bool {
256        match (self, other) {
257            (Self::Loopback(x), Self::Loopback(y)) => *x == *y,
258            (Self::Device(x), Self::Device(y)) => *x == *y,
259            (Self::Blackhole(x), Self::Blackhole(y)) => *x == *y,
260            _ => false,
261        }
262    }
263}
264
265impl PortClass {
266    #[inline]
267    pub fn ordinal(&self) -> u64 {
268        match *self {
269            Self::Loopback(_) => 1,
270            Self::Device(_) => 2,
271            Self::Blackhole(_) => 3,
272            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
273        }
274    }
275
276    #[inline]
277    pub fn unknown_variant_for_testing() -> Self {
278        Self::__SourceBreaking { unknown_ordinal: 0 }
279    }
280
281    #[inline]
282    pub fn is_unknown(&self) -> bool {
283        match self {
284            Self::__SourceBreaking { .. } => true,
285            _ => false,
286        }
287    }
288}
289
290impl fidl::Persistable for PortClass {}
291
292/// Information about the preferred lifetime of an IP address or delegated
293/// prefix.
294#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
295pub enum PreferredLifetimeInfo {
296    /// The end of the preferred lifetime.
297    ///
298    /// The address/prefix should *not* be considered deprecated if `zx.Time`
299    /// is in the past. `preferred_until` is exchanged as a means to inform
300    /// the deadline where deprecation is expected to happen.
301    ///
302    /// The preferred lifetime of addresses is defined in
303    /// [RFC 4862, section 2](https://tools.ietf.org/html/rfc4862#section-2).
304    ///
305    /// Addresses configured using a delegated prefix must have a preferred
306    /// lifetime no longer than that of the prefix according to
307    /// [RFC 8415, section 6.3](https://datatracker.ietf.org/doc/html/rfc8415#section-6.3).
308    ///
309    /// Must be greater than 0. If `zx.Time.INFINITE`, the preferred lifetime
310    /// does not expire.
311    PreferredUntil(i64),
312    /// The address/prefix is deprecated.
313    ///
314    /// Deprecated addresses should no longer be used for initiating
315    /// new connections unless explicitly requested, or if no other
316    /// non-deprecated addresses are assigned (as described in
317    /// [RFC 4862, section 1](https://tools.ietf.org/html/rfc4862#section-1)).
318    ///
319    /// Addresses configured using a deprecated delegated prefix must also be
320    /// deprecated according to
321    /// [RFC 8415, section 6.3](https://datatracker.ietf.org/doc/html/rfc8415#section-6.3).
322    ///
323    /// An address/prefix can become undeprecated if its preferred lifetime is
324    /// extended.
325    Deprecated(Empty),
326}
327
328impl PreferredLifetimeInfo {
329    #[inline]
330    pub fn ordinal(&self) -> u64 {
331        match *self {
332            Self::PreferredUntil(_) => 1,
333            Self::Deprecated(_) => 2,
334        }
335    }
336}
337
338impl fidl::Persistable for PreferredLifetimeInfo {}
339
340mod internal {
341    use super::*;
342    unsafe impl fidl::encoding::TypeMarker for AddressPropertiesInterest {
343        type Owned = Self;
344
345        #[inline(always)]
346        fn inline_align(_context: fidl::encoding::Context) -> usize {
347            8
348        }
349
350        #[inline(always)]
351        fn inline_size(_context: fidl::encoding::Context) -> usize {
352            8
353        }
354    }
355
356    impl fidl::encoding::ValueTypeMarker for AddressPropertiesInterest {
357        type Borrowed<'a> = Self;
358        #[inline(always)]
359        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
360            *value
361        }
362    }
363
364    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
365        for AddressPropertiesInterest
366    {
367        #[inline]
368        unsafe fn encode(
369            self,
370            encoder: &mut fidl::encoding::Encoder<'_, D>,
371            offset: usize,
372            _depth: fidl::encoding::Depth,
373        ) -> fidl::Result<()> {
374            encoder.debug_check_bounds::<Self>(offset);
375            encoder.write_num(self.bits(), offset);
376            Ok(())
377        }
378    }
379
380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
381        for AddressPropertiesInterest
382    {
383        #[inline(always)]
384        fn new_empty() -> Self {
385            Self::empty()
386        }
387
388        #[inline]
389        unsafe fn decode(
390            &mut self,
391            decoder: &mut fidl::encoding::Decoder<'_, D>,
392            offset: usize,
393            _depth: fidl::encoding::Depth,
394        ) -> fidl::Result<()> {
395            decoder.debug_check_bounds::<Self>(offset);
396            let prim = decoder.read_num::<u64>(offset);
397            *self = Self::from_bits_allow_unknown(prim);
398            Ok(())
399        }
400    }
401    unsafe impl fidl::encoding::TypeMarker for AddressAssignmentState {
402        type Owned = Self;
403
404        #[inline(always)]
405        fn inline_align(_context: fidl::encoding::Context) -> usize {
406            std::mem::align_of::<u32>()
407        }
408
409        #[inline(always)]
410        fn inline_size(_context: fidl::encoding::Context) -> usize {
411            std::mem::size_of::<u32>()
412        }
413
414        #[inline(always)]
415        fn encode_is_copy() -> bool {
416            true
417        }
418
419        #[inline(always)]
420        fn decode_is_copy() -> bool {
421            false
422        }
423    }
424
425    impl fidl::encoding::ValueTypeMarker for AddressAssignmentState {
426        type Borrowed<'a> = Self;
427        #[inline(always)]
428        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
429            *value
430        }
431    }
432
433    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
434        for AddressAssignmentState
435    {
436        #[inline]
437        unsafe fn encode(
438            self,
439            encoder: &mut fidl::encoding::Encoder<'_, D>,
440            offset: usize,
441            _depth: fidl::encoding::Depth,
442        ) -> fidl::Result<()> {
443            encoder.debug_check_bounds::<Self>(offset);
444            encoder.write_num(self.into_primitive(), offset);
445            Ok(())
446        }
447    }
448
449    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
450        for AddressAssignmentState
451    {
452        #[inline(always)]
453        fn new_empty() -> Self {
454            Self::Tentative
455        }
456
457        #[inline]
458        unsafe fn decode(
459            &mut self,
460            decoder: &mut fidl::encoding::Decoder<'_, D>,
461            offset: usize,
462            _depth: fidl::encoding::Depth,
463        ) -> fidl::Result<()> {
464            decoder.debug_check_bounds::<Self>(offset);
465            let prim = decoder.read_num::<u32>(offset);
466
467            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
468            Ok(())
469        }
470    }
471
472    impl fidl::encoding::ValueTypeMarker for Empty {
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 Empty {
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    }
492
493    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
494        #[inline]
495        unsafe fn encode(
496            self,
497            encoder: &mut fidl::encoding::Encoder<'_, D>,
498            offset: usize,
499            _depth: fidl::encoding::Depth,
500        ) -> fidl::Result<()> {
501            encoder.debug_check_bounds::<Empty>(offset);
502            encoder.write_num(0u8, offset);
503            Ok(())
504        }
505    }
506
507    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
508        #[inline(always)]
509        fn new_empty() -> Self {
510            Self
511        }
512
513        #[inline]
514        unsafe fn decode(
515            &mut self,
516            decoder: &mut fidl::encoding::Decoder<'_, D>,
517            offset: usize,
518            _depth: fidl::encoding::Depth,
519        ) -> fidl::Result<()> {
520            decoder.debug_check_bounds::<Self>(offset);
521            match decoder.read_num::<u8>(offset) {
522                0 => Ok(()),
523                _ => Err(fidl::Error::Invalid),
524            }
525        }
526    }
527
528    impl fidl::encoding::ValueTypeMarker for WatcherWatchResponse {
529        type Borrowed<'a> = &'a Self;
530        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
531            value
532        }
533    }
534
535    unsafe impl fidl::encoding::TypeMarker for WatcherWatchResponse {
536        type Owned = Self;
537
538        #[inline(always)]
539        fn inline_align(_context: fidl::encoding::Context) -> usize {
540            8
541        }
542
543        #[inline(always)]
544        fn inline_size(_context: fidl::encoding::Context) -> usize {
545            16
546        }
547    }
548
549    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WatcherWatchResponse, D>
550        for &WatcherWatchResponse
551    {
552        #[inline]
553        unsafe fn encode(
554            self,
555            encoder: &mut fidl::encoding::Encoder<'_, D>,
556            offset: usize,
557            _depth: fidl::encoding::Depth,
558        ) -> fidl::Result<()> {
559            encoder.debug_check_bounds::<WatcherWatchResponse>(offset);
560            // Delegate to tuple encoding.
561            fidl::encoding::Encode::<WatcherWatchResponse, D>::encode(
562                (<Event as fidl::encoding::ValueTypeMarker>::borrow(&self.event),),
563                encoder,
564                offset,
565                _depth,
566            )
567        }
568    }
569    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Event, D>>
570        fidl::encoding::Encode<WatcherWatchResponse, D> for (T0,)
571    {
572        #[inline]
573        unsafe fn encode(
574            self,
575            encoder: &mut fidl::encoding::Encoder<'_, D>,
576            offset: usize,
577            depth: fidl::encoding::Depth,
578        ) -> fidl::Result<()> {
579            encoder.debug_check_bounds::<WatcherWatchResponse>(offset);
580            // Zero out padding regions. There's no need to apply masks
581            // because the unmasked parts will be overwritten by fields.
582            // Write the fields.
583            self.0.encode(encoder, offset + 0, depth)?;
584            Ok(())
585        }
586    }
587
588    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatcherWatchResponse {
589        #[inline(always)]
590        fn new_empty() -> Self {
591            Self { event: fidl::new_empty!(Event, D) }
592        }
593
594        #[inline]
595        unsafe fn decode(
596            &mut self,
597            decoder: &mut fidl::encoding::Decoder<'_, D>,
598            offset: usize,
599            _depth: fidl::encoding::Depth,
600        ) -> fidl::Result<()> {
601            decoder.debug_check_bounds::<Self>(offset);
602            // Verify that padding bytes are zero.
603            fidl::decode!(Event, D, &mut self.event, decoder, offset + 0, _depth)?;
604            Ok(())
605        }
606    }
607
608    impl Address {
609        #[inline(always)]
610        fn max_ordinal_present(&self) -> u64 {
611            if let Some(_) = self.assignment_state {
612                return 4;
613            }
614            if let Some(_) = self.preferred_lifetime_info {
615                return 3;
616            }
617            if let Some(_) = self.valid_until {
618                return 2;
619            }
620            if let Some(_) = self.addr {
621                return 1;
622            }
623            0
624        }
625    }
626
627    impl fidl::encoding::ValueTypeMarker for Address {
628        type Borrowed<'a> = &'a Self;
629        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
630            value
631        }
632    }
633
634    unsafe impl fidl::encoding::TypeMarker for Address {
635        type Owned = Self;
636
637        #[inline(always)]
638        fn inline_align(_context: fidl::encoding::Context) -> usize {
639            8
640        }
641
642        #[inline(always)]
643        fn inline_size(_context: fidl::encoding::Context) -> usize {
644            16
645        }
646    }
647
648    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Address, D> for &Address {
649        unsafe fn encode(
650            self,
651            encoder: &mut fidl::encoding::Encoder<'_, D>,
652            offset: usize,
653            mut depth: fidl::encoding::Depth,
654        ) -> fidl::Result<()> {
655            encoder.debug_check_bounds::<Address>(offset);
656            // Vector header
657            let max_ordinal: u64 = self.max_ordinal_present();
658            encoder.write_num(max_ordinal, offset);
659            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
660            // Calling encoder.out_of_line_offset(0) is not allowed.
661            if max_ordinal == 0 {
662                return Ok(());
663            }
664            depth.increment()?;
665            let envelope_size = 8;
666            let bytes_len = max_ordinal as usize * envelope_size;
667            #[allow(unused_variables)]
668            let offset = encoder.out_of_line_offset(bytes_len);
669            let mut _prev_end_offset: usize = 0;
670            if 1 > max_ordinal {
671                return Ok(());
672            }
673
674            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
675            // are envelope_size bytes.
676            let cur_offset: usize = (1 - 1) * envelope_size;
677
678            // Zero reserved fields.
679            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
680
681            // Safety:
682            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
683            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
684            //   envelope_size bytes, there is always sufficient room.
685            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::Subnet, D>(
686                self.addr
687                    .as_ref()
688                    .map(<fidl_fuchsia_net::Subnet as fidl::encoding::ValueTypeMarker>::borrow),
689                encoder,
690                offset + cur_offset,
691                depth,
692            )?;
693
694            _prev_end_offset = cur_offset + envelope_size;
695            if 2 > max_ordinal {
696                return Ok(());
697            }
698
699            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
700            // are envelope_size bytes.
701            let cur_offset: usize = (2 - 1) * envelope_size;
702
703            // Zero reserved fields.
704            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
705
706            // Safety:
707            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
708            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
709            //   envelope_size bytes, there is always sufficient room.
710            fidl::encoding::encode_in_envelope_optional::<i64, D>(
711                self.valid_until.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
712                encoder,
713                offset + cur_offset,
714                depth,
715            )?;
716
717            _prev_end_offset = cur_offset + envelope_size;
718            if 3 > max_ordinal {
719                return Ok(());
720            }
721
722            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
723            // are envelope_size bytes.
724            let cur_offset: usize = (3 - 1) * envelope_size;
725
726            // Zero reserved fields.
727            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
728
729            // Safety:
730            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
731            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
732            //   envelope_size bytes, there is always sufficient room.
733            fidl::encoding::encode_in_envelope_optional::<PreferredLifetimeInfo, D>(
734                self.preferred_lifetime_info
735                    .as_ref()
736                    .map(<PreferredLifetimeInfo as fidl::encoding::ValueTypeMarker>::borrow),
737                encoder,
738                offset + cur_offset,
739                depth,
740            )?;
741
742            _prev_end_offset = cur_offset + envelope_size;
743            if 4 > max_ordinal {
744                return Ok(());
745            }
746
747            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
748            // are envelope_size bytes.
749            let cur_offset: usize = (4 - 1) * envelope_size;
750
751            // Zero reserved fields.
752            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
753
754            // Safety:
755            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
756            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
757            //   envelope_size bytes, there is always sufficient room.
758            fidl::encoding::encode_in_envelope_optional::<AddressAssignmentState, D>(
759                self.assignment_state
760                    .as_ref()
761                    .map(<AddressAssignmentState as fidl::encoding::ValueTypeMarker>::borrow),
762                encoder,
763                offset + cur_offset,
764                depth,
765            )?;
766
767            _prev_end_offset = cur_offset + envelope_size;
768
769            Ok(())
770        }
771    }
772
773    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Address {
774        #[inline(always)]
775        fn new_empty() -> Self {
776            Self::default()
777        }
778
779        unsafe fn decode(
780            &mut self,
781            decoder: &mut fidl::encoding::Decoder<'_, D>,
782            offset: usize,
783            mut depth: fidl::encoding::Depth,
784        ) -> fidl::Result<()> {
785            decoder.debug_check_bounds::<Self>(offset);
786            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
787                None => return Err(fidl::Error::NotNullable),
788                Some(len) => len,
789            };
790            // Calling decoder.out_of_line_offset(0) is not allowed.
791            if len == 0 {
792                return Ok(());
793            };
794            depth.increment()?;
795            let envelope_size = 8;
796            let bytes_len = len * envelope_size;
797            let offset = decoder.out_of_line_offset(bytes_len)?;
798            // Decode the envelope for each type.
799            let mut _next_ordinal_to_read = 0;
800            let mut next_offset = offset;
801            let end_offset = offset + bytes_len;
802            _next_ordinal_to_read += 1;
803            if next_offset >= end_offset {
804                return Ok(());
805            }
806
807            // Decode unknown envelopes for gaps in ordinals.
808            while _next_ordinal_to_read < 1 {
809                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
810                _next_ordinal_to_read += 1;
811                next_offset += envelope_size;
812            }
813
814            let next_out_of_line = decoder.next_out_of_line();
815            let handles_before = decoder.remaining_handles();
816            if let Some((inlined, num_bytes, num_handles)) =
817                fidl::encoding::decode_envelope_header(decoder, next_offset)?
818            {
819                let member_inline_size =
820                    <fidl_fuchsia_net::Subnet as fidl::encoding::TypeMarker>::inline_size(
821                        decoder.context,
822                    );
823                if inlined != (member_inline_size <= 4) {
824                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
825                }
826                let inner_offset;
827                let mut inner_depth = depth.clone();
828                if inlined {
829                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
830                    inner_offset = next_offset;
831                } else {
832                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
833                    inner_depth.increment()?;
834                }
835                let val_ref =
836                    self.addr.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::Subnet, D));
837                fidl::decode!(
838                    fidl_fuchsia_net::Subnet,
839                    D,
840                    val_ref,
841                    decoder,
842                    inner_offset,
843                    inner_depth
844                )?;
845                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
846                {
847                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
848                }
849                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
850                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
851                }
852            }
853
854            next_offset += envelope_size;
855            _next_ordinal_to_read += 1;
856            if next_offset >= end_offset {
857                return Ok(());
858            }
859
860            // Decode unknown envelopes for gaps in ordinals.
861            while _next_ordinal_to_read < 2 {
862                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
863                _next_ordinal_to_read += 1;
864                next_offset += envelope_size;
865            }
866
867            let next_out_of_line = decoder.next_out_of_line();
868            let handles_before = decoder.remaining_handles();
869            if let Some((inlined, num_bytes, num_handles)) =
870                fidl::encoding::decode_envelope_header(decoder, next_offset)?
871            {
872                let member_inline_size =
873                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
874                if inlined != (member_inline_size <= 4) {
875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
876                }
877                let inner_offset;
878                let mut inner_depth = depth.clone();
879                if inlined {
880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
881                    inner_offset = next_offset;
882                } else {
883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
884                    inner_depth.increment()?;
885                }
886                let val_ref = self.valid_until.get_or_insert_with(|| fidl::new_empty!(i64, D));
887                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
888                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
889                {
890                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
891                }
892                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
893                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
894                }
895            }
896
897            next_offset += envelope_size;
898            _next_ordinal_to_read += 1;
899            if next_offset >= end_offset {
900                return Ok(());
901            }
902
903            // Decode unknown envelopes for gaps in ordinals.
904            while _next_ordinal_to_read < 3 {
905                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
906                _next_ordinal_to_read += 1;
907                next_offset += envelope_size;
908            }
909
910            let next_out_of_line = decoder.next_out_of_line();
911            let handles_before = decoder.remaining_handles();
912            if let Some((inlined, num_bytes, num_handles)) =
913                fidl::encoding::decode_envelope_header(decoder, next_offset)?
914            {
915                let member_inline_size =
916                    <PreferredLifetimeInfo as fidl::encoding::TypeMarker>::inline_size(
917                        decoder.context,
918                    );
919                if inlined != (member_inline_size <= 4) {
920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
921                }
922                let inner_offset;
923                let mut inner_depth = depth.clone();
924                if inlined {
925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
926                    inner_offset = next_offset;
927                } else {
928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
929                    inner_depth.increment()?;
930                }
931                let val_ref = self
932                    .preferred_lifetime_info
933                    .get_or_insert_with(|| fidl::new_empty!(PreferredLifetimeInfo, D));
934                fidl::decode!(
935                    PreferredLifetimeInfo,
936                    D,
937                    val_ref,
938                    decoder,
939                    inner_offset,
940                    inner_depth
941                )?;
942                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
943                {
944                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
945                }
946                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
947                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
948                }
949            }
950
951            next_offset += envelope_size;
952            _next_ordinal_to_read += 1;
953            if next_offset >= end_offset {
954                return Ok(());
955            }
956
957            // Decode unknown envelopes for gaps in ordinals.
958            while _next_ordinal_to_read < 4 {
959                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
960                _next_ordinal_to_read += 1;
961                next_offset += envelope_size;
962            }
963
964            let next_out_of_line = decoder.next_out_of_line();
965            let handles_before = decoder.remaining_handles();
966            if let Some((inlined, num_bytes, num_handles)) =
967                fidl::encoding::decode_envelope_header(decoder, next_offset)?
968            {
969                let member_inline_size =
970                    <AddressAssignmentState as fidl::encoding::TypeMarker>::inline_size(
971                        decoder.context,
972                    );
973                if inlined != (member_inline_size <= 4) {
974                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
975                }
976                let inner_offset;
977                let mut inner_depth = depth.clone();
978                if inlined {
979                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
980                    inner_offset = next_offset;
981                } else {
982                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
983                    inner_depth.increment()?;
984                }
985                let val_ref = self
986                    .assignment_state
987                    .get_or_insert_with(|| fidl::new_empty!(AddressAssignmentState, D));
988                fidl::decode!(
989                    AddressAssignmentState,
990                    D,
991                    val_ref,
992                    decoder,
993                    inner_offset,
994                    inner_depth
995                )?;
996                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
997                {
998                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
999                }
1000                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1001                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1002                }
1003            }
1004
1005            next_offset += envelope_size;
1006
1007            // Decode the remaining unknown envelopes.
1008            while next_offset < end_offset {
1009                _next_ordinal_to_read += 1;
1010                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1011                next_offset += envelope_size;
1012            }
1013
1014            Ok(())
1015        }
1016    }
1017
1018    impl Properties {
1019        #[inline(always)]
1020        fn max_ordinal_present(&self) -> u64 {
1021            if let Some(_) = self.port_class {
1022                return 8;
1023            }
1024            if let Some(_) = self.name {
1025                return 7;
1026            }
1027            if let Some(_) = self.has_default_ipv6_route {
1028                return 6;
1029            }
1030            if let Some(_) = self.has_default_ipv4_route {
1031                return 5;
1032            }
1033            if let Some(_) = self.device_class {
1034                return 4;
1035            }
1036            if let Some(_) = self.online {
1037                return 3;
1038            }
1039            if let Some(_) = self.addresses {
1040                return 2;
1041            }
1042            if let Some(_) = self.id {
1043                return 1;
1044            }
1045            0
1046        }
1047    }
1048
1049    impl fidl::encoding::ValueTypeMarker for Properties {
1050        type Borrowed<'a> = &'a Self;
1051        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1052            value
1053        }
1054    }
1055
1056    unsafe impl fidl::encoding::TypeMarker for Properties {
1057        type Owned = Self;
1058
1059        #[inline(always)]
1060        fn inline_align(_context: fidl::encoding::Context) -> usize {
1061            8
1062        }
1063
1064        #[inline(always)]
1065        fn inline_size(_context: fidl::encoding::Context) -> usize {
1066            16
1067        }
1068    }
1069
1070    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Properties, D>
1071        for &Properties
1072    {
1073        unsafe fn encode(
1074            self,
1075            encoder: &mut fidl::encoding::Encoder<'_, D>,
1076            offset: usize,
1077            mut depth: fidl::encoding::Depth,
1078        ) -> fidl::Result<()> {
1079            encoder.debug_check_bounds::<Properties>(offset);
1080            // Vector header
1081            let max_ordinal: u64 = self.max_ordinal_present();
1082            encoder.write_num(max_ordinal, offset);
1083            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1084            // Calling encoder.out_of_line_offset(0) is not allowed.
1085            if max_ordinal == 0 {
1086                return Ok(());
1087            }
1088            depth.increment()?;
1089            let envelope_size = 8;
1090            let bytes_len = max_ordinal as usize * envelope_size;
1091            #[allow(unused_variables)]
1092            let offset = encoder.out_of_line_offset(bytes_len);
1093            let mut _prev_end_offset: usize = 0;
1094            if 1 > max_ordinal {
1095                return Ok(());
1096            }
1097
1098            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1099            // are envelope_size bytes.
1100            let cur_offset: usize = (1 - 1) * envelope_size;
1101
1102            // Zero reserved fields.
1103            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1104
1105            // Safety:
1106            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1107            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1108            //   envelope_size bytes, there is always sufficient room.
1109            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1110                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1111                encoder,
1112                offset + cur_offset,
1113                depth,
1114            )?;
1115
1116            _prev_end_offset = cur_offset + envelope_size;
1117            if 2 > max_ordinal {
1118                return Ok(());
1119            }
1120
1121            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1122            // are envelope_size bytes.
1123            let cur_offset: usize = (2 - 1) * envelope_size;
1124
1125            // Zero reserved fields.
1126            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1127
1128            // Safety:
1129            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1130            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1131            //   envelope_size bytes, there is always sufficient room.
1132            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Address>, D>(
1133            self.addresses.as_ref().map(<fidl::encoding::UnboundedVector<Address> as fidl::encoding::ValueTypeMarker>::borrow),
1134            encoder, offset + cur_offset, depth
1135        )?;
1136
1137            _prev_end_offset = cur_offset + envelope_size;
1138            if 3 > max_ordinal {
1139                return Ok(());
1140            }
1141
1142            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1143            // are envelope_size bytes.
1144            let cur_offset: usize = (3 - 1) * envelope_size;
1145
1146            // Zero reserved fields.
1147            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1148
1149            // Safety:
1150            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1151            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1152            //   envelope_size bytes, there is always sufficient room.
1153            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1154                self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1155                encoder,
1156                offset + cur_offset,
1157                depth,
1158            )?;
1159
1160            _prev_end_offset = cur_offset + envelope_size;
1161            if 4 > max_ordinal {
1162                return Ok(());
1163            }
1164
1165            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1166            // are envelope_size bytes.
1167            let cur_offset: usize = (4 - 1) * envelope_size;
1168
1169            // Zero reserved fields.
1170            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1171
1172            // Safety:
1173            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1174            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1175            //   envelope_size bytes, there is always sufficient room.
1176            fidl::encoding::encode_in_envelope_optional::<DeviceClass, D>(
1177                self.device_class
1178                    .as_ref()
1179                    .map(<DeviceClass as fidl::encoding::ValueTypeMarker>::borrow),
1180                encoder,
1181                offset + cur_offset,
1182                depth,
1183            )?;
1184
1185            _prev_end_offset = cur_offset + envelope_size;
1186            if 5 > max_ordinal {
1187                return Ok(());
1188            }
1189
1190            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1191            // are envelope_size bytes.
1192            let cur_offset: usize = (5 - 1) * envelope_size;
1193
1194            // Zero reserved fields.
1195            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1196
1197            // Safety:
1198            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1199            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1200            //   envelope_size bytes, there is always sufficient room.
1201            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1202                self.has_default_ipv4_route
1203                    .as_ref()
1204                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1205                encoder,
1206                offset + cur_offset,
1207                depth,
1208            )?;
1209
1210            _prev_end_offset = cur_offset + envelope_size;
1211            if 6 > max_ordinal {
1212                return Ok(());
1213            }
1214
1215            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1216            // are envelope_size bytes.
1217            let cur_offset: usize = (6 - 1) * envelope_size;
1218
1219            // Zero reserved fields.
1220            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1221
1222            // Safety:
1223            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1224            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1225            //   envelope_size bytes, there is always sufficient room.
1226            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1227                self.has_default_ipv6_route
1228                    .as_ref()
1229                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1230                encoder,
1231                offset + cur_offset,
1232                depth,
1233            )?;
1234
1235            _prev_end_offset = cur_offset + envelope_size;
1236            if 7 > max_ordinal {
1237                return Ok(());
1238            }
1239
1240            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1241            // are envelope_size bytes.
1242            let cur_offset: usize = (7 - 1) * envelope_size;
1243
1244            // Zero reserved fields.
1245            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1246
1247            // Safety:
1248            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1249            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1250            //   envelope_size bytes, there is always sufficient room.
1251            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<15>, D>(
1252                self.name.as_ref().map(
1253                    <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow,
1254                ),
1255                encoder,
1256                offset + cur_offset,
1257                depth,
1258            )?;
1259
1260            _prev_end_offset = cur_offset + envelope_size;
1261            if 8 > max_ordinal {
1262                return Ok(());
1263            }
1264
1265            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1266            // are envelope_size bytes.
1267            let cur_offset: usize = (8 - 1) * envelope_size;
1268
1269            // Zero reserved fields.
1270            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1271
1272            // Safety:
1273            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1274            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1275            //   envelope_size bytes, there is always sufficient room.
1276            fidl::encoding::encode_in_envelope_optional::<PortClass, D>(
1277                self.port_class
1278                    .as_ref()
1279                    .map(<PortClass as fidl::encoding::ValueTypeMarker>::borrow),
1280                encoder,
1281                offset + cur_offset,
1282                depth,
1283            )?;
1284
1285            _prev_end_offset = cur_offset + envelope_size;
1286
1287            Ok(())
1288        }
1289    }
1290
1291    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Properties {
1292        #[inline(always)]
1293        fn new_empty() -> Self {
1294            Self::default()
1295        }
1296
1297        unsafe fn decode(
1298            &mut self,
1299            decoder: &mut fidl::encoding::Decoder<'_, D>,
1300            offset: usize,
1301            mut depth: fidl::encoding::Depth,
1302        ) -> fidl::Result<()> {
1303            decoder.debug_check_bounds::<Self>(offset);
1304            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1305                None => return Err(fidl::Error::NotNullable),
1306                Some(len) => len,
1307            };
1308            // Calling decoder.out_of_line_offset(0) is not allowed.
1309            if len == 0 {
1310                return Ok(());
1311            };
1312            depth.increment()?;
1313            let envelope_size = 8;
1314            let bytes_len = len * envelope_size;
1315            let offset = decoder.out_of_line_offset(bytes_len)?;
1316            // Decode the envelope for each type.
1317            let mut _next_ordinal_to_read = 0;
1318            let mut next_offset = offset;
1319            let end_offset = offset + bytes_len;
1320            _next_ordinal_to_read += 1;
1321            if next_offset >= end_offset {
1322                return Ok(());
1323            }
1324
1325            // Decode unknown envelopes for gaps in ordinals.
1326            while _next_ordinal_to_read < 1 {
1327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1328                _next_ordinal_to_read += 1;
1329                next_offset += envelope_size;
1330            }
1331
1332            let next_out_of_line = decoder.next_out_of_line();
1333            let handles_before = decoder.remaining_handles();
1334            if let Some((inlined, num_bytes, num_handles)) =
1335                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1336            {
1337                let member_inline_size =
1338                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1339                if inlined != (member_inline_size <= 4) {
1340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1341                }
1342                let inner_offset;
1343                let mut inner_depth = depth.clone();
1344                if inlined {
1345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1346                    inner_offset = next_offset;
1347                } else {
1348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1349                    inner_depth.increment()?;
1350                }
1351                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1352                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1353                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1354                {
1355                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1356                }
1357                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1358                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1359                }
1360            }
1361
1362            next_offset += envelope_size;
1363            _next_ordinal_to_read += 1;
1364            if next_offset >= end_offset {
1365                return Ok(());
1366            }
1367
1368            // Decode unknown envelopes for gaps in ordinals.
1369            while _next_ordinal_to_read < 2 {
1370                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1371                _next_ordinal_to_read += 1;
1372                next_offset += envelope_size;
1373            }
1374
1375            let next_out_of_line = decoder.next_out_of_line();
1376            let handles_before = decoder.remaining_handles();
1377            if let Some((inlined, num_bytes, num_handles)) =
1378                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1379            {
1380                let member_inline_size = <fidl::encoding::UnboundedVector<Address> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1381                if inlined != (member_inline_size <= 4) {
1382                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1383                }
1384                let inner_offset;
1385                let mut inner_depth = depth.clone();
1386                if inlined {
1387                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1388                    inner_offset = next_offset;
1389                } else {
1390                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1391                    inner_depth.increment()?;
1392                }
1393                let val_ref = self.addresses.get_or_insert_with(|| {
1394                    fidl::new_empty!(fidl::encoding::UnboundedVector<Address>, D)
1395                });
1396                fidl::decode!(
1397                    fidl::encoding::UnboundedVector<Address>,
1398                    D,
1399                    val_ref,
1400                    decoder,
1401                    inner_offset,
1402                    inner_depth
1403                )?;
1404                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1405                {
1406                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1407                }
1408                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1409                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1410                }
1411            }
1412
1413            next_offset += envelope_size;
1414            _next_ordinal_to_read += 1;
1415            if next_offset >= end_offset {
1416                return Ok(());
1417            }
1418
1419            // Decode unknown envelopes for gaps in ordinals.
1420            while _next_ordinal_to_read < 3 {
1421                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1422                _next_ordinal_to_read += 1;
1423                next_offset += envelope_size;
1424            }
1425
1426            let next_out_of_line = decoder.next_out_of_line();
1427            let handles_before = decoder.remaining_handles();
1428            if let Some((inlined, num_bytes, num_handles)) =
1429                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1430            {
1431                let member_inline_size =
1432                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1433                if inlined != (member_inline_size <= 4) {
1434                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1435                }
1436                let inner_offset;
1437                let mut inner_depth = depth.clone();
1438                if inlined {
1439                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1440                    inner_offset = next_offset;
1441                } else {
1442                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1443                    inner_depth.increment()?;
1444                }
1445                let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
1446                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1447                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1448                {
1449                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1450                }
1451                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1452                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1453                }
1454            }
1455
1456            next_offset += envelope_size;
1457            _next_ordinal_to_read += 1;
1458            if next_offset >= end_offset {
1459                return Ok(());
1460            }
1461
1462            // Decode unknown envelopes for gaps in ordinals.
1463            while _next_ordinal_to_read < 4 {
1464                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1465                _next_ordinal_to_read += 1;
1466                next_offset += envelope_size;
1467            }
1468
1469            let next_out_of_line = decoder.next_out_of_line();
1470            let handles_before = decoder.remaining_handles();
1471            if let Some((inlined, num_bytes, num_handles)) =
1472                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1473            {
1474                let member_inline_size =
1475                    <DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1476                if inlined != (member_inline_size <= 4) {
1477                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1478                }
1479                let inner_offset;
1480                let mut inner_depth = depth.clone();
1481                if inlined {
1482                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1483                    inner_offset = next_offset;
1484                } else {
1485                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1486                    inner_depth.increment()?;
1487                }
1488                let val_ref =
1489                    self.device_class.get_or_insert_with(|| fidl::new_empty!(DeviceClass, D));
1490                fidl::decode!(DeviceClass, D, val_ref, decoder, inner_offset, inner_depth)?;
1491                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1492                {
1493                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1494                }
1495                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1496                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1497                }
1498            }
1499
1500            next_offset += envelope_size;
1501            _next_ordinal_to_read += 1;
1502            if next_offset >= end_offset {
1503                return Ok(());
1504            }
1505
1506            // Decode unknown envelopes for gaps in ordinals.
1507            while _next_ordinal_to_read < 5 {
1508                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1509                _next_ordinal_to_read += 1;
1510                next_offset += envelope_size;
1511            }
1512
1513            let next_out_of_line = decoder.next_out_of_line();
1514            let handles_before = decoder.remaining_handles();
1515            if let Some((inlined, num_bytes, num_handles)) =
1516                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1517            {
1518                let member_inline_size =
1519                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1520                if inlined != (member_inline_size <= 4) {
1521                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1522                }
1523                let inner_offset;
1524                let mut inner_depth = depth.clone();
1525                if inlined {
1526                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1527                    inner_offset = next_offset;
1528                } else {
1529                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1530                    inner_depth.increment()?;
1531                }
1532                let val_ref =
1533                    self.has_default_ipv4_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
1534                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1535                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1536                {
1537                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1538                }
1539                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1540                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1541                }
1542            }
1543
1544            next_offset += envelope_size;
1545            _next_ordinal_to_read += 1;
1546            if next_offset >= end_offset {
1547                return Ok(());
1548            }
1549
1550            // Decode unknown envelopes for gaps in ordinals.
1551            while _next_ordinal_to_read < 6 {
1552                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1553                _next_ordinal_to_read += 1;
1554                next_offset += envelope_size;
1555            }
1556
1557            let next_out_of_line = decoder.next_out_of_line();
1558            let handles_before = decoder.remaining_handles();
1559            if let Some((inlined, num_bytes, num_handles)) =
1560                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1561            {
1562                let member_inline_size =
1563                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1564                if inlined != (member_inline_size <= 4) {
1565                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1566                }
1567                let inner_offset;
1568                let mut inner_depth = depth.clone();
1569                if inlined {
1570                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1571                    inner_offset = next_offset;
1572                } else {
1573                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1574                    inner_depth.increment()?;
1575                }
1576                let val_ref =
1577                    self.has_default_ipv6_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
1578                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1579                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1580                {
1581                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1582                }
1583                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1584                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1585                }
1586            }
1587
1588            next_offset += envelope_size;
1589            _next_ordinal_to_read += 1;
1590            if next_offset >= end_offset {
1591                return Ok(());
1592            }
1593
1594            // Decode unknown envelopes for gaps in ordinals.
1595            while _next_ordinal_to_read < 7 {
1596                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1597                _next_ordinal_to_read += 1;
1598                next_offset += envelope_size;
1599            }
1600
1601            let next_out_of_line = decoder.next_out_of_line();
1602            let handles_before = decoder.remaining_handles();
1603            if let Some((inlined, num_bytes, num_handles)) =
1604                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1605            {
1606                let member_inline_size =
1607                    <fidl::encoding::BoundedString<15> as fidl::encoding::TypeMarker>::inline_size(
1608                        decoder.context,
1609                    );
1610                if inlined != (member_inline_size <= 4) {
1611                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1612                }
1613                let inner_offset;
1614                let mut inner_depth = depth.clone();
1615                if inlined {
1616                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1617                    inner_offset = next_offset;
1618                } else {
1619                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1620                    inner_depth.increment()?;
1621                }
1622                let val_ref = self
1623                    .name
1624                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<15>, D));
1625                fidl::decode!(
1626                    fidl::encoding::BoundedString<15>,
1627                    D,
1628                    val_ref,
1629                    decoder,
1630                    inner_offset,
1631                    inner_depth
1632                )?;
1633                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1634                {
1635                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1636                }
1637                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1638                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1639                }
1640            }
1641
1642            next_offset += envelope_size;
1643            _next_ordinal_to_read += 1;
1644            if next_offset >= end_offset {
1645                return Ok(());
1646            }
1647
1648            // Decode unknown envelopes for gaps in ordinals.
1649            while _next_ordinal_to_read < 8 {
1650                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1651                _next_ordinal_to_read += 1;
1652                next_offset += envelope_size;
1653            }
1654
1655            let next_out_of_line = decoder.next_out_of_line();
1656            let handles_before = decoder.remaining_handles();
1657            if let Some((inlined, num_bytes, num_handles)) =
1658                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1659            {
1660                let member_inline_size =
1661                    <PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1662                if inlined != (member_inline_size <= 4) {
1663                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1664                }
1665                let inner_offset;
1666                let mut inner_depth = depth.clone();
1667                if inlined {
1668                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1669                    inner_offset = next_offset;
1670                } else {
1671                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1672                    inner_depth.increment()?;
1673                }
1674                let val_ref = self.port_class.get_or_insert_with(|| fidl::new_empty!(PortClass, D));
1675                fidl::decode!(PortClass, D, val_ref, decoder, inner_offset, inner_depth)?;
1676                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1677                {
1678                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1679                }
1680                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1681                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1682                }
1683            }
1684
1685            next_offset += envelope_size;
1686
1687            // Decode the remaining unknown envelopes.
1688            while next_offset < end_offset {
1689                _next_ordinal_to_read += 1;
1690                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1691                next_offset += envelope_size;
1692            }
1693
1694            Ok(())
1695        }
1696    }
1697
1698    impl WatcherOptions {
1699        #[inline(always)]
1700        fn max_ordinal_present(&self) -> u64 {
1701            if let Some(_) = self.include_non_assigned_addresses {
1702                return 2;
1703            }
1704            if let Some(_) = self.address_properties_interest {
1705                return 1;
1706            }
1707            0
1708        }
1709    }
1710
1711    impl fidl::encoding::ValueTypeMarker for WatcherOptions {
1712        type Borrowed<'a> = &'a Self;
1713        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1714            value
1715        }
1716    }
1717
1718    unsafe impl fidl::encoding::TypeMarker for WatcherOptions {
1719        type Owned = Self;
1720
1721        #[inline(always)]
1722        fn inline_align(_context: fidl::encoding::Context) -> usize {
1723            8
1724        }
1725
1726        #[inline(always)]
1727        fn inline_size(_context: fidl::encoding::Context) -> usize {
1728            16
1729        }
1730    }
1731
1732    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WatcherOptions, D>
1733        for &WatcherOptions
1734    {
1735        unsafe fn encode(
1736            self,
1737            encoder: &mut fidl::encoding::Encoder<'_, D>,
1738            offset: usize,
1739            mut depth: fidl::encoding::Depth,
1740        ) -> fidl::Result<()> {
1741            encoder.debug_check_bounds::<WatcherOptions>(offset);
1742            // Vector header
1743            let max_ordinal: u64 = self.max_ordinal_present();
1744            encoder.write_num(max_ordinal, offset);
1745            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1746            // Calling encoder.out_of_line_offset(0) is not allowed.
1747            if max_ordinal == 0 {
1748                return Ok(());
1749            }
1750            depth.increment()?;
1751            let envelope_size = 8;
1752            let bytes_len = max_ordinal as usize * envelope_size;
1753            #[allow(unused_variables)]
1754            let offset = encoder.out_of_line_offset(bytes_len);
1755            let mut _prev_end_offset: usize = 0;
1756            if 1 > max_ordinal {
1757                return Ok(());
1758            }
1759
1760            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1761            // are envelope_size bytes.
1762            let cur_offset: usize = (1 - 1) * envelope_size;
1763
1764            // Zero reserved fields.
1765            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1766
1767            // Safety:
1768            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1769            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1770            //   envelope_size bytes, there is always sufficient room.
1771            fidl::encoding::encode_in_envelope_optional::<AddressPropertiesInterest, D>(
1772                self.address_properties_interest
1773                    .as_ref()
1774                    .map(<AddressPropertiesInterest as fidl::encoding::ValueTypeMarker>::borrow),
1775                encoder,
1776                offset + cur_offset,
1777                depth,
1778            )?;
1779
1780            _prev_end_offset = cur_offset + envelope_size;
1781            if 2 > max_ordinal {
1782                return Ok(());
1783            }
1784
1785            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1786            // are envelope_size bytes.
1787            let cur_offset: usize = (2 - 1) * envelope_size;
1788
1789            // Zero reserved fields.
1790            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1791
1792            // Safety:
1793            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1794            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1795            //   envelope_size bytes, there is always sufficient room.
1796            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1797                self.include_non_assigned_addresses
1798                    .as_ref()
1799                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1800                encoder,
1801                offset + cur_offset,
1802                depth,
1803            )?;
1804
1805            _prev_end_offset = cur_offset + envelope_size;
1806
1807            Ok(())
1808        }
1809    }
1810
1811    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatcherOptions {
1812        #[inline(always)]
1813        fn new_empty() -> Self {
1814            Self::default()
1815        }
1816
1817        unsafe fn decode(
1818            &mut self,
1819            decoder: &mut fidl::encoding::Decoder<'_, D>,
1820            offset: usize,
1821            mut depth: fidl::encoding::Depth,
1822        ) -> fidl::Result<()> {
1823            decoder.debug_check_bounds::<Self>(offset);
1824            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1825                None => return Err(fidl::Error::NotNullable),
1826                Some(len) => len,
1827            };
1828            // Calling decoder.out_of_line_offset(0) is not allowed.
1829            if len == 0 {
1830                return Ok(());
1831            };
1832            depth.increment()?;
1833            let envelope_size = 8;
1834            let bytes_len = len * envelope_size;
1835            let offset = decoder.out_of_line_offset(bytes_len)?;
1836            // Decode the envelope for each type.
1837            let mut _next_ordinal_to_read = 0;
1838            let mut next_offset = offset;
1839            let end_offset = offset + bytes_len;
1840            _next_ordinal_to_read += 1;
1841            if next_offset >= end_offset {
1842                return Ok(());
1843            }
1844
1845            // Decode unknown envelopes for gaps in ordinals.
1846            while _next_ordinal_to_read < 1 {
1847                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1848                _next_ordinal_to_read += 1;
1849                next_offset += envelope_size;
1850            }
1851
1852            let next_out_of_line = decoder.next_out_of_line();
1853            let handles_before = decoder.remaining_handles();
1854            if let Some((inlined, num_bytes, num_handles)) =
1855                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1856            {
1857                let member_inline_size =
1858                    <AddressPropertiesInterest as fidl::encoding::TypeMarker>::inline_size(
1859                        decoder.context,
1860                    );
1861                if inlined != (member_inline_size <= 4) {
1862                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1863                }
1864                let inner_offset;
1865                let mut inner_depth = depth.clone();
1866                if inlined {
1867                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1868                    inner_offset = next_offset;
1869                } else {
1870                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1871                    inner_depth.increment()?;
1872                }
1873                let val_ref = self
1874                    .address_properties_interest
1875                    .get_or_insert_with(|| fidl::new_empty!(AddressPropertiesInterest, D));
1876                fidl::decode!(
1877                    AddressPropertiesInterest,
1878                    D,
1879                    val_ref,
1880                    decoder,
1881                    inner_offset,
1882                    inner_depth
1883                )?;
1884                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1885                {
1886                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1887                }
1888                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1889                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1890                }
1891            }
1892
1893            next_offset += envelope_size;
1894            _next_ordinal_to_read += 1;
1895            if next_offset >= end_offset {
1896                return Ok(());
1897            }
1898
1899            // Decode unknown envelopes for gaps in ordinals.
1900            while _next_ordinal_to_read < 2 {
1901                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1902                _next_ordinal_to_read += 1;
1903                next_offset += envelope_size;
1904            }
1905
1906            let next_out_of_line = decoder.next_out_of_line();
1907            let handles_before = decoder.remaining_handles();
1908            if let Some((inlined, num_bytes, num_handles)) =
1909                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1910            {
1911                let member_inline_size =
1912                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1913                if inlined != (member_inline_size <= 4) {
1914                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1915                }
1916                let inner_offset;
1917                let mut inner_depth = depth.clone();
1918                if inlined {
1919                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1920                    inner_offset = next_offset;
1921                } else {
1922                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1923                    inner_depth.increment()?;
1924                }
1925                let val_ref = self
1926                    .include_non_assigned_addresses
1927                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
1928                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1929                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1930                {
1931                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1932                }
1933                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1934                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1935                }
1936            }
1937
1938            next_offset += envelope_size;
1939
1940            // Decode the remaining unknown envelopes.
1941            while next_offset < end_offset {
1942                _next_ordinal_to_read += 1;
1943                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1944                next_offset += envelope_size;
1945            }
1946
1947            Ok(())
1948        }
1949    }
1950
1951    impl fidl::encoding::ValueTypeMarker for DeviceClass {
1952        type Borrowed<'a> = &'a Self;
1953        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1954            value
1955        }
1956    }
1957
1958    unsafe impl fidl::encoding::TypeMarker for DeviceClass {
1959        type Owned = Self;
1960
1961        #[inline(always)]
1962        fn inline_align(_context: fidl::encoding::Context) -> usize {
1963            8
1964        }
1965
1966        #[inline(always)]
1967        fn inline_size(_context: fidl::encoding::Context) -> usize {
1968            16
1969        }
1970    }
1971
1972    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceClass, D>
1973        for &DeviceClass
1974    {
1975        #[inline]
1976        unsafe fn encode(
1977            self,
1978            encoder: &mut fidl::encoding::Encoder<'_, D>,
1979            offset: usize,
1980            _depth: fidl::encoding::Depth,
1981        ) -> fidl::Result<()> {
1982            encoder.debug_check_bounds::<DeviceClass>(offset);
1983            encoder.write_num::<u64>(self.ordinal(), offset);
1984            match self {
1985            DeviceClass::Loopback(ref val) => {
1986                fidl::encoding::encode_in_envelope::<Empty, D>(
1987                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
1988                    encoder, offset + 8, _depth
1989                )
1990            }
1991            DeviceClass::Device(ref val) => {
1992                fidl::encoding::encode_in_envelope::<fidl_fuchsia_hardware_network::DeviceClass, D>(
1993                    <fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::ValueTypeMarker>::borrow(val),
1994                    encoder, offset + 8, _depth
1995                )
1996            }
1997        }
1998        }
1999    }
2000
2001    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceClass {
2002        #[inline(always)]
2003        fn new_empty() -> Self {
2004            Self::Loopback(fidl::new_empty!(Empty, D))
2005        }
2006
2007        #[inline]
2008        unsafe fn decode(
2009            &mut self,
2010            decoder: &mut fidl::encoding::Decoder<'_, D>,
2011            offset: usize,
2012            mut depth: fidl::encoding::Depth,
2013        ) -> fidl::Result<()> {
2014            decoder.debug_check_bounds::<Self>(offset);
2015            #[allow(unused_variables)]
2016            let next_out_of_line = decoder.next_out_of_line();
2017            let handles_before = decoder.remaining_handles();
2018            let (ordinal, inlined, num_bytes, num_handles) =
2019                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2020
2021            let member_inline_size = match ordinal {
2022            1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2023            2 => <fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2024            _ => return Err(fidl::Error::UnknownUnionTag),
2025        };
2026
2027            if inlined != (member_inline_size <= 4) {
2028                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2029            }
2030            let _inner_offset;
2031            if inlined {
2032                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2033                _inner_offset = offset + 8;
2034            } else {
2035                depth.increment()?;
2036                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2037            }
2038            match ordinal {
2039                1 => {
2040                    #[allow(irrefutable_let_patterns)]
2041                    if let DeviceClass::Loopback(_) = self {
2042                        // Do nothing, read the value into the object
2043                    } else {
2044                        // Initialize `self` to the right variant
2045                        *self = DeviceClass::Loopback(fidl::new_empty!(Empty, D));
2046                    }
2047                    #[allow(irrefutable_let_patterns)]
2048                    if let DeviceClass::Loopback(ref mut val) = self {
2049                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2050                    } else {
2051                        unreachable!()
2052                    }
2053                }
2054                2 => {
2055                    #[allow(irrefutable_let_patterns)]
2056                    if let DeviceClass::Device(_) = self {
2057                        // Do nothing, read the value into the object
2058                    } else {
2059                        // Initialize `self` to the right variant
2060                        *self = DeviceClass::Device(fidl::new_empty!(
2061                            fidl_fuchsia_hardware_network::DeviceClass,
2062                            D
2063                        ));
2064                    }
2065                    #[allow(irrefutable_let_patterns)]
2066                    if let DeviceClass::Device(ref mut val) = self {
2067                        fidl::decode!(
2068                            fidl_fuchsia_hardware_network::DeviceClass,
2069                            D,
2070                            val,
2071                            decoder,
2072                            _inner_offset,
2073                            depth
2074                        )?;
2075                    } else {
2076                        unreachable!()
2077                    }
2078                }
2079                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2080            }
2081            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2082                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2083            }
2084            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2085                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2086            }
2087            Ok(())
2088        }
2089    }
2090
2091    impl fidl::encoding::ValueTypeMarker for Event {
2092        type Borrowed<'a> = &'a Self;
2093        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2094            value
2095        }
2096    }
2097
2098    unsafe impl fidl::encoding::TypeMarker for Event {
2099        type Owned = Self;
2100
2101        #[inline(always)]
2102        fn inline_align(_context: fidl::encoding::Context) -> usize {
2103            8
2104        }
2105
2106        #[inline(always)]
2107        fn inline_size(_context: fidl::encoding::Context) -> usize {
2108            16
2109        }
2110    }
2111
2112    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Event, D> for &Event {
2113        #[inline]
2114        unsafe fn encode(
2115            self,
2116            encoder: &mut fidl::encoding::Encoder<'_, D>,
2117            offset: usize,
2118            _depth: fidl::encoding::Depth,
2119        ) -> fidl::Result<()> {
2120            encoder.debug_check_bounds::<Event>(offset);
2121            encoder.write_num::<u64>(self.ordinal(), offset);
2122            match self {
2123                Event::Existing(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2124                    <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2125                    encoder,
2126                    offset + 8,
2127                    _depth,
2128                ),
2129                Event::Added(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2130                    <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2131                    encoder,
2132                    offset + 8,
2133                    _depth,
2134                ),
2135                Event::Removed(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
2136                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2137                    encoder,
2138                    offset + 8,
2139                    _depth,
2140                ),
2141                Event::Changed(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2142                    <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2143                    encoder,
2144                    offset + 8,
2145                    _depth,
2146                ),
2147                Event::Idle(ref val) => fidl::encoding::encode_in_envelope::<Empty, D>(
2148                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2149                    encoder,
2150                    offset + 8,
2151                    _depth,
2152                ),
2153            }
2154        }
2155    }
2156
2157    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Event {
2158        #[inline(always)]
2159        fn new_empty() -> Self {
2160            Self::Existing(fidl::new_empty!(Properties, D))
2161        }
2162
2163        #[inline]
2164        unsafe fn decode(
2165            &mut self,
2166            decoder: &mut fidl::encoding::Decoder<'_, D>,
2167            offset: usize,
2168            mut depth: fidl::encoding::Depth,
2169        ) -> fidl::Result<()> {
2170            decoder.debug_check_bounds::<Self>(offset);
2171            #[allow(unused_variables)]
2172            let next_out_of_line = decoder.next_out_of_line();
2173            let handles_before = decoder.remaining_handles();
2174            let (ordinal, inlined, num_bytes, num_handles) =
2175                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2176
2177            let member_inline_size = match ordinal {
2178                1 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2179                2 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2180                3 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2181                4 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2182                5 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2183                _ => return Err(fidl::Error::UnknownUnionTag),
2184            };
2185
2186            if inlined != (member_inline_size <= 4) {
2187                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2188            }
2189            let _inner_offset;
2190            if inlined {
2191                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2192                _inner_offset = offset + 8;
2193            } else {
2194                depth.increment()?;
2195                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2196            }
2197            match ordinal {
2198                1 => {
2199                    #[allow(irrefutable_let_patterns)]
2200                    if let Event::Existing(_) = self {
2201                        // Do nothing, read the value into the object
2202                    } else {
2203                        // Initialize `self` to the right variant
2204                        *self = Event::Existing(fidl::new_empty!(Properties, D));
2205                    }
2206                    #[allow(irrefutable_let_patterns)]
2207                    if let Event::Existing(ref mut val) = self {
2208                        fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2209                    } else {
2210                        unreachable!()
2211                    }
2212                }
2213                2 => {
2214                    #[allow(irrefutable_let_patterns)]
2215                    if let Event::Added(_) = self {
2216                        // Do nothing, read the value into the object
2217                    } else {
2218                        // Initialize `self` to the right variant
2219                        *self = Event::Added(fidl::new_empty!(Properties, D));
2220                    }
2221                    #[allow(irrefutable_let_patterns)]
2222                    if let Event::Added(ref mut val) = self {
2223                        fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2224                    } else {
2225                        unreachable!()
2226                    }
2227                }
2228                3 => {
2229                    #[allow(irrefutable_let_patterns)]
2230                    if let Event::Removed(_) = self {
2231                        // Do nothing, read the value into the object
2232                    } else {
2233                        // Initialize `self` to the right variant
2234                        *self = Event::Removed(fidl::new_empty!(u64, D));
2235                    }
2236                    #[allow(irrefutable_let_patterns)]
2237                    if let Event::Removed(ref mut val) = self {
2238                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
2239                    } else {
2240                        unreachable!()
2241                    }
2242                }
2243                4 => {
2244                    #[allow(irrefutable_let_patterns)]
2245                    if let Event::Changed(_) = self {
2246                        // Do nothing, read the value into the object
2247                    } else {
2248                        // Initialize `self` to the right variant
2249                        *self = Event::Changed(fidl::new_empty!(Properties, D));
2250                    }
2251                    #[allow(irrefutable_let_patterns)]
2252                    if let Event::Changed(ref mut val) = self {
2253                        fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2254                    } else {
2255                        unreachable!()
2256                    }
2257                }
2258                5 => {
2259                    #[allow(irrefutable_let_patterns)]
2260                    if let Event::Idle(_) = self {
2261                        // Do nothing, read the value into the object
2262                    } else {
2263                        // Initialize `self` to the right variant
2264                        *self = Event::Idle(fidl::new_empty!(Empty, D));
2265                    }
2266                    #[allow(irrefutable_let_patterns)]
2267                    if let Event::Idle(ref mut val) = self {
2268                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2269                    } else {
2270                        unreachable!()
2271                    }
2272                }
2273                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2274            }
2275            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2276                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2277            }
2278            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2279                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2280            }
2281            Ok(())
2282        }
2283    }
2284
2285    impl fidl::encoding::ValueTypeMarker for PortClass {
2286        type Borrowed<'a> = &'a Self;
2287        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2288            value
2289        }
2290    }
2291
2292    unsafe impl fidl::encoding::TypeMarker for PortClass {
2293        type Owned = Self;
2294
2295        #[inline(always)]
2296        fn inline_align(_context: fidl::encoding::Context) -> usize {
2297            8
2298        }
2299
2300        #[inline(always)]
2301        fn inline_size(_context: fidl::encoding::Context) -> usize {
2302            16
2303        }
2304    }
2305
2306    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortClass, D>
2307        for &PortClass
2308    {
2309        #[inline]
2310        unsafe fn encode(
2311            self,
2312            encoder: &mut fidl::encoding::Encoder<'_, D>,
2313            offset: usize,
2314            _depth: fidl::encoding::Depth,
2315        ) -> fidl::Result<()> {
2316            encoder.debug_check_bounds::<PortClass>(offset);
2317            encoder.write_num::<u64>(self.ordinal(), offset);
2318            match self {
2319            PortClass::Loopback(ref val) => {
2320                fidl::encoding::encode_in_envelope::<Empty, D>(
2321                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2322                    encoder, offset + 8, _depth
2323                )
2324            }
2325            PortClass::Device(ref val) => {
2326                fidl::encoding::encode_in_envelope::<fidl_fuchsia_hardware_network::PortClass, D>(
2327                    <fidl_fuchsia_hardware_network::PortClass as fidl::encoding::ValueTypeMarker>::borrow(val),
2328                    encoder, offset + 8, _depth
2329                )
2330            }
2331            PortClass::Blackhole(ref val) => {
2332                fidl::encoding::encode_in_envelope::<Empty, D>(
2333                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2334                    encoder, offset + 8, _depth
2335                )
2336            }
2337            PortClass::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
2338        }
2339        }
2340    }
2341
2342    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortClass {
2343        #[inline(always)]
2344        fn new_empty() -> Self {
2345            Self::__SourceBreaking { unknown_ordinal: 0 }
2346        }
2347
2348        #[inline]
2349        unsafe fn decode(
2350            &mut self,
2351            decoder: &mut fidl::encoding::Decoder<'_, D>,
2352            offset: usize,
2353            mut depth: fidl::encoding::Depth,
2354        ) -> fidl::Result<()> {
2355            decoder.debug_check_bounds::<Self>(offset);
2356            #[allow(unused_variables)]
2357            let next_out_of_line = decoder.next_out_of_line();
2358            let handles_before = decoder.remaining_handles();
2359            let (ordinal, inlined, num_bytes, num_handles) =
2360                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2361
2362            let member_inline_size = match ordinal {
2363            1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2364            2 => <fidl_fuchsia_hardware_network::PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2365            3 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2366            0 => return Err(fidl::Error::UnknownUnionTag),
2367            _ => num_bytes as usize,
2368        };
2369
2370            if inlined != (member_inline_size <= 4) {
2371                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2372            }
2373            let _inner_offset;
2374            if inlined {
2375                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2376                _inner_offset = offset + 8;
2377            } else {
2378                depth.increment()?;
2379                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2380            }
2381            match ordinal {
2382                1 => {
2383                    #[allow(irrefutable_let_patterns)]
2384                    if let PortClass::Loopback(_) = self {
2385                        // Do nothing, read the value into the object
2386                    } else {
2387                        // Initialize `self` to the right variant
2388                        *self = PortClass::Loopback(fidl::new_empty!(Empty, D));
2389                    }
2390                    #[allow(irrefutable_let_patterns)]
2391                    if let PortClass::Loopback(ref mut val) = self {
2392                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2393                    } else {
2394                        unreachable!()
2395                    }
2396                }
2397                2 => {
2398                    #[allow(irrefutable_let_patterns)]
2399                    if let PortClass::Device(_) = self {
2400                        // Do nothing, read the value into the object
2401                    } else {
2402                        // Initialize `self` to the right variant
2403                        *self = PortClass::Device(fidl::new_empty!(
2404                            fidl_fuchsia_hardware_network::PortClass,
2405                            D
2406                        ));
2407                    }
2408                    #[allow(irrefutable_let_patterns)]
2409                    if let PortClass::Device(ref mut val) = self {
2410                        fidl::decode!(
2411                            fidl_fuchsia_hardware_network::PortClass,
2412                            D,
2413                            val,
2414                            decoder,
2415                            _inner_offset,
2416                            depth
2417                        )?;
2418                    } else {
2419                        unreachable!()
2420                    }
2421                }
2422                3 => {
2423                    #[allow(irrefutable_let_patterns)]
2424                    if let PortClass::Blackhole(_) = self {
2425                        // Do nothing, read the value into the object
2426                    } else {
2427                        // Initialize `self` to the right variant
2428                        *self = PortClass::Blackhole(fidl::new_empty!(Empty, D));
2429                    }
2430                    #[allow(irrefutable_let_patterns)]
2431                    if let PortClass::Blackhole(ref mut val) = self {
2432                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2433                    } else {
2434                        unreachable!()
2435                    }
2436                }
2437                #[allow(deprecated)]
2438                ordinal => {
2439                    for _ in 0..num_handles {
2440                        decoder.drop_next_handle()?;
2441                    }
2442                    *self = PortClass::__SourceBreaking { unknown_ordinal: ordinal };
2443                }
2444            }
2445            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2446                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2447            }
2448            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2449                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2450            }
2451            Ok(())
2452        }
2453    }
2454
2455    impl fidl::encoding::ValueTypeMarker for PreferredLifetimeInfo {
2456        type Borrowed<'a> = &'a Self;
2457        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2458            value
2459        }
2460    }
2461
2462    unsafe impl fidl::encoding::TypeMarker for PreferredLifetimeInfo {
2463        type Owned = Self;
2464
2465        #[inline(always)]
2466        fn inline_align(_context: fidl::encoding::Context) -> usize {
2467            8
2468        }
2469
2470        #[inline(always)]
2471        fn inline_size(_context: fidl::encoding::Context) -> usize {
2472            16
2473        }
2474    }
2475
2476    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PreferredLifetimeInfo, D>
2477        for &PreferredLifetimeInfo
2478    {
2479        #[inline]
2480        unsafe fn encode(
2481            self,
2482            encoder: &mut fidl::encoding::Encoder<'_, D>,
2483            offset: usize,
2484            _depth: fidl::encoding::Depth,
2485        ) -> fidl::Result<()> {
2486            encoder.debug_check_bounds::<PreferredLifetimeInfo>(offset);
2487            encoder.write_num::<u64>(self.ordinal(), offset);
2488            match self {
2489                PreferredLifetimeInfo::PreferredUntil(ref val) => {
2490                    fidl::encoding::encode_in_envelope::<i64, D>(
2491                        <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2492                        encoder,
2493                        offset + 8,
2494                        _depth,
2495                    )
2496                }
2497                PreferredLifetimeInfo::Deprecated(ref val) => {
2498                    fidl::encoding::encode_in_envelope::<Empty, D>(
2499                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2500                        encoder,
2501                        offset + 8,
2502                        _depth,
2503                    )
2504                }
2505            }
2506        }
2507    }
2508
2509    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PreferredLifetimeInfo {
2510        #[inline(always)]
2511        fn new_empty() -> Self {
2512            Self::PreferredUntil(fidl::new_empty!(i64, D))
2513        }
2514
2515        #[inline]
2516        unsafe fn decode(
2517            &mut self,
2518            decoder: &mut fidl::encoding::Decoder<'_, D>,
2519            offset: usize,
2520            mut depth: fidl::encoding::Depth,
2521        ) -> fidl::Result<()> {
2522            decoder.debug_check_bounds::<Self>(offset);
2523            #[allow(unused_variables)]
2524            let next_out_of_line = decoder.next_out_of_line();
2525            let handles_before = decoder.remaining_handles();
2526            let (ordinal, inlined, num_bytes, num_handles) =
2527                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2528
2529            let member_inline_size = match ordinal {
2530                1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2531                2 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2532                _ => return Err(fidl::Error::UnknownUnionTag),
2533            };
2534
2535            if inlined != (member_inline_size <= 4) {
2536                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2537            }
2538            let _inner_offset;
2539            if inlined {
2540                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2541                _inner_offset = offset + 8;
2542            } else {
2543                depth.increment()?;
2544                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2545            }
2546            match ordinal {
2547                1 => {
2548                    #[allow(irrefutable_let_patterns)]
2549                    if let PreferredLifetimeInfo::PreferredUntil(_) = self {
2550                        // Do nothing, read the value into the object
2551                    } else {
2552                        // Initialize `self` to the right variant
2553                        *self = PreferredLifetimeInfo::PreferredUntil(fidl::new_empty!(i64, D));
2554                    }
2555                    #[allow(irrefutable_let_patterns)]
2556                    if let PreferredLifetimeInfo::PreferredUntil(ref mut val) = self {
2557                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2558                    } else {
2559                        unreachable!()
2560                    }
2561                }
2562                2 => {
2563                    #[allow(irrefutable_let_patterns)]
2564                    if let PreferredLifetimeInfo::Deprecated(_) = self {
2565                        // Do nothing, read the value into the object
2566                    } else {
2567                        // Initialize `self` to the right variant
2568                        *self = PreferredLifetimeInfo::Deprecated(fidl::new_empty!(Empty, D));
2569                    }
2570                    #[allow(irrefutable_let_patterns)]
2571                    if let PreferredLifetimeInfo::Deprecated(ref mut val) = self {
2572                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2573                    } else {
2574                        unreachable!()
2575                    }
2576                }
2577                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2578            }
2579            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2580                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2581            }
2582            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2583                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2584            }
2585            Ok(())
2586        }
2587    }
2588}