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