1#![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 MissingNetworkId,
15 MissingNetworkInfo,
17 MissingNetworkDnsServers,
19 DuplicateNetworkId,
22 #[doc(hidden)]
23 __SourceBreaking { unknown_ordinal: u32 },
24}
25
26#[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 NotFound,
86 CannotRemoveDefaultNetwork,
88 #[doc(hidden)]
89 __SourceBreaking { unknown_ordinal: u32 },
90}
91
92#[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 NotFound,
146 #[doc(hidden)]
147 __SourceBreaking { unknown_ordinal: u32 },
148}
149
150#[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 MissingNetworkId,
201 MissingNetworkInfo,
203 MissingNetworkDnsServers,
205 NotFound,
207 #[doc(hidden)]
208 __SourceBreaking { unknown_ordinal: u32 },
209}
210
211#[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#[derive(Clone, Debug, Default, PartialEq)]
307pub struct DnsServerList {
308 pub addresses: Option<Vec<fidl_fuchsia_net__common::SocketAddress>>,
310 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#[derive(Clone, Debug, Default, PartialEq)]
330pub struct Network {
331 pub network_id: Option<u32>,
333 pub info: Option<NetworkInfo>,
335 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 Starnix(StarnixNetworkInfo),
367 Fuchsia(FuchsiaNetworkInfo),
369 #[doc(hidden)]
370 __SourceBreaking { unknown_ordinal: u64 },
371}
372
373#[macro_export]
375macro_rules! NetworkInfoUnknown {
376 () => {
377 _
378 };
379}
380
381impl 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 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 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 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 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 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 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 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 }
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 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 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1213
1214 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1216
1217 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 let cur_offset: usize = (2 - 1) * envelope_size;
1234
1235 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1237
1238 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 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 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 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 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 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 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 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 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 let mut _next_ordinal_to_read = 0;
1484 let mut next_offset = offset;
1485 let end_offset = offset + bytes_len;
1486
1487 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1564
1565 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1567
1568 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 let cur_offset: usize = (2 - 1) * envelope_size;
1587
1588 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1590
1591 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 let cur_offset: usize = (3 - 1) * envelope_size;
1610
1611 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1613
1614 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1869
1870 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1872
1873 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 let cur_offset: usize = (2 - 1) * envelope_size;
1890
1891 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1893
1894 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2131
2132 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2134
2135 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 let cur_offset: usize = (2 - 1) * envelope_size;
2154
2155 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2157
2158 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 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 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 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 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 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 } else {
2405 *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 } else {
2420 *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}