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)]
13#[repr(u32)]
14pub enum AddressRemovalReason {
15 Invalid = 1,
17 AlreadyAssigned = 2,
19 DadFailed = 3,
23 InterfaceRemoved = 4,
25 UserRemoved = 5,
27 InvalidProperties = 6,
30}
31
32impl AddressRemovalReason {
33 #[inline]
34 pub fn from_primitive(prim: u32) -> Option<Self> {
35 match prim {
36 1 => Some(Self::Invalid),
37 2 => Some(Self::AlreadyAssigned),
38 3 => Some(Self::DadFailed),
39 4 => Some(Self::InterfaceRemoved),
40 5 => Some(Self::UserRemoved),
41 6 => Some(Self::InvalidProperties),
42 _ => None,
43 }
44 }
45
46 #[inline]
47 pub const fn into_primitive(self) -> u32 {
48 self as u32
49 }
50}
51
52#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
53pub enum ControlDisableError {
54 #[doc(hidden)]
55 __SourceBreaking { unknown_ordinal: u32 },
56}
57
58#[macro_export]
60macro_rules! ControlDisableErrorUnknown {
61 () => {
62 _
63 };
64}
65
66impl ControlDisableError {
67 #[inline]
68 pub fn from_primitive(prim: u32) -> Option<Self> {
69 match prim {
70 _ => None,
71 }
72 }
73
74 #[inline]
75 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
76 match prim {
77 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
78 }
79 }
80
81 #[inline]
82 pub fn unknown() -> Self {
83 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
84 }
85
86 #[inline]
87 pub const fn into_primitive(self) -> u32 {
88 match self {
89 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
90 }
91 }
92
93 #[inline]
94 pub fn is_unknown(&self) -> bool {
95 match self {
96 Self::__SourceBreaking { unknown_ordinal: _ } => true,
97 }
98 }
99}
100
101#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
102pub enum ControlEnableError {
103 #[doc(hidden)]
104 __SourceBreaking { unknown_ordinal: u32 },
105}
106
107#[macro_export]
109macro_rules! ControlEnableErrorUnknown {
110 () => {
111 _
112 };
113}
114
115impl ControlEnableError {
116 #[inline]
117 pub fn from_primitive(prim: u32) -> Option<Self> {
118 match prim {
119 _ => None,
120 }
121 }
122
123 #[inline]
124 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
125 match prim {
126 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
127 }
128 }
129
130 #[inline]
131 pub fn unknown() -> Self {
132 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
133 }
134
135 #[inline]
136 pub const fn into_primitive(self) -> u32 {
137 match self {
138 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
139 }
140 }
141
142 #[inline]
143 pub fn is_unknown(&self) -> bool {
144 match self {
145 Self::__SourceBreaking { unknown_ordinal: _ } => true,
146 }
147 }
148}
149
150#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
151pub enum ControlGetConfigurationError {
152 #[doc(hidden)]
153 __SourceBreaking { unknown_ordinal: u32 },
154}
155
156#[macro_export]
158macro_rules! ControlGetConfigurationErrorUnknown {
159 () => {
160 _
161 };
162}
163
164impl ControlGetConfigurationError {
165 #[inline]
166 pub fn from_primitive(prim: u32) -> Option<Self> {
167 match prim {
168 _ => None,
169 }
170 }
171
172 #[inline]
173 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
174 match prim {
175 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
176 }
177 }
178
179 #[inline]
180 pub fn unknown() -> Self {
181 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
182 }
183
184 #[inline]
185 pub const fn into_primitive(self) -> u32 {
186 match self {
187 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
188 }
189 }
190
191 #[inline]
192 pub fn is_unknown(&self) -> bool {
193 match self {
194 Self::__SourceBreaking { unknown_ordinal: _ } => true,
195 }
196 }
197}
198
199#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
200pub enum ControlRemoveAddressError {
201 #[doc(hidden)]
202 __SourceBreaking { unknown_ordinal: u32 },
203}
204
205#[macro_export]
207macro_rules! ControlRemoveAddressErrorUnknown {
208 () => {
209 _
210 };
211}
212
213impl ControlRemoveAddressError {
214 #[inline]
215 pub fn from_primitive(prim: u32) -> Option<Self> {
216 match prim {
217 _ => None,
218 }
219 }
220
221 #[inline]
222 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
223 match prim {
224 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
225 }
226 }
227
228 #[inline]
229 pub fn unknown() -> Self {
230 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
231 }
232
233 #[inline]
234 pub const fn into_primitive(self) -> u32 {
235 match self {
236 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
237 }
238 }
239
240 #[inline]
241 pub fn is_unknown(&self) -> bool {
242 match self {
243 Self::__SourceBreaking { unknown_ordinal: _ } => true,
244 }
245 }
246}
247
248#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
249pub enum ControlRemoveError {
250 NotAllowed,
252 #[doc(hidden)]
253 __SourceBreaking { unknown_ordinal: u32 },
254}
255
256#[macro_export]
258macro_rules! ControlRemoveErrorUnknown {
259 () => {
260 _
261 };
262}
263
264impl ControlRemoveError {
265 #[inline]
266 pub fn from_primitive(prim: u32) -> Option<Self> {
267 match prim {
268 1 => Some(Self::NotAllowed),
269 _ => None,
270 }
271 }
272
273 #[inline]
274 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
275 match prim {
276 1 => Self::NotAllowed,
277 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
278 }
279 }
280
281 #[inline]
282 pub fn unknown() -> Self {
283 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
284 }
285
286 #[inline]
287 pub const fn into_primitive(self) -> u32 {
288 match self {
289 Self::NotAllowed => 1,
290 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
291 }
292 }
293
294 #[inline]
295 pub fn is_unknown(&self) -> bool {
296 match self {
297 Self::__SourceBreaking { unknown_ordinal: _ } => true,
298 _ => false,
299 }
300 }
301}
302
303#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
304pub enum ControlSetConfigurationError {
305 Ipv4ForwardingUnsupported,
308 Ipv4MulticastForwardingUnsupported,
311 Ipv4IgmpVersionUnsupported,
314 Ipv6ForwardingUnsupported,
317 Ipv6MulticastForwardingUnsupported,
320 Ipv6MldVersionUnsupported,
323 IllegalZeroValue,
326 ArpNotSupported,
330 NdpNotSupported,
334 IllegalNegativeValue,
337 #[doc(hidden)]
338 __SourceBreaking { unknown_ordinal: u32 },
339}
340
341#[macro_export]
343macro_rules! ControlSetConfigurationErrorUnknown {
344 () => {
345 _
346 };
347}
348
349impl ControlSetConfigurationError {
350 #[inline]
351 pub fn from_primitive(prim: u32) -> Option<Self> {
352 match prim {
353 1 => Some(Self::Ipv4ForwardingUnsupported),
354 2 => Some(Self::Ipv4MulticastForwardingUnsupported),
355 3 => Some(Self::Ipv4IgmpVersionUnsupported),
356 4 => Some(Self::Ipv6ForwardingUnsupported),
357 5 => Some(Self::Ipv6MulticastForwardingUnsupported),
358 6 => Some(Self::Ipv6MldVersionUnsupported),
359 7 => Some(Self::IllegalZeroValue),
360 8 => Some(Self::ArpNotSupported),
361 9 => Some(Self::NdpNotSupported),
362 10 => Some(Self::IllegalNegativeValue),
363 _ => None,
364 }
365 }
366
367 #[inline]
368 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
369 match prim {
370 1 => Self::Ipv4ForwardingUnsupported,
371 2 => Self::Ipv4MulticastForwardingUnsupported,
372 3 => Self::Ipv4IgmpVersionUnsupported,
373 4 => Self::Ipv6ForwardingUnsupported,
374 5 => Self::Ipv6MulticastForwardingUnsupported,
375 6 => Self::Ipv6MldVersionUnsupported,
376 7 => Self::IllegalZeroValue,
377 8 => Self::ArpNotSupported,
378 9 => Self::NdpNotSupported,
379 10 => Self::IllegalNegativeValue,
380 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
381 }
382 }
383
384 #[inline]
385 pub fn unknown() -> Self {
386 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
387 }
388
389 #[inline]
390 pub const fn into_primitive(self) -> u32 {
391 match self {
392 Self::Ipv4ForwardingUnsupported => 1,
393 Self::Ipv4MulticastForwardingUnsupported => 2,
394 Self::Ipv4IgmpVersionUnsupported => 3,
395 Self::Ipv6ForwardingUnsupported => 4,
396 Self::Ipv6MulticastForwardingUnsupported => 5,
397 Self::Ipv6MldVersionUnsupported => 6,
398 Self::IllegalZeroValue => 7,
399 Self::ArpNotSupported => 8,
400 Self::NdpNotSupported => 9,
401 Self::IllegalNegativeValue => 10,
402 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
403 }
404 }
405
406 #[inline]
407 pub fn is_unknown(&self) -> bool {
408 match self {
409 Self::__SourceBreaking { unknown_ordinal: _ } => true,
410 _ => false,
411 }
412 }
413}
414
415#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
416pub enum IgmpVersion {
417 V1,
419 V2,
421 V3,
423 #[doc(hidden)]
424 __SourceBreaking { unknown_ordinal: u8 },
425}
426
427#[macro_export]
429macro_rules! IgmpVersionUnknown {
430 () => {
431 _
432 };
433}
434
435impl IgmpVersion {
436 #[inline]
437 pub fn from_primitive(prim: u8) -> Option<Self> {
438 match prim {
439 1 => Some(Self::V1),
440 2 => Some(Self::V2),
441 3 => Some(Self::V3),
442 _ => None,
443 }
444 }
445
446 #[inline]
447 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
448 match prim {
449 1 => Self::V1,
450 2 => Self::V2,
451 3 => Self::V3,
452 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
453 }
454 }
455
456 #[inline]
457 pub fn unknown() -> Self {
458 Self::__SourceBreaking { unknown_ordinal: 0xff }
459 }
460
461 #[inline]
462 pub const fn into_primitive(self) -> u8 {
463 match self {
464 Self::V1 => 1,
465 Self::V2 => 2,
466 Self::V3 => 3,
467 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
468 }
469 }
470
471 #[inline]
472 pub fn is_unknown(&self) -> bool {
473 match self {
474 Self::__SourceBreaking { unknown_ordinal: _ } => true,
475 _ => false,
476 }
477 }
478}
479
480#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
481pub enum InterfaceRemovedReason {
482 DuplicateName,
485 PortAlreadyBound,
487 BadPort,
490 PortClosed,
492 User,
494 #[doc(hidden)]
495 __SourceBreaking { unknown_ordinal: u32 },
496}
497
498#[macro_export]
500macro_rules! InterfaceRemovedReasonUnknown {
501 () => {
502 _
503 };
504}
505
506impl InterfaceRemovedReason {
507 #[inline]
508 pub fn from_primitive(prim: u32) -> Option<Self> {
509 match prim {
510 1 => Some(Self::DuplicateName),
511 2 => Some(Self::PortAlreadyBound),
512 3 => Some(Self::BadPort),
513 4 => Some(Self::PortClosed),
514 5 => Some(Self::User),
515 _ => None,
516 }
517 }
518
519 #[inline]
520 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
521 match prim {
522 1 => Self::DuplicateName,
523 2 => Self::PortAlreadyBound,
524 3 => Self::BadPort,
525 4 => Self::PortClosed,
526 5 => Self::User,
527 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
528 }
529 }
530
531 #[inline]
532 pub fn unknown() -> Self {
533 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
534 }
535
536 #[inline]
537 pub const fn into_primitive(self) -> u32 {
538 match self {
539 Self::DuplicateName => 1,
540 Self::PortAlreadyBound => 2,
541 Self::BadPort => 3,
542 Self::PortClosed => 4,
543 Self::User => 5,
544 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
545 }
546 }
547
548 #[inline]
549 pub fn is_unknown(&self) -> bool {
550 match self {
551 Self::__SourceBreaking { unknown_ordinal: _ } => true,
552 _ => false,
553 }
554 }
555}
556
557#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
558pub enum MldVersion {
559 V1,
561 V2,
563 #[doc(hidden)]
564 __SourceBreaking { unknown_ordinal: u8 },
565}
566
567#[macro_export]
569macro_rules! MldVersionUnknown {
570 () => {
571 _
572 };
573}
574
575impl MldVersion {
576 #[inline]
577 pub fn from_primitive(prim: u8) -> Option<Self> {
578 match prim {
579 1 => Some(Self::V1),
580 2 => Some(Self::V2),
581 _ => None,
582 }
583 }
584
585 #[inline]
586 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
587 match prim {
588 1 => Self::V1,
589 2 => Self::V2,
590 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
591 }
592 }
593
594 #[inline]
595 pub fn unknown() -> Self {
596 Self::__SourceBreaking { unknown_ordinal: 0xff }
597 }
598
599 #[inline]
600 pub const fn into_primitive(self) -> u8 {
601 match self {
602 Self::V1 => 1,
603 Self::V2 => 2,
604 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
605 }
606 }
607
608 #[inline]
609 pub fn is_unknown(&self) -> bool {
610 match self {
611 Self::__SourceBreaking { unknown_ordinal: _ } => true,
612 _ => false,
613 }
614 }
615}
616
617#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
618pub struct AddressStateProviderOnAddressRemovedRequest {
619 pub error: AddressRemovalReason,
620}
621
622impl fidl::Persistable for AddressStateProviderOnAddressRemovedRequest {}
623
624#[derive(Clone, Debug, PartialEq)]
625pub struct AddressStateProviderUpdateAddressPropertiesRequest {
626 pub address_properties: AddressProperties,
627}
628
629impl fidl::Persistable for AddressStateProviderUpdateAddressPropertiesRequest {}
630
631#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
632pub struct AddressStateProviderWatchAddressAssignmentStateResponse {
633 pub assignment_state: fidl_fuchsia_net_interfaces::AddressAssignmentState,
634}
635
636impl fidl::Persistable for AddressStateProviderWatchAddressAssignmentStateResponse {}
637
638#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
639#[repr(C)]
640pub struct ControlGetIdResponse {
641 pub id: u64,
642}
643
644impl fidl::Persistable for ControlGetIdResponse {}
645
646#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
647pub struct ControlOnInterfaceRemovedRequest {
648 pub reason: InterfaceRemovedReason,
649}
650
651impl fidl::Persistable for ControlOnInterfaceRemovedRequest {}
652
653#[derive(Clone, Debug, PartialEq)]
654pub struct ControlRemoveAddressRequest {
655 pub address: fidl_fuchsia_net::Subnet,
656}
657
658impl fidl::Persistable for ControlRemoveAddressRequest {}
659
660#[derive(Clone, Debug, PartialEq)]
661pub struct ControlSetConfigurationRequest {
662 pub config: Configuration,
663}
664
665impl fidl::Persistable for ControlSetConfigurationRequest {}
666
667#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
668pub struct ControlDisableResponse {
669 pub did_disable: bool,
670}
671
672impl fidl::Persistable for ControlDisableResponse {}
673
674#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
675pub struct ControlEnableResponse {
676 pub did_enable: bool,
677}
678
679impl fidl::Persistable for ControlEnableResponse {}
680
681#[derive(Clone, Debug, PartialEq)]
682pub struct ControlGetConfigurationResponse {
683 pub config: Configuration,
684}
685
686impl fidl::Persistable for ControlGetConfigurationResponse {}
687
688#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
689pub struct ControlRemoveAddressResponse {
690 pub did_remove: bool,
691}
692
693impl fidl::Persistable for ControlRemoveAddressResponse {}
694
695#[derive(Clone, Debug, PartialEq)]
696pub struct ControlSetConfigurationResponse {
697 pub previous_config: Configuration,
698}
699
700impl fidl::Persistable for ControlSetConfigurationResponse {}
701
702#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
703pub struct Empty;
704
705impl fidl::Persistable for Empty {}
706
707#[derive(Clone, Debug, Default, PartialEq)]
709pub struct AddressParameters {
710 pub initial_properties: Option<AddressProperties>,
714 pub temporary: Option<bool>,
731 pub add_subnet_route: Option<bool>,
740 pub perform_dad: Option<bool>,
756 #[doc(hidden)]
757 pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for AddressParameters {}
761
762#[derive(Clone, Debug, Default, PartialEq)]
764pub struct AddressProperties {
765 pub preferred_lifetime_info: Option<fidl_fuchsia_net_interfaces::PreferredLifetimeInfo>,
770 pub valid_lifetime_end: Option<i64>,
784 #[doc(hidden)]
785 pub __source_breaking: fidl::marker::SourceBreaking,
786}
787
788impl fidl::Persistable for AddressProperties {}
789
790#[derive(Clone, Debug, Default, PartialEq)]
791pub struct ArpConfiguration {
792 pub nud: Option<NudConfiguration>,
794 pub dad: Option<DadConfiguration>,
799 #[doc(hidden)]
800 pub __source_breaking: fidl::marker::SourceBreaking,
801}
802
803impl fidl::Persistable for ArpConfiguration {}
804
805#[derive(Clone, Debug, Default, PartialEq)]
807pub struct Configuration {
808 pub ipv4: Option<Ipv4Configuration>,
810 pub ipv6: Option<Ipv6Configuration>,
812 #[doc(hidden)]
813 pub __source_breaking: fidl::marker::SourceBreaking,
814}
815
816impl fidl::Persistable for Configuration {}
817
818#[derive(Clone, Debug, Default, PartialEq)]
820pub struct DadConfiguration {
821 pub transmits: Option<u16>,
826 #[doc(hidden)]
827 pub __source_breaking: fidl::marker::SourceBreaking,
828}
829
830impl fidl::Persistable for DadConfiguration {}
831
832#[derive(Clone, Debug, Default, PartialEq)]
833pub struct IgmpConfiguration {
834 pub version: Option<IgmpVersion>,
840 #[doc(hidden)]
841 pub __source_breaking: fidl::marker::SourceBreaking,
842}
843
844impl fidl::Persistable for IgmpConfiguration {}
845
846#[derive(Clone, Debug, Default, PartialEq)]
847pub struct Ipv4Configuration {
848 pub unicast_forwarding: Option<bool>,
851 pub multicast_forwarding: Option<bool>,
853 pub igmp: Option<IgmpConfiguration>,
855 pub arp: Option<ArpConfiguration>,
857 #[doc(hidden)]
858 pub __source_breaking: fidl::marker::SourceBreaking,
859}
860
861impl fidl::Persistable for Ipv4Configuration {}
862
863#[derive(Clone, Debug, Default, PartialEq)]
864pub struct Ipv6Configuration {
865 pub unicast_forwarding: Option<bool>,
868 pub multicast_forwarding: Option<bool>,
870 pub mld: Option<MldConfiguration>,
872 pub ndp: Option<NdpConfiguration>,
874 #[doc(hidden)]
875 pub __source_breaking: fidl::marker::SourceBreaking,
876}
877
878impl fidl::Persistable for Ipv6Configuration {}
879
880#[derive(Clone, Debug, Default, PartialEq)]
881pub struct MldConfiguration {
882 pub version: Option<MldVersion>,
888 #[doc(hidden)]
889 pub __source_breaking: fidl::marker::SourceBreaking,
890}
891
892impl fidl::Persistable for MldConfiguration {}
893
894#[derive(Clone, Debug, Default, PartialEq)]
895pub struct NdpConfiguration {
896 pub nud: Option<NudConfiguration>,
898 pub dad: Option<DadConfiguration>,
900 pub slaac: Option<SlaacConfiguration>,
902 #[doc(hidden)]
903 pub __source_breaking: fidl::marker::SourceBreaking,
904}
905
906impl fidl::Persistable for NdpConfiguration {}
907
908#[derive(Clone, Debug, Default, PartialEq)]
912pub struct NudConfiguration {
913 pub max_multicast_solicitations: Option<u16>,
919 pub max_unicast_solicitations: Option<u16>,
924 pub base_reachable_time: Option<i64>,
934 #[doc(hidden)]
935 pub __source_breaking: fidl::marker::SourceBreaking,
936}
937
938impl fidl::Persistable for NudConfiguration {}
939
940#[derive(Clone, Debug, Default, PartialEq)]
942pub struct Options {
943 pub name: Option<String>,
947 pub metric: Option<u32>,
951 #[doc(hidden)]
952 pub __source_breaking: fidl::marker::SourceBreaking,
953}
954
955impl fidl::Persistable for Options {}
956
957#[derive(Clone, Debug, Default, PartialEq)]
958pub struct SlaacConfiguration {
959 pub temporary_address: Option<bool>,
968 #[doc(hidden)]
969 pub __source_breaking: fidl::marker::SourceBreaking,
970}
971
972impl fidl::Persistable for SlaacConfiguration {}
973
974mod internal {
975 use super::*;
976 unsafe impl fidl::encoding::TypeMarker for AddressRemovalReason {
977 type Owned = Self;
978
979 #[inline(always)]
980 fn inline_align(_context: fidl::encoding::Context) -> usize {
981 std::mem::align_of::<u32>()
982 }
983
984 #[inline(always)]
985 fn inline_size(_context: fidl::encoding::Context) -> usize {
986 std::mem::size_of::<u32>()
987 }
988
989 #[inline(always)]
990 fn encode_is_copy() -> bool {
991 true
992 }
993
994 #[inline(always)]
995 fn decode_is_copy() -> bool {
996 false
997 }
998 }
999
1000 impl fidl::encoding::ValueTypeMarker for AddressRemovalReason {
1001 type Borrowed<'a> = Self;
1002 #[inline(always)]
1003 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1004 *value
1005 }
1006 }
1007
1008 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1009 for AddressRemovalReason
1010 {
1011 #[inline]
1012 unsafe fn encode(
1013 self,
1014 encoder: &mut fidl::encoding::Encoder<'_, D>,
1015 offset: usize,
1016 _depth: fidl::encoding::Depth,
1017 ) -> fidl::Result<()> {
1018 encoder.debug_check_bounds::<Self>(offset);
1019 encoder.write_num(self.into_primitive(), offset);
1020 Ok(())
1021 }
1022 }
1023
1024 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressRemovalReason {
1025 #[inline(always)]
1026 fn new_empty() -> Self {
1027 Self::Invalid
1028 }
1029
1030 #[inline]
1031 unsafe fn decode(
1032 &mut self,
1033 decoder: &mut fidl::encoding::Decoder<'_, D>,
1034 offset: usize,
1035 _depth: fidl::encoding::Depth,
1036 ) -> fidl::Result<()> {
1037 decoder.debug_check_bounds::<Self>(offset);
1038 let prim = decoder.read_num::<u32>(offset);
1039
1040 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1041 Ok(())
1042 }
1043 }
1044 unsafe impl fidl::encoding::TypeMarker for ControlDisableError {
1045 type Owned = Self;
1046
1047 #[inline(always)]
1048 fn inline_align(_context: fidl::encoding::Context) -> usize {
1049 std::mem::align_of::<u32>()
1050 }
1051
1052 #[inline(always)]
1053 fn inline_size(_context: fidl::encoding::Context) -> usize {
1054 std::mem::size_of::<u32>()
1055 }
1056
1057 #[inline(always)]
1058 fn encode_is_copy() -> bool {
1059 false
1060 }
1061
1062 #[inline(always)]
1063 fn decode_is_copy() -> bool {
1064 false
1065 }
1066 }
1067
1068 impl fidl::encoding::ValueTypeMarker for ControlDisableError {
1069 type Borrowed<'a> = Self;
1070 #[inline(always)]
1071 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1072 *value
1073 }
1074 }
1075
1076 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1077 for ControlDisableError
1078 {
1079 #[inline]
1080 unsafe fn encode(
1081 self,
1082 encoder: &mut fidl::encoding::Encoder<'_, D>,
1083 offset: usize,
1084 _depth: fidl::encoding::Depth,
1085 ) -> fidl::Result<()> {
1086 encoder.debug_check_bounds::<Self>(offset);
1087 encoder.write_num(self.into_primitive(), offset);
1088 Ok(())
1089 }
1090 }
1091
1092 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlDisableError {
1093 #[inline(always)]
1094 fn new_empty() -> Self {
1095 Self::unknown()
1096 }
1097
1098 #[inline]
1099 unsafe fn decode(
1100 &mut self,
1101 decoder: &mut fidl::encoding::Decoder<'_, D>,
1102 offset: usize,
1103 _depth: fidl::encoding::Depth,
1104 ) -> fidl::Result<()> {
1105 decoder.debug_check_bounds::<Self>(offset);
1106 let prim = decoder.read_num::<u32>(offset);
1107
1108 *self = Self::from_primitive_allow_unknown(prim);
1109 Ok(())
1110 }
1111 }
1112 unsafe impl fidl::encoding::TypeMarker for ControlEnableError {
1113 type Owned = Self;
1114
1115 #[inline(always)]
1116 fn inline_align(_context: fidl::encoding::Context) -> usize {
1117 std::mem::align_of::<u32>()
1118 }
1119
1120 #[inline(always)]
1121 fn inline_size(_context: fidl::encoding::Context) -> usize {
1122 std::mem::size_of::<u32>()
1123 }
1124
1125 #[inline(always)]
1126 fn encode_is_copy() -> bool {
1127 false
1128 }
1129
1130 #[inline(always)]
1131 fn decode_is_copy() -> bool {
1132 false
1133 }
1134 }
1135
1136 impl fidl::encoding::ValueTypeMarker for ControlEnableError {
1137 type Borrowed<'a> = Self;
1138 #[inline(always)]
1139 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1140 *value
1141 }
1142 }
1143
1144 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1145 for ControlEnableError
1146 {
1147 #[inline]
1148 unsafe fn encode(
1149 self,
1150 encoder: &mut fidl::encoding::Encoder<'_, D>,
1151 offset: usize,
1152 _depth: fidl::encoding::Depth,
1153 ) -> fidl::Result<()> {
1154 encoder.debug_check_bounds::<Self>(offset);
1155 encoder.write_num(self.into_primitive(), offset);
1156 Ok(())
1157 }
1158 }
1159
1160 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableError {
1161 #[inline(always)]
1162 fn new_empty() -> Self {
1163 Self::unknown()
1164 }
1165
1166 #[inline]
1167 unsafe fn decode(
1168 &mut self,
1169 decoder: &mut fidl::encoding::Decoder<'_, D>,
1170 offset: usize,
1171 _depth: fidl::encoding::Depth,
1172 ) -> fidl::Result<()> {
1173 decoder.debug_check_bounds::<Self>(offset);
1174 let prim = decoder.read_num::<u32>(offset);
1175
1176 *self = Self::from_primitive_allow_unknown(prim);
1177 Ok(())
1178 }
1179 }
1180 unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationError {
1181 type Owned = Self;
1182
1183 #[inline(always)]
1184 fn inline_align(_context: fidl::encoding::Context) -> usize {
1185 std::mem::align_of::<u32>()
1186 }
1187
1188 #[inline(always)]
1189 fn inline_size(_context: fidl::encoding::Context) -> usize {
1190 std::mem::size_of::<u32>()
1191 }
1192
1193 #[inline(always)]
1194 fn encode_is_copy() -> bool {
1195 false
1196 }
1197
1198 #[inline(always)]
1199 fn decode_is_copy() -> bool {
1200 false
1201 }
1202 }
1203
1204 impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationError {
1205 type Borrowed<'a> = Self;
1206 #[inline(always)]
1207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1208 *value
1209 }
1210 }
1211
1212 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1213 for ControlGetConfigurationError
1214 {
1215 #[inline]
1216 unsafe fn encode(
1217 self,
1218 encoder: &mut fidl::encoding::Encoder<'_, D>,
1219 offset: usize,
1220 _depth: fidl::encoding::Depth,
1221 ) -> fidl::Result<()> {
1222 encoder.debug_check_bounds::<Self>(offset);
1223 encoder.write_num(self.into_primitive(), offset);
1224 Ok(())
1225 }
1226 }
1227
1228 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1229 for ControlGetConfigurationError
1230 {
1231 #[inline(always)]
1232 fn new_empty() -> Self {
1233 Self::unknown()
1234 }
1235
1236 #[inline]
1237 unsafe fn decode(
1238 &mut self,
1239 decoder: &mut fidl::encoding::Decoder<'_, D>,
1240 offset: usize,
1241 _depth: fidl::encoding::Depth,
1242 ) -> fidl::Result<()> {
1243 decoder.debug_check_bounds::<Self>(offset);
1244 let prim = decoder.read_num::<u32>(offset);
1245
1246 *self = Self::from_primitive_allow_unknown(prim);
1247 Ok(())
1248 }
1249 }
1250 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressError {
1251 type Owned = Self;
1252
1253 #[inline(always)]
1254 fn inline_align(_context: fidl::encoding::Context) -> usize {
1255 std::mem::align_of::<u32>()
1256 }
1257
1258 #[inline(always)]
1259 fn inline_size(_context: fidl::encoding::Context) -> usize {
1260 std::mem::size_of::<u32>()
1261 }
1262
1263 #[inline(always)]
1264 fn encode_is_copy() -> bool {
1265 false
1266 }
1267
1268 #[inline(always)]
1269 fn decode_is_copy() -> bool {
1270 false
1271 }
1272 }
1273
1274 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressError {
1275 type Borrowed<'a> = Self;
1276 #[inline(always)]
1277 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1278 *value
1279 }
1280 }
1281
1282 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1283 for ControlRemoveAddressError
1284 {
1285 #[inline]
1286 unsafe fn encode(
1287 self,
1288 encoder: &mut fidl::encoding::Encoder<'_, D>,
1289 offset: usize,
1290 _depth: fidl::encoding::Depth,
1291 ) -> fidl::Result<()> {
1292 encoder.debug_check_bounds::<Self>(offset);
1293 encoder.write_num(self.into_primitive(), offset);
1294 Ok(())
1295 }
1296 }
1297
1298 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1299 for ControlRemoveAddressError
1300 {
1301 #[inline(always)]
1302 fn new_empty() -> Self {
1303 Self::unknown()
1304 }
1305
1306 #[inline]
1307 unsafe fn decode(
1308 &mut self,
1309 decoder: &mut fidl::encoding::Decoder<'_, D>,
1310 offset: usize,
1311 _depth: fidl::encoding::Depth,
1312 ) -> fidl::Result<()> {
1313 decoder.debug_check_bounds::<Self>(offset);
1314 let prim = decoder.read_num::<u32>(offset);
1315
1316 *self = Self::from_primitive_allow_unknown(prim);
1317 Ok(())
1318 }
1319 }
1320 unsafe impl fidl::encoding::TypeMarker for ControlRemoveError {
1321 type Owned = Self;
1322
1323 #[inline(always)]
1324 fn inline_align(_context: fidl::encoding::Context) -> usize {
1325 std::mem::align_of::<u32>()
1326 }
1327
1328 #[inline(always)]
1329 fn inline_size(_context: fidl::encoding::Context) -> usize {
1330 std::mem::size_of::<u32>()
1331 }
1332
1333 #[inline(always)]
1334 fn encode_is_copy() -> bool {
1335 false
1336 }
1337
1338 #[inline(always)]
1339 fn decode_is_copy() -> bool {
1340 false
1341 }
1342 }
1343
1344 impl fidl::encoding::ValueTypeMarker for ControlRemoveError {
1345 type Borrowed<'a> = Self;
1346 #[inline(always)]
1347 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1348 *value
1349 }
1350 }
1351
1352 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1353 for ControlRemoveError
1354 {
1355 #[inline]
1356 unsafe fn encode(
1357 self,
1358 encoder: &mut fidl::encoding::Encoder<'_, D>,
1359 offset: usize,
1360 _depth: fidl::encoding::Depth,
1361 ) -> fidl::Result<()> {
1362 encoder.debug_check_bounds::<Self>(offset);
1363 encoder.write_num(self.into_primitive(), offset);
1364 Ok(())
1365 }
1366 }
1367
1368 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlRemoveError {
1369 #[inline(always)]
1370 fn new_empty() -> Self {
1371 Self::unknown()
1372 }
1373
1374 #[inline]
1375 unsafe fn decode(
1376 &mut self,
1377 decoder: &mut fidl::encoding::Decoder<'_, D>,
1378 offset: usize,
1379 _depth: fidl::encoding::Depth,
1380 ) -> fidl::Result<()> {
1381 decoder.debug_check_bounds::<Self>(offset);
1382 let prim = decoder.read_num::<u32>(offset);
1383
1384 *self = Self::from_primitive_allow_unknown(prim);
1385 Ok(())
1386 }
1387 }
1388 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationError {
1389 type Owned = Self;
1390
1391 #[inline(always)]
1392 fn inline_align(_context: fidl::encoding::Context) -> usize {
1393 std::mem::align_of::<u32>()
1394 }
1395
1396 #[inline(always)]
1397 fn inline_size(_context: fidl::encoding::Context) -> usize {
1398 std::mem::size_of::<u32>()
1399 }
1400
1401 #[inline(always)]
1402 fn encode_is_copy() -> bool {
1403 false
1404 }
1405
1406 #[inline(always)]
1407 fn decode_is_copy() -> bool {
1408 false
1409 }
1410 }
1411
1412 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationError {
1413 type Borrowed<'a> = Self;
1414 #[inline(always)]
1415 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1416 *value
1417 }
1418 }
1419
1420 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1421 for ControlSetConfigurationError
1422 {
1423 #[inline]
1424 unsafe fn encode(
1425 self,
1426 encoder: &mut fidl::encoding::Encoder<'_, D>,
1427 offset: usize,
1428 _depth: fidl::encoding::Depth,
1429 ) -> fidl::Result<()> {
1430 encoder.debug_check_bounds::<Self>(offset);
1431 encoder.write_num(self.into_primitive(), offset);
1432 Ok(())
1433 }
1434 }
1435
1436 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1437 for ControlSetConfigurationError
1438 {
1439 #[inline(always)]
1440 fn new_empty() -> Self {
1441 Self::unknown()
1442 }
1443
1444 #[inline]
1445 unsafe fn decode(
1446 &mut self,
1447 decoder: &mut fidl::encoding::Decoder<'_, D>,
1448 offset: usize,
1449 _depth: fidl::encoding::Depth,
1450 ) -> fidl::Result<()> {
1451 decoder.debug_check_bounds::<Self>(offset);
1452 let prim = decoder.read_num::<u32>(offset);
1453
1454 *self = Self::from_primitive_allow_unknown(prim);
1455 Ok(())
1456 }
1457 }
1458 unsafe impl fidl::encoding::TypeMarker for IgmpVersion {
1459 type Owned = Self;
1460
1461 #[inline(always)]
1462 fn inline_align(_context: fidl::encoding::Context) -> usize {
1463 std::mem::align_of::<u8>()
1464 }
1465
1466 #[inline(always)]
1467 fn inline_size(_context: fidl::encoding::Context) -> usize {
1468 std::mem::size_of::<u8>()
1469 }
1470
1471 #[inline(always)]
1472 fn encode_is_copy() -> bool {
1473 false
1474 }
1475
1476 #[inline(always)]
1477 fn decode_is_copy() -> bool {
1478 false
1479 }
1480 }
1481
1482 impl fidl::encoding::ValueTypeMarker for IgmpVersion {
1483 type Borrowed<'a> = Self;
1484 #[inline(always)]
1485 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1486 *value
1487 }
1488 }
1489
1490 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IgmpVersion {
1491 #[inline]
1492 unsafe fn encode(
1493 self,
1494 encoder: &mut fidl::encoding::Encoder<'_, D>,
1495 offset: usize,
1496 _depth: fidl::encoding::Depth,
1497 ) -> fidl::Result<()> {
1498 encoder.debug_check_bounds::<Self>(offset);
1499 encoder.write_num(self.into_primitive(), offset);
1500 Ok(())
1501 }
1502 }
1503
1504 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpVersion {
1505 #[inline(always)]
1506 fn new_empty() -> Self {
1507 Self::unknown()
1508 }
1509
1510 #[inline]
1511 unsafe fn decode(
1512 &mut self,
1513 decoder: &mut fidl::encoding::Decoder<'_, D>,
1514 offset: usize,
1515 _depth: fidl::encoding::Depth,
1516 ) -> fidl::Result<()> {
1517 decoder.debug_check_bounds::<Self>(offset);
1518 let prim = decoder.read_num::<u8>(offset);
1519
1520 *self = Self::from_primitive_allow_unknown(prim);
1521 Ok(())
1522 }
1523 }
1524 unsafe impl fidl::encoding::TypeMarker for InterfaceRemovedReason {
1525 type Owned = Self;
1526
1527 #[inline(always)]
1528 fn inline_align(_context: fidl::encoding::Context) -> usize {
1529 std::mem::align_of::<u32>()
1530 }
1531
1532 #[inline(always)]
1533 fn inline_size(_context: fidl::encoding::Context) -> usize {
1534 std::mem::size_of::<u32>()
1535 }
1536
1537 #[inline(always)]
1538 fn encode_is_copy() -> bool {
1539 false
1540 }
1541
1542 #[inline(always)]
1543 fn decode_is_copy() -> bool {
1544 false
1545 }
1546 }
1547
1548 impl fidl::encoding::ValueTypeMarker for InterfaceRemovedReason {
1549 type Borrowed<'a> = Self;
1550 #[inline(always)]
1551 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1552 *value
1553 }
1554 }
1555
1556 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1557 for InterfaceRemovedReason
1558 {
1559 #[inline]
1560 unsafe fn encode(
1561 self,
1562 encoder: &mut fidl::encoding::Encoder<'_, D>,
1563 offset: usize,
1564 _depth: fidl::encoding::Depth,
1565 ) -> fidl::Result<()> {
1566 encoder.debug_check_bounds::<Self>(offset);
1567 encoder.write_num(self.into_primitive(), offset);
1568 Ok(())
1569 }
1570 }
1571
1572 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1573 for InterfaceRemovedReason
1574 {
1575 #[inline(always)]
1576 fn new_empty() -> Self {
1577 Self::unknown()
1578 }
1579
1580 #[inline]
1581 unsafe fn decode(
1582 &mut self,
1583 decoder: &mut fidl::encoding::Decoder<'_, D>,
1584 offset: usize,
1585 _depth: fidl::encoding::Depth,
1586 ) -> fidl::Result<()> {
1587 decoder.debug_check_bounds::<Self>(offset);
1588 let prim = decoder.read_num::<u32>(offset);
1589
1590 *self = Self::from_primitive_allow_unknown(prim);
1591 Ok(())
1592 }
1593 }
1594 unsafe impl fidl::encoding::TypeMarker for MldVersion {
1595 type Owned = Self;
1596
1597 #[inline(always)]
1598 fn inline_align(_context: fidl::encoding::Context) -> usize {
1599 std::mem::align_of::<u8>()
1600 }
1601
1602 #[inline(always)]
1603 fn inline_size(_context: fidl::encoding::Context) -> usize {
1604 std::mem::size_of::<u8>()
1605 }
1606
1607 #[inline(always)]
1608 fn encode_is_copy() -> bool {
1609 false
1610 }
1611
1612 #[inline(always)]
1613 fn decode_is_copy() -> bool {
1614 false
1615 }
1616 }
1617
1618 impl fidl::encoding::ValueTypeMarker for MldVersion {
1619 type Borrowed<'a> = Self;
1620 #[inline(always)]
1621 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1622 *value
1623 }
1624 }
1625
1626 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MldVersion {
1627 #[inline]
1628 unsafe fn encode(
1629 self,
1630 encoder: &mut fidl::encoding::Encoder<'_, D>,
1631 offset: usize,
1632 _depth: fidl::encoding::Depth,
1633 ) -> fidl::Result<()> {
1634 encoder.debug_check_bounds::<Self>(offset);
1635 encoder.write_num(self.into_primitive(), offset);
1636 Ok(())
1637 }
1638 }
1639
1640 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldVersion {
1641 #[inline(always)]
1642 fn new_empty() -> Self {
1643 Self::unknown()
1644 }
1645
1646 #[inline]
1647 unsafe fn decode(
1648 &mut self,
1649 decoder: &mut fidl::encoding::Decoder<'_, D>,
1650 offset: usize,
1651 _depth: fidl::encoding::Depth,
1652 ) -> fidl::Result<()> {
1653 decoder.debug_check_bounds::<Self>(offset);
1654 let prim = decoder.read_num::<u8>(offset);
1655
1656 *self = Self::from_primitive_allow_unknown(prim);
1657 Ok(())
1658 }
1659 }
1660
1661 impl fidl::encoding::ValueTypeMarker for AddressStateProviderOnAddressRemovedRequest {
1662 type Borrowed<'a> = &'a Self;
1663 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1664 value
1665 }
1666 }
1667
1668 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderOnAddressRemovedRequest {
1669 type Owned = Self;
1670
1671 #[inline(always)]
1672 fn inline_align(_context: fidl::encoding::Context) -> usize {
1673 4
1674 }
1675
1676 #[inline(always)]
1677 fn inline_size(_context: fidl::encoding::Context) -> usize {
1678 4
1679 }
1680 }
1681
1682 unsafe impl<D: fidl::encoding::ResourceDialect>
1683 fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D>
1684 for &AddressStateProviderOnAddressRemovedRequest
1685 {
1686 #[inline]
1687 unsafe fn encode(
1688 self,
1689 encoder: &mut fidl::encoding::Encoder<'_, D>,
1690 offset: usize,
1691 _depth: fidl::encoding::Depth,
1692 ) -> fidl::Result<()> {
1693 encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1694 fidl::encoding::Encode::<AddressStateProviderOnAddressRemovedRequest, D>::encode(
1696 (<AddressRemovalReason as fidl::encoding::ValueTypeMarker>::borrow(&self.error),),
1697 encoder,
1698 offset,
1699 _depth,
1700 )
1701 }
1702 }
1703 unsafe impl<
1704 D: fidl::encoding::ResourceDialect,
1705 T0: fidl::encoding::Encode<AddressRemovalReason, D>,
1706 > fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D> for (T0,)
1707 {
1708 #[inline]
1709 unsafe fn encode(
1710 self,
1711 encoder: &mut fidl::encoding::Encoder<'_, D>,
1712 offset: usize,
1713 depth: fidl::encoding::Depth,
1714 ) -> fidl::Result<()> {
1715 encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1716 self.0.encode(encoder, offset + 0, depth)?;
1720 Ok(())
1721 }
1722 }
1723
1724 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1725 for AddressStateProviderOnAddressRemovedRequest
1726 {
1727 #[inline(always)]
1728 fn new_empty() -> Self {
1729 Self { error: fidl::new_empty!(AddressRemovalReason, D) }
1730 }
1731
1732 #[inline]
1733 unsafe fn decode(
1734 &mut self,
1735 decoder: &mut fidl::encoding::Decoder<'_, D>,
1736 offset: usize,
1737 _depth: fidl::encoding::Depth,
1738 ) -> fidl::Result<()> {
1739 decoder.debug_check_bounds::<Self>(offset);
1740 fidl::decode!(AddressRemovalReason, D, &mut self.error, decoder, offset + 0, _depth)?;
1742 Ok(())
1743 }
1744 }
1745
1746 impl fidl::encoding::ValueTypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1747 type Borrowed<'a> = &'a Self;
1748 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1749 value
1750 }
1751 }
1752
1753 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1754 type Owned = Self;
1755
1756 #[inline(always)]
1757 fn inline_align(_context: fidl::encoding::Context) -> usize {
1758 8
1759 }
1760
1761 #[inline(always)]
1762 fn inline_size(_context: fidl::encoding::Context) -> usize {
1763 16
1764 }
1765 }
1766
1767 unsafe impl<D: fidl::encoding::ResourceDialect>
1768 fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D>
1769 for &AddressStateProviderUpdateAddressPropertiesRequest
1770 {
1771 #[inline]
1772 unsafe fn encode(
1773 self,
1774 encoder: &mut fidl::encoding::Encoder<'_, D>,
1775 offset: usize,
1776 _depth: fidl::encoding::Depth,
1777 ) -> fidl::Result<()> {
1778 encoder
1779 .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1780 fidl::encoding::Encode::<AddressStateProviderUpdateAddressPropertiesRequest, D>::encode(
1782 (<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow(
1783 &self.address_properties,
1784 ),),
1785 encoder,
1786 offset,
1787 _depth,
1788 )
1789 }
1790 }
1791 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AddressProperties, D>>
1792 fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D> for (T0,)
1793 {
1794 #[inline]
1795 unsafe fn encode(
1796 self,
1797 encoder: &mut fidl::encoding::Encoder<'_, D>,
1798 offset: usize,
1799 depth: fidl::encoding::Depth,
1800 ) -> fidl::Result<()> {
1801 encoder
1802 .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1803 self.0.encode(encoder, offset + 0, depth)?;
1807 Ok(())
1808 }
1809 }
1810
1811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1812 for AddressStateProviderUpdateAddressPropertiesRequest
1813 {
1814 #[inline(always)]
1815 fn new_empty() -> Self {
1816 Self { address_properties: fidl::new_empty!(AddressProperties, D) }
1817 }
1818
1819 #[inline]
1820 unsafe fn decode(
1821 &mut self,
1822 decoder: &mut fidl::encoding::Decoder<'_, D>,
1823 offset: usize,
1824 _depth: fidl::encoding::Depth,
1825 ) -> fidl::Result<()> {
1826 decoder.debug_check_bounds::<Self>(offset);
1827 fidl::decode!(
1829 AddressProperties,
1830 D,
1831 &mut self.address_properties,
1832 decoder,
1833 offset + 0,
1834 _depth
1835 )?;
1836 Ok(())
1837 }
1838 }
1839
1840 impl fidl::encoding::ValueTypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1841 type Borrowed<'a> = &'a Self;
1842 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1843 value
1844 }
1845 }
1846
1847 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1848 type Owned = Self;
1849
1850 #[inline(always)]
1851 fn inline_align(_context: fidl::encoding::Context) -> usize {
1852 4
1853 }
1854
1855 #[inline(always)]
1856 fn inline_size(_context: fidl::encoding::Context) -> usize {
1857 4
1858 }
1859 }
1860
1861 unsafe impl<D: fidl::encoding::ResourceDialect>
1862 fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1863 for &AddressStateProviderWatchAddressAssignmentStateResponse
1864 {
1865 #[inline]
1866 unsafe fn encode(
1867 self,
1868 encoder: &mut fidl::encoding::Encoder<'_, D>,
1869 offset: usize,
1870 _depth: fidl::encoding::Depth,
1871 ) -> fidl::Result<()> {
1872 encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1873 offset,
1874 );
1875 fidl::encoding::Encode::<AddressStateProviderWatchAddressAssignmentStateResponse, D>::encode(
1877 (
1878 <fidl_fuchsia_net_interfaces::AddressAssignmentState as fidl::encoding::ValueTypeMarker>::borrow(&self.assignment_state),
1879 ),
1880 encoder, offset, _depth
1881 )
1882 }
1883 }
1884 unsafe impl<
1885 D: fidl::encoding::ResourceDialect,
1886 T0: fidl::encoding::Encode<fidl_fuchsia_net_interfaces::AddressAssignmentState, D>,
1887 > fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1888 for (T0,)
1889 {
1890 #[inline]
1891 unsafe fn encode(
1892 self,
1893 encoder: &mut fidl::encoding::Encoder<'_, D>,
1894 offset: usize,
1895 depth: fidl::encoding::Depth,
1896 ) -> fidl::Result<()> {
1897 encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1898 offset,
1899 );
1900 self.0.encode(encoder, offset + 0, depth)?;
1904 Ok(())
1905 }
1906 }
1907
1908 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1909 for AddressStateProviderWatchAddressAssignmentStateResponse
1910 {
1911 #[inline(always)]
1912 fn new_empty() -> Self {
1913 Self {
1914 assignment_state: fidl::new_empty!(
1915 fidl_fuchsia_net_interfaces::AddressAssignmentState,
1916 D
1917 ),
1918 }
1919 }
1920
1921 #[inline]
1922 unsafe fn decode(
1923 &mut self,
1924 decoder: &mut fidl::encoding::Decoder<'_, D>,
1925 offset: usize,
1926 _depth: fidl::encoding::Depth,
1927 ) -> fidl::Result<()> {
1928 decoder.debug_check_bounds::<Self>(offset);
1929 fidl::decode!(
1931 fidl_fuchsia_net_interfaces::AddressAssignmentState,
1932 D,
1933 &mut self.assignment_state,
1934 decoder,
1935 offset + 0,
1936 _depth
1937 )?;
1938 Ok(())
1939 }
1940 }
1941
1942 impl fidl::encoding::ValueTypeMarker for ControlGetIdResponse {
1943 type Borrowed<'a> = &'a Self;
1944 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1945 value
1946 }
1947 }
1948
1949 unsafe impl fidl::encoding::TypeMarker for ControlGetIdResponse {
1950 type Owned = Self;
1951
1952 #[inline(always)]
1953 fn inline_align(_context: fidl::encoding::Context) -> usize {
1954 8
1955 }
1956
1957 #[inline(always)]
1958 fn inline_size(_context: fidl::encoding::Context) -> usize {
1959 8
1960 }
1961 #[inline(always)]
1962 fn encode_is_copy() -> bool {
1963 true
1964 }
1965
1966 #[inline(always)]
1967 fn decode_is_copy() -> bool {
1968 true
1969 }
1970 }
1971
1972 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlGetIdResponse, D>
1973 for &ControlGetIdResponse
1974 {
1975 #[inline]
1976 unsafe fn encode(
1977 self,
1978 encoder: &mut fidl::encoding::Encoder<'_, D>,
1979 offset: usize,
1980 _depth: fidl::encoding::Depth,
1981 ) -> fidl::Result<()> {
1982 encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
1983 unsafe {
1984 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1986 (buf_ptr as *mut ControlGetIdResponse)
1987 .write_unaligned((self as *const ControlGetIdResponse).read());
1988 }
1991 Ok(())
1992 }
1993 }
1994 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
1995 fidl::encoding::Encode<ControlGetIdResponse, D> for (T0,)
1996 {
1997 #[inline]
1998 unsafe fn encode(
1999 self,
2000 encoder: &mut fidl::encoding::Encoder<'_, D>,
2001 offset: usize,
2002 depth: fidl::encoding::Depth,
2003 ) -> fidl::Result<()> {
2004 encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
2005 self.0.encode(encoder, offset + 0, depth)?;
2009 Ok(())
2010 }
2011 }
2012
2013 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlGetIdResponse {
2014 #[inline(always)]
2015 fn new_empty() -> Self {
2016 Self { id: fidl::new_empty!(u64, D) }
2017 }
2018
2019 #[inline]
2020 unsafe fn decode(
2021 &mut self,
2022 decoder: &mut fidl::encoding::Decoder<'_, D>,
2023 offset: usize,
2024 _depth: fidl::encoding::Depth,
2025 ) -> fidl::Result<()> {
2026 decoder.debug_check_bounds::<Self>(offset);
2027 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2028 unsafe {
2031 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2032 }
2033 Ok(())
2034 }
2035 }
2036
2037 impl fidl::encoding::ValueTypeMarker for ControlOnInterfaceRemovedRequest {
2038 type Borrowed<'a> = &'a Self;
2039 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2040 value
2041 }
2042 }
2043
2044 unsafe impl fidl::encoding::TypeMarker for ControlOnInterfaceRemovedRequest {
2045 type Owned = Self;
2046
2047 #[inline(always)]
2048 fn inline_align(_context: fidl::encoding::Context) -> usize {
2049 4
2050 }
2051
2052 #[inline(always)]
2053 fn inline_size(_context: fidl::encoding::Context) -> usize {
2054 4
2055 }
2056 }
2057
2058 unsafe impl<D: fidl::encoding::ResourceDialect>
2059 fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D>
2060 for &ControlOnInterfaceRemovedRequest
2061 {
2062 #[inline]
2063 unsafe fn encode(
2064 self,
2065 encoder: &mut fidl::encoding::Encoder<'_, D>,
2066 offset: usize,
2067 _depth: fidl::encoding::Depth,
2068 ) -> fidl::Result<()> {
2069 encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2070 fidl::encoding::Encode::<ControlOnInterfaceRemovedRequest, D>::encode(
2072 (<InterfaceRemovedReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
2073 encoder,
2074 offset,
2075 _depth,
2076 )
2077 }
2078 }
2079 unsafe impl<
2080 D: fidl::encoding::ResourceDialect,
2081 T0: fidl::encoding::Encode<InterfaceRemovedReason, D>,
2082 > fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D> for (T0,)
2083 {
2084 #[inline]
2085 unsafe fn encode(
2086 self,
2087 encoder: &mut fidl::encoding::Encoder<'_, D>,
2088 offset: usize,
2089 depth: fidl::encoding::Depth,
2090 ) -> fidl::Result<()> {
2091 encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2092 self.0.encode(encoder, offset + 0, depth)?;
2096 Ok(())
2097 }
2098 }
2099
2100 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2101 for ControlOnInterfaceRemovedRequest
2102 {
2103 #[inline(always)]
2104 fn new_empty() -> Self {
2105 Self { reason: fidl::new_empty!(InterfaceRemovedReason, D) }
2106 }
2107
2108 #[inline]
2109 unsafe fn decode(
2110 &mut self,
2111 decoder: &mut fidl::encoding::Decoder<'_, D>,
2112 offset: usize,
2113 _depth: fidl::encoding::Depth,
2114 ) -> fidl::Result<()> {
2115 decoder.debug_check_bounds::<Self>(offset);
2116 fidl::decode!(
2118 InterfaceRemovedReason,
2119 D,
2120 &mut self.reason,
2121 decoder,
2122 offset + 0,
2123 _depth
2124 )?;
2125 Ok(())
2126 }
2127 }
2128
2129 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressRequest {
2130 type Borrowed<'a> = &'a Self;
2131 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2132 value
2133 }
2134 }
2135
2136 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressRequest {
2137 type Owned = Self;
2138
2139 #[inline(always)]
2140 fn inline_align(_context: fidl::encoding::Context) -> usize {
2141 8
2142 }
2143
2144 #[inline(always)]
2145 fn inline_size(_context: fidl::encoding::Context) -> usize {
2146 24
2147 }
2148 }
2149
2150 unsafe impl<D: fidl::encoding::ResourceDialect>
2151 fidl::encoding::Encode<ControlRemoveAddressRequest, D> for &ControlRemoveAddressRequest
2152 {
2153 #[inline]
2154 unsafe fn encode(
2155 self,
2156 encoder: &mut fidl::encoding::Encoder<'_, D>,
2157 offset: usize,
2158 _depth: fidl::encoding::Depth,
2159 ) -> fidl::Result<()> {
2160 encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2161 fidl::encoding::Encode::<ControlRemoveAddressRequest, D>::encode(
2163 (<fidl_fuchsia_net::Subnet as fidl::encoding::ValueTypeMarker>::borrow(
2164 &self.address,
2165 ),),
2166 encoder,
2167 offset,
2168 _depth,
2169 )
2170 }
2171 }
2172 unsafe impl<
2173 D: fidl::encoding::ResourceDialect,
2174 T0: fidl::encoding::Encode<fidl_fuchsia_net::Subnet, D>,
2175 > fidl::encoding::Encode<ControlRemoveAddressRequest, D> for (T0,)
2176 {
2177 #[inline]
2178 unsafe fn encode(
2179 self,
2180 encoder: &mut fidl::encoding::Encoder<'_, D>,
2181 offset: usize,
2182 depth: fidl::encoding::Depth,
2183 ) -> fidl::Result<()> {
2184 encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2185 self.0.encode(encoder, offset + 0, depth)?;
2189 Ok(())
2190 }
2191 }
2192
2193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2194 for ControlRemoveAddressRequest
2195 {
2196 #[inline(always)]
2197 fn new_empty() -> Self {
2198 Self { address: fidl::new_empty!(fidl_fuchsia_net::Subnet, D) }
2199 }
2200
2201 #[inline]
2202 unsafe fn decode(
2203 &mut self,
2204 decoder: &mut fidl::encoding::Decoder<'_, D>,
2205 offset: usize,
2206 _depth: fidl::encoding::Depth,
2207 ) -> fidl::Result<()> {
2208 decoder.debug_check_bounds::<Self>(offset);
2209 fidl::decode!(
2211 fidl_fuchsia_net::Subnet,
2212 D,
2213 &mut self.address,
2214 decoder,
2215 offset + 0,
2216 _depth
2217 )?;
2218 Ok(())
2219 }
2220 }
2221
2222 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationRequest {
2223 type Borrowed<'a> = &'a Self;
2224 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2225 value
2226 }
2227 }
2228
2229 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationRequest {
2230 type Owned = Self;
2231
2232 #[inline(always)]
2233 fn inline_align(_context: fidl::encoding::Context) -> usize {
2234 8
2235 }
2236
2237 #[inline(always)]
2238 fn inline_size(_context: fidl::encoding::Context) -> usize {
2239 16
2240 }
2241 }
2242
2243 unsafe impl<D: fidl::encoding::ResourceDialect>
2244 fidl::encoding::Encode<ControlSetConfigurationRequest, D>
2245 for &ControlSetConfigurationRequest
2246 {
2247 #[inline]
2248 unsafe fn encode(
2249 self,
2250 encoder: &mut fidl::encoding::Encoder<'_, D>,
2251 offset: usize,
2252 _depth: fidl::encoding::Depth,
2253 ) -> fidl::Result<()> {
2254 encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2255 fidl::encoding::Encode::<ControlSetConfigurationRequest, D>::encode(
2257 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2258 encoder,
2259 offset,
2260 _depth,
2261 )
2262 }
2263 }
2264 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2265 fidl::encoding::Encode<ControlSetConfigurationRequest, D> for (T0,)
2266 {
2267 #[inline]
2268 unsafe fn encode(
2269 self,
2270 encoder: &mut fidl::encoding::Encoder<'_, D>,
2271 offset: usize,
2272 depth: fidl::encoding::Depth,
2273 ) -> fidl::Result<()> {
2274 encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2275 self.0.encode(encoder, offset + 0, depth)?;
2279 Ok(())
2280 }
2281 }
2282
2283 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2284 for ControlSetConfigurationRequest
2285 {
2286 #[inline(always)]
2287 fn new_empty() -> Self {
2288 Self { config: fidl::new_empty!(Configuration, D) }
2289 }
2290
2291 #[inline]
2292 unsafe fn decode(
2293 &mut self,
2294 decoder: &mut fidl::encoding::Decoder<'_, D>,
2295 offset: usize,
2296 _depth: fidl::encoding::Depth,
2297 ) -> fidl::Result<()> {
2298 decoder.debug_check_bounds::<Self>(offset);
2299 fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2301 Ok(())
2302 }
2303 }
2304
2305 impl fidl::encoding::ValueTypeMarker for ControlDisableResponse {
2306 type Borrowed<'a> = &'a Self;
2307 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2308 value
2309 }
2310 }
2311
2312 unsafe impl fidl::encoding::TypeMarker for ControlDisableResponse {
2313 type Owned = Self;
2314
2315 #[inline(always)]
2316 fn inline_align(_context: fidl::encoding::Context) -> usize {
2317 1
2318 }
2319
2320 #[inline(always)]
2321 fn inline_size(_context: fidl::encoding::Context) -> usize {
2322 1
2323 }
2324 }
2325
2326 unsafe impl<D: fidl::encoding::ResourceDialect>
2327 fidl::encoding::Encode<ControlDisableResponse, D> for &ControlDisableResponse
2328 {
2329 #[inline]
2330 unsafe fn encode(
2331 self,
2332 encoder: &mut fidl::encoding::Encoder<'_, D>,
2333 offset: usize,
2334 _depth: fidl::encoding::Depth,
2335 ) -> fidl::Result<()> {
2336 encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2337 fidl::encoding::Encode::<ControlDisableResponse, D>::encode(
2339 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_disable),),
2340 encoder,
2341 offset,
2342 _depth,
2343 )
2344 }
2345 }
2346 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2347 fidl::encoding::Encode<ControlDisableResponse, D> for (T0,)
2348 {
2349 #[inline]
2350 unsafe fn encode(
2351 self,
2352 encoder: &mut fidl::encoding::Encoder<'_, D>,
2353 offset: usize,
2354 depth: fidl::encoding::Depth,
2355 ) -> fidl::Result<()> {
2356 encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2357 self.0.encode(encoder, offset + 0, depth)?;
2361 Ok(())
2362 }
2363 }
2364
2365 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2366 for ControlDisableResponse
2367 {
2368 #[inline(always)]
2369 fn new_empty() -> Self {
2370 Self { did_disable: fidl::new_empty!(bool, D) }
2371 }
2372
2373 #[inline]
2374 unsafe fn decode(
2375 &mut self,
2376 decoder: &mut fidl::encoding::Decoder<'_, D>,
2377 offset: usize,
2378 _depth: fidl::encoding::Depth,
2379 ) -> fidl::Result<()> {
2380 decoder.debug_check_bounds::<Self>(offset);
2381 fidl::decode!(bool, D, &mut self.did_disable, decoder, offset + 0, _depth)?;
2383 Ok(())
2384 }
2385 }
2386
2387 impl fidl::encoding::ValueTypeMarker for ControlEnableResponse {
2388 type Borrowed<'a> = &'a Self;
2389 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2390 value
2391 }
2392 }
2393
2394 unsafe impl fidl::encoding::TypeMarker for ControlEnableResponse {
2395 type Owned = Self;
2396
2397 #[inline(always)]
2398 fn inline_align(_context: fidl::encoding::Context) -> usize {
2399 1
2400 }
2401
2402 #[inline(always)]
2403 fn inline_size(_context: fidl::encoding::Context) -> usize {
2404 1
2405 }
2406 }
2407
2408 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlEnableResponse, D>
2409 for &ControlEnableResponse
2410 {
2411 #[inline]
2412 unsafe fn encode(
2413 self,
2414 encoder: &mut fidl::encoding::Encoder<'_, D>,
2415 offset: usize,
2416 _depth: fidl::encoding::Depth,
2417 ) -> fidl::Result<()> {
2418 encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2419 fidl::encoding::Encode::<ControlEnableResponse, D>::encode(
2421 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_enable),),
2422 encoder,
2423 offset,
2424 _depth,
2425 )
2426 }
2427 }
2428 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2429 fidl::encoding::Encode<ControlEnableResponse, D> for (T0,)
2430 {
2431 #[inline]
2432 unsafe fn encode(
2433 self,
2434 encoder: &mut fidl::encoding::Encoder<'_, D>,
2435 offset: usize,
2436 depth: fidl::encoding::Depth,
2437 ) -> fidl::Result<()> {
2438 encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2439 self.0.encode(encoder, offset + 0, depth)?;
2443 Ok(())
2444 }
2445 }
2446
2447 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableResponse {
2448 #[inline(always)]
2449 fn new_empty() -> Self {
2450 Self { did_enable: fidl::new_empty!(bool, D) }
2451 }
2452
2453 #[inline]
2454 unsafe fn decode(
2455 &mut self,
2456 decoder: &mut fidl::encoding::Decoder<'_, D>,
2457 offset: usize,
2458 _depth: fidl::encoding::Depth,
2459 ) -> fidl::Result<()> {
2460 decoder.debug_check_bounds::<Self>(offset);
2461 fidl::decode!(bool, D, &mut self.did_enable, decoder, offset + 0, _depth)?;
2463 Ok(())
2464 }
2465 }
2466
2467 impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationResponse {
2468 type Borrowed<'a> = &'a Self;
2469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2470 value
2471 }
2472 }
2473
2474 unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationResponse {
2475 type Owned = Self;
2476
2477 #[inline(always)]
2478 fn inline_align(_context: fidl::encoding::Context) -> usize {
2479 8
2480 }
2481
2482 #[inline(always)]
2483 fn inline_size(_context: fidl::encoding::Context) -> usize {
2484 16
2485 }
2486 }
2487
2488 unsafe impl<D: fidl::encoding::ResourceDialect>
2489 fidl::encoding::Encode<ControlGetConfigurationResponse, D>
2490 for &ControlGetConfigurationResponse
2491 {
2492 #[inline]
2493 unsafe fn encode(
2494 self,
2495 encoder: &mut fidl::encoding::Encoder<'_, D>,
2496 offset: usize,
2497 _depth: fidl::encoding::Depth,
2498 ) -> fidl::Result<()> {
2499 encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2500 fidl::encoding::Encode::<ControlGetConfigurationResponse, D>::encode(
2502 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2503 encoder,
2504 offset,
2505 _depth,
2506 )
2507 }
2508 }
2509 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2510 fidl::encoding::Encode<ControlGetConfigurationResponse, D> for (T0,)
2511 {
2512 #[inline]
2513 unsafe fn encode(
2514 self,
2515 encoder: &mut fidl::encoding::Encoder<'_, D>,
2516 offset: usize,
2517 depth: fidl::encoding::Depth,
2518 ) -> fidl::Result<()> {
2519 encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2520 self.0.encode(encoder, offset + 0, depth)?;
2524 Ok(())
2525 }
2526 }
2527
2528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2529 for ControlGetConfigurationResponse
2530 {
2531 #[inline(always)]
2532 fn new_empty() -> Self {
2533 Self { config: fidl::new_empty!(Configuration, D) }
2534 }
2535
2536 #[inline]
2537 unsafe fn decode(
2538 &mut self,
2539 decoder: &mut fidl::encoding::Decoder<'_, D>,
2540 offset: usize,
2541 _depth: fidl::encoding::Depth,
2542 ) -> fidl::Result<()> {
2543 decoder.debug_check_bounds::<Self>(offset);
2544 fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2546 Ok(())
2547 }
2548 }
2549
2550 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressResponse {
2551 type Borrowed<'a> = &'a Self;
2552 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2553 value
2554 }
2555 }
2556
2557 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressResponse {
2558 type Owned = Self;
2559
2560 #[inline(always)]
2561 fn inline_align(_context: fidl::encoding::Context) -> usize {
2562 1
2563 }
2564
2565 #[inline(always)]
2566 fn inline_size(_context: fidl::encoding::Context) -> usize {
2567 1
2568 }
2569 }
2570
2571 unsafe impl<D: fidl::encoding::ResourceDialect>
2572 fidl::encoding::Encode<ControlRemoveAddressResponse, D> for &ControlRemoveAddressResponse
2573 {
2574 #[inline]
2575 unsafe fn encode(
2576 self,
2577 encoder: &mut fidl::encoding::Encoder<'_, D>,
2578 offset: usize,
2579 _depth: fidl::encoding::Depth,
2580 ) -> fidl::Result<()> {
2581 encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2582 fidl::encoding::Encode::<ControlRemoveAddressResponse, D>::encode(
2584 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_remove),),
2585 encoder,
2586 offset,
2587 _depth,
2588 )
2589 }
2590 }
2591 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2592 fidl::encoding::Encode<ControlRemoveAddressResponse, D> for (T0,)
2593 {
2594 #[inline]
2595 unsafe fn encode(
2596 self,
2597 encoder: &mut fidl::encoding::Encoder<'_, D>,
2598 offset: usize,
2599 depth: fidl::encoding::Depth,
2600 ) -> fidl::Result<()> {
2601 encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2602 self.0.encode(encoder, offset + 0, depth)?;
2606 Ok(())
2607 }
2608 }
2609
2610 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2611 for ControlRemoveAddressResponse
2612 {
2613 #[inline(always)]
2614 fn new_empty() -> Self {
2615 Self { did_remove: fidl::new_empty!(bool, D) }
2616 }
2617
2618 #[inline]
2619 unsafe fn decode(
2620 &mut self,
2621 decoder: &mut fidl::encoding::Decoder<'_, D>,
2622 offset: usize,
2623 _depth: fidl::encoding::Depth,
2624 ) -> fidl::Result<()> {
2625 decoder.debug_check_bounds::<Self>(offset);
2626 fidl::decode!(bool, D, &mut self.did_remove, decoder, offset + 0, _depth)?;
2628 Ok(())
2629 }
2630 }
2631
2632 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationResponse {
2633 type Borrowed<'a> = &'a Self;
2634 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2635 value
2636 }
2637 }
2638
2639 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationResponse {
2640 type Owned = Self;
2641
2642 #[inline(always)]
2643 fn inline_align(_context: fidl::encoding::Context) -> usize {
2644 8
2645 }
2646
2647 #[inline(always)]
2648 fn inline_size(_context: fidl::encoding::Context) -> usize {
2649 16
2650 }
2651 }
2652
2653 unsafe impl<D: fidl::encoding::ResourceDialect>
2654 fidl::encoding::Encode<ControlSetConfigurationResponse, D>
2655 for &ControlSetConfigurationResponse
2656 {
2657 #[inline]
2658 unsafe fn encode(
2659 self,
2660 encoder: &mut fidl::encoding::Encoder<'_, D>,
2661 offset: usize,
2662 _depth: fidl::encoding::Depth,
2663 ) -> fidl::Result<()> {
2664 encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2665 fidl::encoding::Encode::<ControlSetConfigurationResponse, D>::encode(
2667 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.previous_config),),
2668 encoder,
2669 offset,
2670 _depth,
2671 )
2672 }
2673 }
2674 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2675 fidl::encoding::Encode<ControlSetConfigurationResponse, D> for (T0,)
2676 {
2677 #[inline]
2678 unsafe fn encode(
2679 self,
2680 encoder: &mut fidl::encoding::Encoder<'_, D>,
2681 offset: usize,
2682 depth: fidl::encoding::Depth,
2683 ) -> fidl::Result<()> {
2684 encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2685 self.0.encode(encoder, offset + 0, depth)?;
2689 Ok(())
2690 }
2691 }
2692
2693 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2694 for ControlSetConfigurationResponse
2695 {
2696 #[inline(always)]
2697 fn new_empty() -> Self {
2698 Self { previous_config: fidl::new_empty!(Configuration, D) }
2699 }
2700
2701 #[inline]
2702 unsafe fn decode(
2703 &mut self,
2704 decoder: &mut fidl::encoding::Decoder<'_, D>,
2705 offset: usize,
2706 _depth: fidl::encoding::Depth,
2707 ) -> fidl::Result<()> {
2708 decoder.debug_check_bounds::<Self>(offset);
2709 fidl::decode!(
2711 Configuration,
2712 D,
2713 &mut self.previous_config,
2714 decoder,
2715 offset + 0,
2716 _depth
2717 )?;
2718 Ok(())
2719 }
2720 }
2721
2722 impl fidl::encoding::ValueTypeMarker for Empty {
2723 type Borrowed<'a> = &'a Self;
2724 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2725 value
2726 }
2727 }
2728
2729 unsafe impl fidl::encoding::TypeMarker for Empty {
2730 type Owned = Self;
2731
2732 #[inline(always)]
2733 fn inline_align(_context: fidl::encoding::Context) -> usize {
2734 1
2735 }
2736
2737 #[inline(always)]
2738 fn inline_size(_context: fidl::encoding::Context) -> usize {
2739 1
2740 }
2741 }
2742
2743 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
2744 #[inline]
2745 unsafe fn encode(
2746 self,
2747 encoder: &mut fidl::encoding::Encoder<'_, D>,
2748 offset: usize,
2749 _depth: fidl::encoding::Depth,
2750 ) -> fidl::Result<()> {
2751 encoder.debug_check_bounds::<Empty>(offset);
2752 encoder.write_num(0u8, offset);
2753 Ok(())
2754 }
2755 }
2756
2757 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
2758 #[inline(always)]
2759 fn new_empty() -> Self {
2760 Self
2761 }
2762
2763 #[inline]
2764 unsafe fn decode(
2765 &mut self,
2766 decoder: &mut fidl::encoding::Decoder<'_, D>,
2767 offset: usize,
2768 _depth: fidl::encoding::Depth,
2769 ) -> fidl::Result<()> {
2770 decoder.debug_check_bounds::<Self>(offset);
2771 match decoder.read_num::<u8>(offset) {
2772 0 => Ok(()),
2773 _ => Err(fidl::Error::Invalid),
2774 }
2775 }
2776 }
2777
2778 impl AddressParameters {
2779 #[inline(always)]
2780 fn max_ordinal_present(&self) -> u64 {
2781 if let Some(_) = self.perform_dad {
2782 return 4;
2783 }
2784 if let Some(_) = self.add_subnet_route {
2785 return 3;
2786 }
2787 if let Some(_) = self.temporary {
2788 return 2;
2789 }
2790 if let Some(_) = self.initial_properties {
2791 return 1;
2792 }
2793 0
2794 }
2795 }
2796
2797 impl fidl::encoding::ValueTypeMarker for AddressParameters {
2798 type Borrowed<'a> = &'a Self;
2799 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2800 value
2801 }
2802 }
2803
2804 unsafe impl fidl::encoding::TypeMarker for AddressParameters {
2805 type Owned = Self;
2806
2807 #[inline(always)]
2808 fn inline_align(_context: fidl::encoding::Context) -> usize {
2809 8
2810 }
2811
2812 #[inline(always)]
2813 fn inline_size(_context: fidl::encoding::Context) -> usize {
2814 16
2815 }
2816 }
2817
2818 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressParameters, D>
2819 for &AddressParameters
2820 {
2821 unsafe fn encode(
2822 self,
2823 encoder: &mut fidl::encoding::Encoder<'_, D>,
2824 offset: usize,
2825 mut depth: fidl::encoding::Depth,
2826 ) -> fidl::Result<()> {
2827 encoder.debug_check_bounds::<AddressParameters>(offset);
2828 let max_ordinal: u64 = self.max_ordinal_present();
2830 encoder.write_num(max_ordinal, offset);
2831 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2832 if max_ordinal == 0 {
2834 return Ok(());
2835 }
2836 depth.increment()?;
2837 let envelope_size = 8;
2838 let bytes_len = max_ordinal as usize * envelope_size;
2839 #[allow(unused_variables)]
2840 let offset = encoder.out_of_line_offset(bytes_len);
2841 let mut _prev_end_offset: usize = 0;
2842 if 1 > max_ordinal {
2843 return Ok(());
2844 }
2845
2846 let cur_offset: usize = (1 - 1) * envelope_size;
2849
2850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2852
2853 fidl::encoding::encode_in_envelope_optional::<AddressProperties, D>(
2858 self.initial_properties
2859 .as_ref()
2860 .map(<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow),
2861 encoder,
2862 offset + cur_offset,
2863 depth,
2864 )?;
2865
2866 _prev_end_offset = cur_offset + envelope_size;
2867 if 2 > max_ordinal {
2868 return Ok(());
2869 }
2870
2871 let cur_offset: usize = (2 - 1) * envelope_size;
2874
2875 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2877
2878 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2883 self.temporary.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2884 encoder,
2885 offset + cur_offset,
2886 depth,
2887 )?;
2888
2889 _prev_end_offset = cur_offset + envelope_size;
2890 if 3 > max_ordinal {
2891 return Ok(());
2892 }
2893
2894 let cur_offset: usize = (3 - 1) * envelope_size;
2897
2898 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2900
2901 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2906 self.add_subnet_route
2907 .as_ref()
2908 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2909 encoder,
2910 offset + cur_offset,
2911 depth,
2912 )?;
2913
2914 _prev_end_offset = cur_offset + envelope_size;
2915 if 4 > max_ordinal {
2916 return Ok(());
2917 }
2918
2919 let cur_offset: usize = (4 - 1) * envelope_size;
2922
2923 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2925
2926 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2931 self.perform_dad.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2932 encoder,
2933 offset + cur_offset,
2934 depth,
2935 )?;
2936
2937 _prev_end_offset = cur_offset + envelope_size;
2938
2939 Ok(())
2940 }
2941 }
2942
2943 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressParameters {
2944 #[inline(always)]
2945 fn new_empty() -> Self {
2946 Self::default()
2947 }
2948
2949 unsafe fn decode(
2950 &mut self,
2951 decoder: &mut fidl::encoding::Decoder<'_, D>,
2952 offset: usize,
2953 mut depth: fidl::encoding::Depth,
2954 ) -> fidl::Result<()> {
2955 decoder.debug_check_bounds::<Self>(offset);
2956 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2957 None => return Err(fidl::Error::NotNullable),
2958 Some(len) => len,
2959 };
2960 if len == 0 {
2962 return Ok(());
2963 };
2964 depth.increment()?;
2965 let envelope_size = 8;
2966 let bytes_len = len * envelope_size;
2967 let offset = decoder.out_of_line_offset(bytes_len)?;
2968 let mut _next_ordinal_to_read = 0;
2970 let mut next_offset = offset;
2971 let end_offset = offset + bytes_len;
2972 _next_ordinal_to_read += 1;
2973 if next_offset >= end_offset {
2974 return Ok(());
2975 }
2976
2977 while _next_ordinal_to_read < 1 {
2979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2980 _next_ordinal_to_read += 1;
2981 next_offset += envelope_size;
2982 }
2983
2984 let next_out_of_line = decoder.next_out_of_line();
2985 let handles_before = decoder.remaining_handles();
2986 if let Some((inlined, num_bytes, num_handles)) =
2987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2988 {
2989 let member_inline_size =
2990 <AddressProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2991 if inlined != (member_inline_size <= 4) {
2992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2993 }
2994 let inner_offset;
2995 let mut inner_depth = depth.clone();
2996 if inlined {
2997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2998 inner_offset = next_offset;
2999 } else {
3000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3001 inner_depth.increment()?;
3002 }
3003 let val_ref = self
3004 .initial_properties
3005 .get_or_insert_with(|| fidl::new_empty!(AddressProperties, D));
3006 fidl::decode!(AddressProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3007 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3008 {
3009 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3010 }
3011 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3012 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3013 }
3014 }
3015
3016 next_offset += envelope_size;
3017 _next_ordinal_to_read += 1;
3018 if next_offset >= end_offset {
3019 return Ok(());
3020 }
3021
3022 while _next_ordinal_to_read < 2 {
3024 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3025 _next_ordinal_to_read += 1;
3026 next_offset += envelope_size;
3027 }
3028
3029 let next_out_of_line = decoder.next_out_of_line();
3030 let handles_before = decoder.remaining_handles();
3031 if let Some((inlined, num_bytes, num_handles)) =
3032 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3033 {
3034 let member_inline_size =
3035 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3036 if inlined != (member_inline_size <= 4) {
3037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3038 }
3039 let inner_offset;
3040 let mut inner_depth = depth.clone();
3041 if inlined {
3042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3043 inner_offset = next_offset;
3044 } else {
3045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3046 inner_depth.increment()?;
3047 }
3048 let val_ref = self.temporary.get_or_insert_with(|| fidl::new_empty!(bool, D));
3049 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3050 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3051 {
3052 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3053 }
3054 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3055 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3056 }
3057 }
3058
3059 next_offset += envelope_size;
3060 _next_ordinal_to_read += 1;
3061 if next_offset >= end_offset {
3062 return Ok(());
3063 }
3064
3065 while _next_ordinal_to_read < 3 {
3067 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3068 _next_ordinal_to_read += 1;
3069 next_offset += envelope_size;
3070 }
3071
3072 let next_out_of_line = decoder.next_out_of_line();
3073 let handles_before = decoder.remaining_handles();
3074 if let Some((inlined, num_bytes, num_handles)) =
3075 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3076 {
3077 let member_inline_size =
3078 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3079 if inlined != (member_inline_size <= 4) {
3080 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3081 }
3082 let inner_offset;
3083 let mut inner_depth = depth.clone();
3084 if inlined {
3085 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3086 inner_offset = next_offset;
3087 } else {
3088 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3089 inner_depth.increment()?;
3090 }
3091 let val_ref =
3092 self.add_subnet_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
3093 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3094 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3095 {
3096 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3097 }
3098 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3099 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3100 }
3101 }
3102
3103 next_offset += envelope_size;
3104 _next_ordinal_to_read += 1;
3105 if next_offset >= end_offset {
3106 return Ok(());
3107 }
3108
3109 while _next_ordinal_to_read < 4 {
3111 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3112 _next_ordinal_to_read += 1;
3113 next_offset += envelope_size;
3114 }
3115
3116 let next_out_of_line = decoder.next_out_of_line();
3117 let handles_before = decoder.remaining_handles();
3118 if let Some((inlined, num_bytes, num_handles)) =
3119 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3120 {
3121 let member_inline_size =
3122 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3123 if inlined != (member_inline_size <= 4) {
3124 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3125 }
3126 let inner_offset;
3127 let mut inner_depth = depth.clone();
3128 if inlined {
3129 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3130 inner_offset = next_offset;
3131 } else {
3132 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3133 inner_depth.increment()?;
3134 }
3135 let val_ref = self.perform_dad.get_or_insert_with(|| fidl::new_empty!(bool, D));
3136 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3137 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3138 {
3139 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3140 }
3141 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3142 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3143 }
3144 }
3145
3146 next_offset += envelope_size;
3147
3148 while next_offset < end_offset {
3150 _next_ordinal_to_read += 1;
3151 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3152 next_offset += envelope_size;
3153 }
3154
3155 Ok(())
3156 }
3157 }
3158
3159 impl AddressProperties {
3160 #[inline(always)]
3161 fn max_ordinal_present(&self) -> u64 {
3162 if let Some(_) = self.valid_lifetime_end {
3163 return 2;
3164 }
3165 if let Some(_) = self.preferred_lifetime_info {
3166 return 1;
3167 }
3168 0
3169 }
3170 }
3171
3172 impl fidl::encoding::ValueTypeMarker for AddressProperties {
3173 type Borrowed<'a> = &'a Self;
3174 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3175 value
3176 }
3177 }
3178
3179 unsafe impl fidl::encoding::TypeMarker for AddressProperties {
3180 type Owned = Self;
3181
3182 #[inline(always)]
3183 fn inline_align(_context: fidl::encoding::Context) -> usize {
3184 8
3185 }
3186
3187 #[inline(always)]
3188 fn inline_size(_context: fidl::encoding::Context) -> usize {
3189 16
3190 }
3191 }
3192
3193 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressProperties, D>
3194 for &AddressProperties
3195 {
3196 unsafe fn encode(
3197 self,
3198 encoder: &mut fidl::encoding::Encoder<'_, D>,
3199 offset: usize,
3200 mut depth: fidl::encoding::Depth,
3201 ) -> fidl::Result<()> {
3202 encoder.debug_check_bounds::<AddressProperties>(offset);
3203 let max_ordinal: u64 = self.max_ordinal_present();
3205 encoder.write_num(max_ordinal, offset);
3206 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3207 if max_ordinal == 0 {
3209 return Ok(());
3210 }
3211 depth.increment()?;
3212 let envelope_size = 8;
3213 let bytes_len = max_ordinal as usize * envelope_size;
3214 #[allow(unused_variables)]
3215 let offset = encoder.out_of_line_offset(bytes_len);
3216 let mut _prev_end_offset: usize = 0;
3217 if 1 > max_ordinal {
3218 return Ok(());
3219 }
3220
3221 let cur_offset: usize = (1 - 1) * envelope_size;
3224
3225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3227
3228 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net_interfaces::PreferredLifetimeInfo, D>(
3233 self.preferred_lifetime_info.as_ref().map(<fidl_fuchsia_net_interfaces::PreferredLifetimeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3234 encoder, offset + cur_offset, depth
3235 )?;
3236
3237 _prev_end_offset = cur_offset + envelope_size;
3238 if 2 > max_ordinal {
3239 return Ok(());
3240 }
3241
3242 let cur_offset: usize = (2 - 1) * envelope_size;
3245
3246 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3248
3249 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3254 self.valid_lifetime_end
3255 .as_ref()
3256 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3257 encoder,
3258 offset + cur_offset,
3259 depth,
3260 )?;
3261
3262 _prev_end_offset = cur_offset + envelope_size;
3263
3264 Ok(())
3265 }
3266 }
3267
3268 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressProperties {
3269 #[inline(always)]
3270 fn new_empty() -> Self {
3271 Self::default()
3272 }
3273
3274 unsafe fn decode(
3275 &mut self,
3276 decoder: &mut fidl::encoding::Decoder<'_, D>,
3277 offset: usize,
3278 mut depth: fidl::encoding::Depth,
3279 ) -> fidl::Result<()> {
3280 decoder.debug_check_bounds::<Self>(offset);
3281 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3282 None => return Err(fidl::Error::NotNullable),
3283 Some(len) => len,
3284 };
3285 if len == 0 {
3287 return Ok(());
3288 };
3289 depth.increment()?;
3290 let envelope_size = 8;
3291 let bytes_len = len * envelope_size;
3292 let offset = decoder.out_of_line_offset(bytes_len)?;
3293 let mut _next_ordinal_to_read = 0;
3295 let mut next_offset = offset;
3296 let end_offset = offset + bytes_len;
3297 _next_ordinal_to_read += 1;
3298 if next_offset >= end_offset {
3299 return Ok(());
3300 }
3301
3302 while _next_ordinal_to_read < 1 {
3304 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3305 _next_ordinal_to_read += 1;
3306 next_offset += envelope_size;
3307 }
3308
3309 let next_out_of_line = decoder.next_out_of_line();
3310 let handles_before = decoder.remaining_handles();
3311 if let Some((inlined, num_bytes, num_handles)) =
3312 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3313 {
3314 let member_inline_size = <fidl_fuchsia_net_interfaces::PreferredLifetimeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3315 if inlined != (member_inline_size <= 4) {
3316 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3317 }
3318 let inner_offset;
3319 let mut inner_depth = depth.clone();
3320 if inlined {
3321 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3322 inner_offset = next_offset;
3323 } else {
3324 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3325 inner_depth.increment()?;
3326 }
3327 let val_ref = self.preferred_lifetime_info.get_or_insert_with(|| {
3328 fidl::new_empty!(fidl_fuchsia_net_interfaces::PreferredLifetimeInfo, D)
3329 });
3330 fidl::decode!(
3331 fidl_fuchsia_net_interfaces::PreferredLifetimeInfo,
3332 D,
3333 val_ref,
3334 decoder,
3335 inner_offset,
3336 inner_depth
3337 )?;
3338 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3339 {
3340 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3341 }
3342 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3343 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3344 }
3345 }
3346
3347 next_offset += envelope_size;
3348 _next_ordinal_to_read += 1;
3349 if next_offset >= end_offset {
3350 return Ok(());
3351 }
3352
3353 while _next_ordinal_to_read < 2 {
3355 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3356 _next_ordinal_to_read += 1;
3357 next_offset += envelope_size;
3358 }
3359
3360 let next_out_of_line = decoder.next_out_of_line();
3361 let handles_before = decoder.remaining_handles();
3362 if let Some((inlined, num_bytes, num_handles)) =
3363 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3364 {
3365 let member_inline_size =
3366 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3367 if inlined != (member_inline_size <= 4) {
3368 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3369 }
3370 let inner_offset;
3371 let mut inner_depth = depth.clone();
3372 if inlined {
3373 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3374 inner_offset = next_offset;
3375 } else {
3376 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3377 inner_depth.increment()?;
3378 }
3379 let val_ref =
3380 self.valid_lifetime_end.get_or_insert_with(|| fidl::new_empty!(i64, D));
3381 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3382 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3383 {
3384 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3385 }
3386 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3387 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3388 }
3389 }
3390
3391 next_offset += envelope_size;
3392
3393 while next_offset < end_offset {
3395 _next_ordinal_to_read += 1;
3396 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3397 next_offset += envelope_size;
3398 }
3399
3400 Ok(())
3401 }
3402 }
3403
3404 impl ArpConfiguration {
3405 #[inline(always)]
3406 fn max_ordinal_present(&self) -> u64 {
3407 if let Some(_) = self.dad {
3408 return 2;
3409 }
3410 if let Some(_) = self.nud {
3411 return 1;
3412 }
3413 0
3414 }
3415 }
3416
3417 impl fidl::encoding::ValueTypeMarker for ArpConfiguration {
3418 type Borrowed<'a> = &'a Self;
3419 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3420 value
3421 }
3422 }
3423
3424 unsafe impl fidl::encoding::TypeMarker for ArpConfiguration {
3425 type Owned = Self;
3426
3427 #[inline(always)]
3428 fn inline_align(_context: fidl::encoding::Context) -> usize {
3429 8
3430 }
3431
3432 #[inline(always)]
3433 fn inline_size(_context: fidl::encoding::Context) -> usize {
3434 16
3435 }
3436 }
3437
3438 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ArpConfiguration, D>
3439 for &ArpConfiguration
3440 {
3441 unsafe fn encode(
3442 self,
3443 encoder: &mut fidl::encoding::Encoder<'_, D>,
3444 offset: usize,
3445 mut depth: fidl::encoding::Depth,
3446 ) -> fidl::Result<()> {
3447 encoder.debug_check_bounds::<ArpConfiguration>(offset);
3448 let max_ordinal: u64 = self.max_ordinal_present();
3450 encoder.write_num(max_ordinal, offset);
3451 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3452 if max_ordinal == 0 {
3454 return Ok(());
3455 }
3456 depth.increment()?;
3457 let envelope_size = 8;
3458 let bytes_len = max_ordinal as usize * envelope_size;
3459 #[allow(unused_variables)]
3460 let offset = encoder.out_of_line_offset(bytes_len);
3461 let mut _prev_end_offset: usize = 0;
3462 if 1 > max_ordinal {
3463 return Ok(());
3464 }
3465
3466 let cur_offset: usize = (1 - 1) * envelope_size;
3469
3470 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3472
3473 fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
3478 self.nud
3479 .as_ref()
3480 .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3481 encoder,
3482 offset + cur_offset,
3483 depth,
3484 )?;
3485
3486 _prev_end_offset = cur_offset + envelope_size;
3487 if 2 > max_ordinal {
3488 return Ok(());
3489 }
3490
3491 let cur_offset: usize = (2 - 1) * envelope_size;
3494
3495 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3497
3498 fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
3503 self.dad
3504 .as_ref()
3505 .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3506 encoder,
3507 offset + cur_offset,
3508 depth,
3509 )?;
3510
3511 _prev_end_offset = cur_offset + envelope_size;
3512
3513 Ok(())
3514 }
3515 }
3516
3517 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ArpConfiguration {
3518 #[inline(always)]
3519 fn new_empty() -> Self {
3520 Self::default()
3521 }
3522
3523 unsafe fn decode(
3524 &mut self,
3525 decoder: &mut fidl::encoding::Decoder<'_, D>,
3526 offset: usize,
3527 mut depth: fidl::encoding::Depth,
3528 ) -> fidl::Result<()> {
3529 decoder.debug_check_bounds::<Self>(offset);
3530 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3531 None => return Err(fidl::Error::NotNullable),
3532 Some(len) => len,
3533 };
3534 if len == 0 {
3536 return Ok(());
3537 };
3538 depth.increment()?;
3539 let envelope_size = 8;
3540 let bytes_len = len * envelope_size;
3541 let offset = decoder.out_of_line_offset(bytes_len)?;
3542 let mut _next_ordinal_to_read = 0;
3544 let mut next_offset = offset;
3545 let end_offset = offset + bytes_len;
3546 _next_ordinal_to_read += 1;
3547 if next_offset >= end_offset {
3548 return Ok(());
3549 }
3550
3551 while _next_ordinal_to_read < 1 {
3553 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3554 _next_ordinal_to_read += 1;
3555 next_offset += envelope_size;
3556 }
3557
3558 let next_out_of_line = decoder.next_out_of_line();
3559 let handles_before = decoder.remaining_handles();
3560 if let Some((inlined, num_bytes, num_handles)) =
3561 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3562 {
3563 let member_inline_size =
3564 <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3565 if inlined != (member_inline_size <= 4) {
3566 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3567 }
3568 let inner_offset;
3569 let mut inner_depth = depth.clone();
3570 if inlined {
3571 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3572 inner_offset = next_offset;
3573 } else {
3574 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3575 inner_depth.increment()?;
3576 }
3577 let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
3578 fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3579 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3580 {
3581 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3582 }
3583 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3584 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3585 }
3586 }
3587
3588 next_offset += envelope_size;
3589 _next_ordinal_to_read += 1;
3590 if next_offset >= end_offset {
3591 return Ok(());
3592 }
3593
3594 while _next_ordinal_to_read < 2 {
3596 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3597 _next_ordinal_to_read += 1;
3598 next_offset += envelope_size;
3599 }
3600
3601 let next_out_of_line = decoder.next_out_of_line();
3602 let handles_before = decoder.remaining_handles();
3603 if let Some((inlined, num_bytes, num_handles)) =
3604 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3605 {
3606 let member_inline_size =
3607 <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3608 if inlined != (member_inline_size <= 4) {
3609 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3610 }
3611 let inner_offset;
3612 let mut inner_depth = depth.clone();
3613 if inlined {
3614 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3615 inner_offset = next_offset;
3616 } else {
3617 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3618 inner_depth.increment()?;
3619 }
3620 let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
3621 fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3622 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3623 {
3624 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3625 }
3626 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3627 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3628 }
3629 }
3630
3631 next_offset += envelope_size;
3632
3633 while next_offset < end_offset {
3635 _next_ordinal_to_read += 1;
3636 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3637 next_offset += envelope_size;
3638 }
3639
3640 Ok(())
3641 }
3642 }
3643
3644 impl Configuration {
3645 #[inline(always)]
3646 fn max_ordinal_present(&self) -> u64 {
3647 if let Some(_) = self.ipv6 {
3648 return 2;
3649 }
3650 if let Some(_) = self.ipv4 {
3651 return 1;
3652 }
3653 0
3654 }
3655 }
3656
3657 impl fidl::encoding::ValueTypeMarker for Configuration {
3658 type Borrowed<'a> = &'a Self;
3659 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3660 value
3661 }
3662 }
3663
3664 unsafe impl fidl::encoding::TypeMarker for Configuration {
3665 type Owned = Self;
3666
3667 #[inline(always)]
3668 fn inline_align(_context: fidl::encoding::Context) -> usize {
3669 8
3670 }
3671
3672 #[inline(always)]
3673 fn inline_size(_context: fidl::encoding::Context) -> usize {
3674 16
3675 }
3676 }
3677
3678 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
3679 for &Configuration
3680 {
3681 unsafe fn encode(
3682 self,
3683 encoder: &mut fidl::encoding::Encoder<'_, D>,
3684 offset: usize,
3685 mut depth: fidl::encoding::Depth,
3686 ) -> fidl::Result<()> {
3687 encoder.debug_check_bounds::<Configuration>(offset);
3688 let max_ordinal: u64 = self.max_ordinal_present();
3690 encoder.write_num(max_ordinal, offset);
3691 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3692 if max_ordinal == 0 {
3694 return Ok(());
3695 }
3696 depth.increment()?;
3697 let envelope_size = 8;
3698 let bytes_len = max_ordinal as usize * envelope_size;
3699 #[allow(unused_variables)]
3700 let offset = encoder.out_of_line_offset(bytes_len);
3701 let mut _prev_end_offset: usize = 0;
3702 if 1 > max_ordinal {
3703 return Ok(());
3704 }
3705
3706 let cur_offset: usize = (1 - 1) * envelope_size;
3709
3710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3712
3713 fidl::encoding::encode_in_envelope_optional::<Ipv4Configuration, D>(
3718 self.ipv4
3719 .as_ref()
3720 .map(<Ipv4Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3721 encoder,
3722 offset + cur_offset,
3723 depth,
3724 )?;
3725
3726 _prev_end_offset = cur_offset + envelope_size;
3727 if 2 > max_ordinal {
3728 return Ok(());
3729 }
3730
3731 let cur_offset: usize = (2 - 1) * envelope_size;
3734
3735 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3737
3738 fidl::encoding::encode_in_envelope_optional::<Ipv6Configuration, D>(
3743 self.ipv6
3744 .as_ref()
3745 .map(<Ipv6Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3746 encoder,
3747 offset + cur_offset,
3748 depth,
3749 )?;
3750
3751 _prev_end_offset = cur_offset + envelope_size;
3752
3753 Ok(())
3754 }
3755 }
3756
3757 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
3758 #[inline(always)]
3759 fn new_empty() -> Self {
3760 Self::default()
3761 }
3762
3763 unsafe fn decode(
3764 &mut self,
3765 decoder: &mut fidl::encoding::Decoder<'_, D>,
3766 offset: usize,
3767 mut depth: fidl::encoding::Depth,
3768 ) -> fidl::Result<()> {
3769 decoder.debug_check_bounds::<Self>(offset);
3770 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3771 None => return Err(fidl::Error::NotNullable),
3772 Some(len) => len,
3773 };
3774 if len == 0 {
3776 return Ok(());
3777 };
3778 depth.increment()?;
3779 let envelope_size = 8;
3780 let bytes_len = len * envelope_size;
3781 let offset = decoder.out_of_line_offset(bytes_len)?;
3782 let mut _next_ordinal_to_read = 0;
3784 let mut next_offset = offset;
3785 let end_offset = offset + bytes_len;
3786 _next_ordinal_to_read += 1;
3787 if next_offset >= end_offset {
3788 return Ok(());
3789 }
3790
3791 while _next_ordinal_to_read < 1 {
3793 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3794 _next_ordinal_to_read += 1;
3795 next_offset += envelope_size;
3796 }
3797
3798 let next_out_of_line = decoder.next_out_of_line();
3799 let handles_before = decoder.remaining_handles();
3800 if let Some((inlined, num_bytes, num_handles)) =
3801 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3802 {
3803 let member_inline_size =
3804 <Ipv4Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3805 if inlined != (member_inline_size <= 4) {
3806 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3807 }
3808 let inner_offset;
3809 let mut inner_depth = depth.clone();
3810 if inlined {
3811 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3812 inner_offset = next_offset;
3813 } else {
3814 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3815 inner_depth.increment()?;
3816 }
3817 let val_ref =
3818 self.ipv4.get_or_insert_with(|| fidl::new_empty!(Ipv4Configuration, D));
3819 fidl::decode!(Ipv4Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3820 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3821 {
3822 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3823 }
3824 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3825 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3826 }
3827 }
3828
3829 next_offset += envelope_size;
3830 _next_ordinal_to_read += 1;
3831 if next_offset >= end_offset {
3832 return Ok(());
3833 }
3834
3835 while _next_ordinal_to_read < 2 {
3837 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3838 _next_ordinal_to_read += 1;
3839 next_offset += envelope_size;
3840 }
3841
3842 let next_out_of_line = decoder.next_out_of_line();
3843 let handles_before = decoder.remaining_handles();
3844 if let Some((inlined, num_bytes, num_handles)) =
3845 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3846 {
3847 let member_inline_size =
3848 <Ipv6Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3849 if inlined != (member_inline_size <= 4) {
3850 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3851 }
3852 let inner_offset;
3853 let mut inner_depth = depth.clone();
3854 if inlined {
3855 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3856 inner_offset = next_offset;
3857 } else {
3858 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3859 inner_depth.increment()?;
3860 }
3861 let val_ref =
3862 self.ipv6.get_or_insert_with(|| fidl::new_empty!(Ipv6Configuration, D));
3863 fidl::decode!(Ipv6Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3864 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3865 {
3866 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3867 }
3868 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3869 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3870 }
3871 }
3872
3873 next_offset += envelope_size;
3874
3875 while next_offset < end_offset {
3877 _next_ordinal_to_read += 1;
3878 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3879 next_offset += envelope_size;
3880 }
3881
3882 Ok(())
3883 }
3884 }
3885
3886 impl DadConfiguration {
3887 #[inline(always)]
3888 fn max_ordinal_present(&self) -> u64 {
3889 if let Some(_) = self.transmits {
3890 return 1;
3891 }
3892 0
3893 }
3894 }
3895
3896 impl fidl::encoding::ValueTypeMarker for DadConfiguration {
3897 type Borrowed<'a> = &'a Self;
3898 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3899 value
3900 }
3901 }
3902
3903 unsafe impl fidl::encoding::TypeMarker for DadConfiguration {
3904 type Owned = Self;
3905
3906 #[inline(always)]
3907 fn inline_align(_context: fidl::encoding::Context) -> usize {
3908 8
3909 }
3910
3911 #[inline(always)]
3912 fn inline_size(_context: fidl::encoding::Context) -> usize {
3913 16
3914 }
3915 }
3916
3917 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DadConfiguration, D>
3918 for &DadConfiguration
3919 {
3920 unsafe fn encode(
3921 self,
3922 encoder: &mut fidl::encoding::Encoder<'_, D>,
3923 offset: usize,
3924 mut depth: fidl::encoding::Depth,
3925 ) -> fidl::Result<()> {
3926 encoder.debug_check_bounds::<DadConfiguration>(offset);
3927 let max_ordinal: u64 = self.max_ordinal_present();
3929 encoder.write_num(max_ordinal, offset);
3930 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3931 if max_ordinal == 0 {
3933 return Ok(());
3934 }
3935 depth.increment()?;
3936 let envelope_size = 8;
3937 let bytes_len = max_ordinal as usize * envelope_size;
3938 #[allow(unused_variables)]
3939 let offset = encoder.out_of_line_offset(bytes_len);
3940 let mut _prev_end_offset: usize = 0;
3941 if 1 > max_ordinal {
3942 return Ok(());
3943 }
3944
3945 let cur_offset: usize = (1 - 1) * envelope_size;
3948
3949 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3951
3952 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3957 self.transmits.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3958 encoder,
3959 offset + cur_offset,
3960 depth,
3961 )?;
3962
3963 _prev_end_offset = cur_offset + envelope_size;
3964
3965 Ok(())
3966 }
3967 }
3968
3969 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DadConfiguration {
3970 #[inline(always)]
3971 fn new_empty() -> Self {
3972 Self::default()
3973 }
3974
3975 unsafe fn decode(
3976 &mut self,
3977 decoder: &mut fidl::encoding::Decoder<'_, D>,
3978 offset: usize,
3979 mut depth: fidl::encoding::Depth,
3980 ) -> fidl::Result<()> {
3981 decoder.debug_check_bounds::<Self>(offset);
3982 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3983 None => return Err(fidl::Error::NotNullable),
3984 Some(len) => len,
3985 };
3986 if len == 0 {
3988 return Ok(());
3989 };
3990 depth.increment()?;
3991 let envelope_size = 8;
3992 let bytes_len = len * envelope_size;
3993 let offset = decoder.out_of_line_offset(bytes_len)?;
3994 let mut _next_ordinal_to_read = 0;
3996 let mut next_offset = offset;
3997 let end_offset = offset + bytes_len;
3998 _next_ordinal_to_read += 1;
3999 if next_offset >= end_offset {
4000 return Ok(());
4001 }
4002
4003 while _next_ordinal_to_read < 1 {
4005 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4006 _next_ordinal_to_read += 1;
4007 next_offset += envelope_size;
4008 }
4009
4010 let next_out_of_line = decoder.next_out_of_line();
4011 let handles_before = decoder.remaining_handles();
4012 if let Some((inlined, num_bytes, num_handles)) =
4013 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4014 {
4015 let member_inline_size =
4016 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4017 if inlined != (member_inline_size <= 4) {
4018 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4019 }
4020 let inner_offset;
4021 let mut inner_depth = depth.clone();
4022 if inlined {
4023 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4024 inner_offset = next_offset;
4025 } else {
4026 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4027 inner_depth.increment()?;
4028 }
4029 let val_ref = self.transmits.get_or_insert_with(|| fidl::new_empty!(u16, D));
4030 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4031 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4032 {
4033 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4034 }
4035 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4036 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4037 }
4038 }
4039
4040 next_offset += envelope_size;
4041
4042 while next_offset < end_offset {
4044 _next_ordinal_to_read += 1;
4045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4046 next_offset += envelope_size;
4047 }
4048
4049 Ok(())
4050 }
4051 }
4052
4053 impl IgmpConfiguration {
4054 #[inline(always)]
4055 fn max_ordinal_present(&self) -> u64 {
4056 if let Some(_) = self.version {
4057 return 1;
4058 }
4059 0
4060 }
4061 }
4062
4063 impl fidl::encoding::ValueTypeMarker for IgmpConfiguration {
4064 type Borrowed<'a> = &'a Self;
4065 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4066 value
4067 }
4068 }
4069
4070 unsafe impl fidl::encoding::TypeMarker for IgmpConfiguration {
4071 type Owned = Self;
4072
4073 #[inline(always)]
4074 fn inline_align(_context: fidl::encoding::Context) -> usize {
4075 8
4076 }
4077
4078 #[inline(always)]
4079 fn inline_size(_context: fidl::encoding::Context) -> usize {
4080 16
4081 }
4082 }
4083
4084 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IgmpConfiguration, D>
4085 for &IgmpConfiguration
4086 {
4087 unsafe fn encode(
4088 self,
4089 encoder: &mut fidl::encoding::Encoder<'_, D>,
4090 offset: usize,
4091 mut depth: fidl::encoding::Depth,
4092 ) -> fidl::Result<()> {
4093 encoder.debug_check_bounds::<IgmpConfiguration>(offset);
4094 let max_ordinal: u64 = self.max_ordinal_present();
4096 encoder.write_num(max_ordinal, offset);
4097 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4098 if max_ordinal == 0 {
4100 return Ok(());
4101 }
4102 depth.increment()?;
4103 let envelope_size = 8;
4104 let bytes_len = max_ordinal as usize * envelope_size;
4105 #[allow(unused_variables)]
4106 let offset = encoder.out_of_line_offset(bytes_len);
4107 let mut _prev_end_offset: usize = 0;
4108 if 1 > max_ordinal {
4109 return Ok(());
4110 }
4111
4112 let cur_offset: usize = (1 - 1) * envelope_size;
4115
4116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4118
4119 fidl::encoding::encode_in_envelope_optional::<IgmpVersion, D>(
4124 self.version.as_ref().map(<IgmpVersion as fidl::encoding::ValueTypeMarker>::borrow),
4125 encoder,
4126 offset + cur_offset,
4127 depth,
4128 )?;
4129
4130 _prev_end_offset = cur_offset + envelope_size;
4131
4132 Ok(())
4133 }
4134 }
4135
4136 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpConfiguration {
4137 #[inline(always)]
4138 fn new_empty() -> Self {
4139 Self::default()
4140 }
4141
4142 unsafe fn decode(
4143 &mut self,
4144 decoder: &mut fidl::encoding::Decoder<'_, D>,
4145 offset: usize,
4146 mut depth: fidl::encoding::Depth,
4147 ) -> fidl::Result<()> {
4148 decoder.debug_check_bounds::<Self>(offset);
4149 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4150 None => return Err(fidl::Error::NotNullable),
4151 Some(len) => len,
4152 };
4153 if len == 0 {
4155 return Ok(());
4156 };
4157 depth.increment()?;
4158 let envelope_size = 8;
4159 let bytes_len = len * envelope_size;
4160 let offset = decoder.out_of_line_offset(bytes_len)?;
4161 let mut _next_ordinal_to_read = 0;
4163 let mut next_offset = offset;
4164 let end_offset = offset + bytes_len;
4165 _next_ordinal_to_read += 1;
4166 if next_offset >= end_offset {
4167 return Ok(());
4168 }
4169
4170 while _next_ordinal_to_read < 1 {
4172 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4173 _next_ordinal_to_read += 1;
4174 next_offset += envelope_size;
4175 }
4176
4177 let next_out_of_line = decoder.next_out_of_line();
4178 let handles_before = decoder.remaining_handles();
4179 if let Some((inlined, num_bytes, num_handles)) =
4180 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4181 {
4182 let member_inline_size =
4183 <IgmpVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4184 if inlined != (member_inline_size <= 4) {
4185 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4186 }
4187 let inner_offset;
4188 let mut inner_depth = depth.clone();
4189 if inlined {
4190 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4191 inner_offset = next_offset;
4192 } else {
4193 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4194 inner_depth.increment()?;
4195 }
4196 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(IgmpVersion, D));
4197 fidl::decode!(IgmpVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
4198 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4199 {
4200 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4201 }
4202 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4203 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4204 }
4205 }
4206
4207 next_offset += envelope_size;
4208
4209 while next_offset < end_offset {
4211 _next_ordinal_to_read += 1;
4212 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4213 next_offset += envelope_size;
4214 }
4215
4216 Ok(())
4217 }
4218 }
4219
4220 impl Ipv4Configuration {
4221 #[inline(always)]
4222 fn max_ordinal_present(&self) -> u64 {
4223 if let Some(_) = self.arp {
4224 return 4;
4225 }
4226 if let Some(_) = self.igmp {
4227 return 3;
4228 }
4229 if let Some(_) = self.multicast_forwarding {
4230 return 2;
4231 }
4232 if let Some(_) = self.unicast_forwarding {
4233 return 1;
4234 }
4235 0
4236 }
4237 }
4238
4239 impl fidl::encoding::ValueTypeMarker for Ipv4Configuration {
4240 type Borrowed<'a> = &'a Self;
4241 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4242 value
4243 }
4244 }
4245
4246 unsafe impl fidl::encoding::TypeMarker for Ipv4Configuration {
4247 type Owned = Self;
4248
4249 #[inline(always)]
4250 fn inline_align(_context: fidl::encoding::Context) -> usize {
4251 8
4252 }
4253
4254 #[inline(always)]
4255 fn inline_size(_context: fidl::encoding::Context) -> usize {
4256 16
4257 }
4258 }
4259
4260 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv4Configuration, D>
4261 for &Ipv4Configuration
4262 {
4263 unsafe fn encode(
4264 self,
4265 encoder: &mut fidl::encoding::Encoder<'_, D>,
4266 offset: usize,
4267 mut depth: fidl::encoding::Depth,
4268 ) -> fidl::Result<()> {
4269 encoder.debug_check_bounds::<Ipv4Configuration>(offset);
4270 let max_ordinal: u64 = self.max_ordinal_present();
4272 encoder.write_num(max_ordinal, offset);
4273 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4274 if max_ordinal == 0 {
4276 return Ok(());
4277 }
4278 depth.increment()?;
4279 let envelope_size = 8;
4280 let bytes_len = max_ordinal as usize * envelope_size;
4281 #[allow(unused_variables)]
4282 let offset = encoder.out_of_line_offset(bytes_len);
4283 let mut _prev_end_offset: usize = 0;
4284 if 1 > max_ordinal {
4285 return Ok(());
4286 }
4287
4288 let cur_offset: usize = (1 - 1) * envelope_size;
4291
4292 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4294
4295 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4300 self.unicast_forwarding
4301 .as_ref()
4302 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4303 encoder,
4304 offset + cur_offset,
4305 depth,
4306 )?;
4307
4308 _prev_end_offset = cur_offset + envelope_size;
4309 if 2 > max_ordinal {
4310 return Ok(());
4311 }
4312
4313 let cur_offset: usize = (2 - 1) * envelope_size;
4316
4317 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4319
4320 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4325 self.multicast_forwarding
4326 .as_ref()
4327 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4328 encoder,
4329 offset + cur_offset,
4330 depth,
4331 )?;
4332
4333 _prev_end_offset = cur_offset + envelope_size;
4334 if 3 > max_ordinal {
4335 return Ok(());
4336 }
4337
4338 let cur_offset: usize = (3 - 1) * envelope_size;
4341
4342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4344
4345 fidl::encoding::encode_in_envelope_optional::<IgmpConfiguration, D>(
4350 self.igmp
4351 .as_ref()
4352 .map(<IgmpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4353 encoder,
4354 offset + cur_offset,
4355 depth,
4356 )?;
4357
4358 _prev_end_offset = cur_offset + envelope_size;
4359 if 4 > max_ordinal {
4360 return Ok(());
4361 }
4362
4363 let cur_offset: usize = (4 - 1) * envelope_size;
4366
4367 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4369
4370 fidl::encoding::encode_in_envelope_optional::<ArpConfiguration, D>(
4375 self.arp
4376 .as_ref()
4377 .map(<ArpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4378 encoder,
4379 offset + cur_offset,
4380 depth,
4381 )?;
4382
4383 _prev_end_offset = cur_offset + envelope_size;
4384
4385 Ok(())
4386 }
4387 }
4388
4389 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv4Configuration {
4390 #[inline(always)]
4391 fn new_empty() -> Self {
4392 Self::default()
4393 }
4394
4395 unsafe fn decode(
4396 &mut self,
4397 decoder: &mut fidl::encoding::Decoder<'_, D>,
4398 offset: usize,
4399 mut depth: fidl::encoding::Depth,
4400 ) -> fidl::Result<()> {
4401 decoder.debug_check_bounds::<Self>(offset);
4402 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4403 None => return Err(fidl::Error::NotNullable),
4404 Some(len) => len,
4405 };
4406 if len == 0 {
4408 return Ok(());
4409 };
4410 depth.increment()?;
4411 let envelope_size = 8;
4412 let bytes_len = len * envelope_size;
4413 let offset = decoder.out_of_line_offset(bytes_len)?;
4414 let mut _next_ordinal_to_read = 0;
4416 let mut next_offset = offset;
4417 let end_offset = offset + bytes_len;
4418 _next_ordinal_to_read += 1;
4419 if next_offset >= end_offset {
4420 return Ok(());
4421 }
4422
4423 while _next_ordinal_to_read < 1 {
4425 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4426 _next_ordinal_to_read += 1;
4427 next_offset += envelope_size;
4428 }
4429
4430 let next_out_of_line = decoder.next_out_of_line();
4431 let handles_before = decoder.remaining_handles();
4432 if let Some((inlined, num_bytes, num_handles)) =
4433 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4434 {
4435 let member_inline_size =
4436 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4437 if inlined != (member_inline_size <= 4) {
4438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4439 }
4440 let inner_offset;
4441 let mut inner_depth = depth.clone();
4442 if inlined {
4443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4444 inner_offset = next_offset;
4445 } else {
4446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4447 inner_depth.increment()?;
4448 }
4449 let val_ref =
4450 self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4451 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4452 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4453 {
4454 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4455 }
4456 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4457 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4458 }
4459 }
4460
4461 next_offset += envelope_size;
4462 _next_ordinal_to_read += 1;
4463 if next_offset >= end_offset {
4464 return Ok(());
4465 }
4466
4467 while _next_ordinal_to_read < 2 {
4469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4470 _next_ordinal_to_read += 1;
4471 next_offset += envelope_size;
4472 }
4473
4474 let next_out_of_line = decoder.next_out_of_line();
4475 let handles_before = decoder.remaining_handles();
4476 if let Some((inlined, num_bytes, num_handles)) =
4477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4478 {
4479 let member_inline_size =
4480 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4481 if inlined != (member_inline_size <= 4) {
4482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4483 }
4484 let inner_offset;
4485 let mut inner_depth = depth.clone();
4486 if inlined {
4487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4488 inner_offset = next_offset;
4489 } else {
4490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4491 inner_depth.increment()?;
4492 }
4493 let val_ref =
4494 self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4495 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4496 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4497 {
4498 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4499 }
4500 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4501 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4502 }
4503 }
4504
4505 next_offset += envelope_size;
4506 _next_ordinal_to_read += 1;
4507 if next_offset >= end_offset {
4508 return Ok(());
4509 }
4510
4511 while _next_ordinal_to_read < 3 {
4513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4514 _next_ordinal_to_read += 1;
4515 next_offset += envelope_size;
4516 }
4517
4518 let next_out_of_line = decoder.next_out_of_line();
4519 let handles_before = decoder.remaining_handles();
4520 if let Some((inlined, num_bytes, num_handles)) =
4521 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4522 {
4523 let member_inline_size =
4524 <IgmpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4525 if inlined != (member_inline_size <= 4) {
4526 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4527 }
4528 let inner_offset;
4529 let mut inner_depth = depth.clone();
4530 if inlined {
4531 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4532 inner_offset = next_offset;
4533 } else {
4534 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4535 inner_depth.increment()?;
4536 }
4537 let val_ref =
4538 self.igmp.get_or_insert_with(|| fidl::new_empty!(IgmpConfiguration, D));
4539 fidl::decode!(IgmpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4540 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4541 {
4542 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4543 }
4544 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4545 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4546 }
4547 }
4548
4549 next_offset += envelope_size;
4550 _next_ordinal_to_read += 1;
4551 if next_offset >= end_offset {
4552 return Ok(());
4553 }
4554
4555 while _next_ordinal_to_read < 4 {
4557 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4558 _next_ordinal_to_read += 1;
4559 next_offset += envelope_size;
4560 }
4561
4562 let next_out_of_line = decoder.next_out_of_line();
4563 let handles_before = decoder.remaining_handles();
4564 if let Some((inlined, num_bytes, num_handles)) =
4565 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4566 {
4567 let member_inline_size =
4568 <ArpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4569 if inlined != (member_inline_size <= 4) {
4570 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4571 }
4572 let inner_offset;
4573 let mut inner_depth = depth.clone();
4574 if inlined {
4575 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4576 inner_offset = next_offset;
4577 } else {
4578 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4579 inner_depth.increment()?;
4580 }
4581 let val_ref = self.arp.get_or_insert_with(|| fidl::new_empty!(ArpConfiguration, D));
4582 fidl::decode!(ArpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4584 {
4585 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4586 }
4587 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4588 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4589 }
4590 }
4591
4592 next_offset += envelope_size;
4593
4594 while next_offset < end_offset {
4596 _next_ordinal_to_read += 1;
4597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4598 next_offset += envelope_size;
4599 }
4600
4601 Ok(())
4602 }
4603 }
4604
4605 impl Ipv6Configuration {
4606 #[inline(always)]
4607 fn max_ordinal_present(&self) -> u64 {
4608 if let Some(_) = self.ndp {
4609 return 4;
4610 }
4611 if let Some(_) = self.mld {
4612 return 3;
4613 }
4614 if let Some(_) = self.multicast_forwarding {
4615 return 2;
4616 }
4617 if let Some(_) = self.unicast_forwarding {
4618 return 1;
4619 }
4620 0
4621 }
4622 }
4623
4624 impl fidl::encoding::ValueTypeMarker for Ipv6Configuration {
4625 type Borrowed<'a> = &'a Self;
4626 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4627 value
4628 }
4629 }
4630
4631 unsafe impl fidl::encoding::TypeMarker for Ipv6Configuration {
4632 type Owned = Self;
4633
4634 #[inline(always)]
4635 fn inline_align(_context: fidl::encoding::Context) -> usize {
4636 8
4637 }
4638
4639 #[inline(always)]
4640 fn inline_size(_context: fidl::encoding::Context) -> usize {
4641 16
4642 }
4643 }
4644
4645 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv6Configuration, D>
4646 for &Ipv6Configuration
4647 {
4648 unsafe fn encode(
4649 self,
4650 encoder: &mut fidl::encoding::Encoder<'_, D>,
4651 offset: usize,
4652 mut depth: fidl::encoding::Depth,
4653 ) -> fidl::Result<()> {
4654 encoder.debug_check_bounds::<Ipv6Configuration>(offset);
4655 let max_ordinal: u64 = self.max_ordinal_present();
4657 encoder.write_num(max_ordinal, offset);
4658 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4659 if max_ordinal == 0 {
4661 return Ok(());
4662 }
4663 depth.increment()?;
4664 let envelope_size = 8;
4665 let bytes_len = max_ordinal as usize * envelope_size;
4666 #[allow(unused_variables)]
4667 let offset = encoder.out_of_line_offset(bytes_len);
4668 let mut _prev_end_offset: usize = 0;
4669 if 1 > max_ordinal {
4670 return Ok(());
4671 }
4672
4673 let cur_offset: usize = (1 - 1) * envelope_size;
4676
4677 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4679
4680 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4685 self.unicast_forwarding
4686 .as_ref()
4687 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4688 encoder,
4689 offset + cur_offset,
4690 depth,
4691 )?;
4692
4693 _prev_end_offset = cur_offset + envelope_size;
4694 if 2 > max_ordinal {
4695 return Ok(());
4696 }
4697
4698 let cur_offset: usize = (2 - 1) * envelope_size;
4701
4702 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4704
4705 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4710 self.multicast_forwarding
4711 .as_ref()
4712 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4713 encoder,
4714 offset + cur_offset,
4715 depth,
4716 )?;
4717
4718 _prev_end_offset = cur_offset + envelope_size;
4719 if 3 > max_ordinal {
4720 return Ok(());
4721 }
4722
4723 let cur_offset: usize = (3 - 1) * envelope_size;
4726
4727 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4729
4730 fidl::encoding::encode_in_envelope_optional::<MldConfiguration, D>(
4735 self.mld
4736 .as_ref()
4737 .map(<MldConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4738 encoder,
4739 offset + cur_offset,
4740 depth,
4741 )?;
4742
4743 _prev_end_offset = cur_offset + envelope_size;
4744 if 4 > max_ordinal {
4745 return Ok(());
4746 }
4747
4748 let cur_offset: usize = (4 - 1) * envelope_size;
4751
4752 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4754
4755 fidl::encoding::encode_in_envelope_optional::<NdpConfiguration, D>(
4760 self.ndp
4761 .as_ref()
4762 .map(<NdpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4763 encoder,
4764 offset + cur_offset,
4765 depth,
4766 )?;
4767
4768 _prev_end_offset = cur_offset + envelope_size;
4769
4770 Ok(())
4771 }
4772 }
4773
4774 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv6Configuration {
4775 #[inline(always)]
4776 fn new_empty() -> Self {
4777 Self::default()
4778 }
4779
4780 unsafe fn decode(
4781 &mut self,
4782 decoder: &mut fidl::encoding::Decoder<'_, D>,
4783 offset: usize,
4784 mut depth: fidl::encoding::Depth,
4785 ) -> fidl::Result<()> {
4786 decoder.debug_check_bounds::<Self>(offset);
4787 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4788 None => return Err(fidl::Error::NotNullable),
4789 Some(len) => len,
4790 };
4791 if len == 0 {
4793 return Ok(());
4794 };
4795 depth.increment()?;
4796 let envelope_size = 8;
4797 let bytes_len = len * envelope_size;
4798 let offset = decoder.out_of_line_offset(bytes_len)?;
4799 let mut _next_ordinal_to_read = 0;
4801 let mut next_offset = offset;
4802 let end_offset = offset + bytes_len;
4803 _next_ordinal_to_read += 1;
4804 if next_offset >= end_offset {
4805 return Ok(());
4806 }
4807
4808 while _next_ordinal_to_read < 1 {
4810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4811 _next_ordinal_to_read += 1;
4812 next_offset += envelope_size;
4813 }
4814
4815 let next_out_of_line = decoder.next_out_of_line();
4816 let handles_before = decoder.remaining_handles();
4817 if let Some((inlined, num_bytes, num_handles)) =
4818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4819 {
4820 let member_inline_size =
4821 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4822 if inlined != (member_inline_size <= 4) {
4823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4824 }
4825 let inner_offset;
4826 let mut inner_depth = depth.clone();
4827 if inlined {
4828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4829 inner_offset = next_offset;
4830 } else {
4831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4832 inner_depth.increment()?;
4833 }
4834 let val_ref =
4835 self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4836 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4837 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4838 {
4839 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4840 }
4841 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4842 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4843 }
4844 }
4845
4846 next_offset += envelope_size;
4847 _next_ordinal_to_read += 1;
4848 if next_offset >= end_offset {
4849 return Ok(());
4850 }
4851
4852 while _next_ordinal_to_read < 2 {
4854 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4855 _next_ordinal_to_read += 1;
4856 next_offset += envelope_size;
4857 }
4858
4859 let next_out_of_line = decoder.next_out_of_line();
4860 let handles_before = decoder.remaining_handles();
4861 if let Some((inlined, num_bytes, num_handles)) =
4862 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4863 {
4864 let member_inline_size =
4865 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4866 if inlined != (member_inline_size <= 4) {
4867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4868 }
4869 let inner_offset;
4870 let mut inner_depth = depth.clone();
4871 if inlined {
4872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4873 inner_offset = next_offset;
4874 } else {
4875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4876 inner_depth.increment()?;
4877 }
4878 let val_ref =
4879 self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4880 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4881 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4882 {
4883 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4884 }
4885 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4886 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4887 }
4888 }
4889
4890 next_offset += envelope_size;
4891 _next_ordinal_to_read += 1;
4892 if next_offset >= end_offset {
4893 return Ok(());
4894 }
4895
4896 while _next_ordinal_to_read < 3 {
4898 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4899 _next_ordinal_to_read += 1;
4900 next_offset += envelope_size;
4901 }
4902
4903 let next_out_of_line = decoder.next_out_of_line();
4904 let handles_before = decoder.remaining_handles();
4905 if let Some((inlined, num_bytes, num_handles)) =
4906 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4907 {
4908 let member_inline_size =
4909 <MldConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4910 if inlined != (member_inline_size <= 4) {
4911 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4912 }
4913 let inner_offset;
4914 let mut inner_depth = depth.clone();
4915 if inlined {
4916 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4917 inner_offset = next_offset;
4918 } else {
4919 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4920 inner_depth.increment()?;
4921 }
4922 let val_ref = self.mld.get_or_insert_with(|| fidl::new_empty!(MldConfiguration, D));
4923 fidl::decode!(MldConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4924 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4925 {
4926 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4927 }
4928 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4929 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4930 }
4931 }
4932
4933 next_offset += envelope_size;
4934 _next_ordinal_to_read += 1;
4935 if next_offset >= end_offset {
4936 return Ok(());
4937 }
4938
4939 while _next_ordinal_to_read < 4 {
4941 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4942 _next_ordinal_to_read += 1;
4943 next_offset += envelope_size;
4944 }
4945
4946 let next_out_of_line = decoder.next_out_of_line();
4947 let handles_before = decoder.remaining_handles();
4948 if let Some((inlined, num_bytes, num_handles)) =
4949 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4950 {
4951 let member_inline_size =
4952 <NdpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4953 if inlined != (member_inline_size <= 4) {
4954 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4955 }
4956 let inner_offset;
4957 let mut inner_depth = depth.clone();
4958 if inlined {
4959 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4960 inner_offset = next_offset;
4961 } else {
4962 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4963 inner_depth.increment()?;
4964 }
4965 let val_ref = self.ndp.get_or_insert_with(|| fidl::new_empty!(NdpConfiguration, D));
4966 fidl::decode!(NdpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4967 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4968 {
4969 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4970 }
4971 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4972 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4973 }
4974 }
4975
4976 next_offset += envelope_size;
4977
4978 while next_offset < end_offset {
4980 _next_ordinal_to_read += 1;
4981 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4982 next_offset += envelope_size;
4983 }
4984
4985 Ok(())
4986 }
4987 }
4988
4989 impl MldConfiguration {
4990 #[inline(always)]
4991 fn max_ordinal_present(&self) -> u64 {
4992 if let Some(_) = self.version {
4993 return 1;
4994 }
4995 0
4996 }
4997 }
4998
4999 impl fidl::encoding::ValueTypeMarker for MldConfiguration {
5000 type Borrowed<'a> = &'a Self;
5001 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5002 value
5003 }
5004 }
5005
5006 unsafe impl fidl::encoding::TypeMarker for MldConfiguration {
5007 type Owned = Self;
5008
5009 #[inline(always)]
5010 fn inline_align(_context: fidl::encoding::Context) -> usize {
5011 8
5012 }
5013
5014 #[inline(always)]
5015 fn inline_size(_context: fidl::encoding::Context) -> usize {
5016 16
5017 }
5018 }
5019
5020 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MldConfiguration, D>
5021 for &MldConfiguration
5022 {
5023 unsafe fn encode(
5024 self,
5025 encoder: &mut fidl::encoding::Encoder<'_, D>,
5026 offset: usize,
5027 mut depth: fidl::encoding::Depth,
5028 ) -> fidl::Result<()> {
5029 encoder.debug_check_bounds::<MldConfiguration>(offset);
5030 let max_ordinal: u64 = self.max_ordinal_present();
5032 encoder.write_num(max_ordinal, offset);
5033 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5034 if max_ordinal == 0 {
5036 return Ok(());
5037 }
5038 depth.increment()?;
5039 let envelope_size = 8;
5040 let bytes_len = max_ordinal as usize * envelope_size;
5041 #[allow(unused_variables)]
5042 let offset = encoder.out_of_line_offset(bytes_len);
5043 let mut _prev_end_offset: usize = 0;
5044 if 1 > max_ordinal {
5045 return Ok(());
5046 }
5047
5048 let cur_offset: usize = (1 - 1) * envelope_size;
5051
5052 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5054
5055 fidl::encoding::encode_in_envelope_optional::<MldVersion, D>(
5060 self.version.as_ref().map(<MldVersion as fidl::encoding::ValueTypeMarker>::borrow),
5061 encoder,
5062 offset + cur_offset,
5063 depth,
5064 )?;
5065
5066 _prev_end_offset = cur_offset + envelope_size;
5067
5068 Ok(())
5069 }
5070 }
5071
5072 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldConfiguration {
5073 #[inline(always)]
5074 fn new_empty() -> Self {
5075 Self::default()
5076 }
5077
5078 unsafe fn decode(
5079 &mut self,
5080 decoder: &mut fidl::encoding::Decoder<'_, D>,
5081 offset: usize,
5082 mut depth: fidl::encoding::Depth,
5083 ) -> fidl::Result<()> {
5084 decoder.debug_check_bounds::<Self>(offset);
5085 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5086 None => return Err(fidl::Error::NotNullable),
5087 Some(len) => len,
5088 };
5089 if len == 0 {
5091 return Ok(());
5092 };
5093 depth.increment()?;
5094 let envelope_size = 8;
5095 let bytes_len = len * envelope_size;
5096 let offset = decoder.out_of_line_offset(bytes_len)?;
5097 let mut _next_ordinal_to_read = 0;
5099 let mut next_offset = offset;
5100 let end_offset = offset + bytes_len;
5101 _next_ordinal_to_read += 1;
5102 if next_offset >= end_offset {
5103 return Ok(());
5104 }
5105
5106 while _next_ordinal_to_read < 1 {
5108 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5109 _next_ordinal_to_read += 1;
5110 next_offset += envelope_size;
5111 }
5112
5113 let next_out_of_line = decoder.next_out_of_line();
5114 let handles_before = decoder.remaining_handles();
5115 if let Some((inlined, num_bytes, num_handles)) =
5116 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5117 {
5118 let member_inline_size =
5119 <MldVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5120 if inlined != (member_inline_size <= 4) {
5121 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5122 }
5123 let inner_offset;
5124 let mut inner_depth = depth.clone();
5125 if inlined {
5126 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5127 inner_offset = next_offset;
5128 } else {
5129 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5130 inner_depth.increment()?;
5131 }
5132 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(MldVersion, D));
5133 fidl::decode!(MldVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
5134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5135 {
5136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5137 }
5138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5140 }
5141 }
5142
5143 next_offset += envelope_size;
5144
5145 while next_offset < end_offset {
5147 _next_ordinal_to_read += 1;
5148 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5149 next_offset += envelope_size;
5150 }
5151
5152 Ok(())
5153 }
5154 }
5155
5156 impl NdpConfiguration {
5157 #[inline(always)]
5158 fn max_ordinal_present(&self) -> u64 {
5159 if let Some(_) = self.slaac {
5160 return 3;
5161 }
5162 if let Some(_) = self.dad {
5163 return 2;
5164 }
5165 if let Some(_) = self.nud {
5166 return 1;
5167 }
5168 0
5169 }
5170 }
5171
5172 impl fidl::encoding::ValueTypeMarker for NdpConfiguration {
5173 type Borrowed<'a> = &'a Self;
5174 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5175 value
5176 }
5177 }
5178
5179 unsafe impl fidl::encoding::TypeMarker for NdpConfiguration {
5180 type Owned = Self;
5181
5182 #[inline(always)]
5183 fn inline_align(_context: fidl::encoding::Context) -> usize {
5184 8
5185 }
5186
5187 #[inline(always)]
5188 fn inline_size(_context: fidl::encoding::Context) -> usize {
5189 16
5190 }
5191 }
5192
5193 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NdpConfiguration, D>
5194 for &NdpConfiguration
5195 {
5196 unsafe fn encode(
5197 self,
5198 encoder: &mut fidl::encoding::Encoder<'_, D>,
5199 offset: usize,
5200 mut depth: fidl::encoding::Depth,
5201 ) -> fidl::Result<()> {
5202 encoder.debug_check_bounds::<NdpConfiguration>(offset);
5203 let max_ordinal: u64 = self.max_ordinal_present();
5205 encoder.write_num(max_ordinal, offset);
5206 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5207 if max_ordinal == 0 {
5209 return Ok(());
5210 }
5211 depth.increment()?;
5212 let envelope_size = 8;
5213 let bytes_len = max_ordinal as usize * envelope_size;
5214 #[allow(unused_variables)]
5215 let offset = encoder.out_of_line_offset(bytes_len);
5216 let mut _prev_end_offset: usize = 0;
5217 if 1 > max_ordinal {
5218 return Ok(());
5219 }
5220
5221 let cur_offset: usize = (1 - 1) * envelope_size;
5224
5225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5227
5228 fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
5233 self.nud
5234 .as_ref()
5235 .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5236 encoder,
5237 offset + cur_offset,
5238 depth,
5239 )?;
5240
5241 _prev_end_offset = cur_offset + envelope_size;
5242 if 2 > max_ordinal {
5243 return Ok(());
5244 }
5245
5246 let cur_offset: usize = (2 - 1) * envelope_size;
5249
5250 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5252
5253 fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
5258 self.dad
5259 .as_ref()
5260 .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5261 encoder,
5262 offset + cur_offset,
5263 depth,
5264 )?;
5265
5266 _prev_end_offset = cur_offset + envelope_size;
5267 if 3 > max_ordinal {
5268 return Ok(());
5269 }
5270
5271 let cur_offset: usize = (3 - 1) * envelope_size;
5274
5275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5277
5278 fidl::encoding::encode_in_envelope_optional::<SlaacConfiguration, D>(
5283 self.slaac
5284 .as_ref()
5285 .map(<SlaacConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5286 encoder,
5287 offset + cur_offset,
5288 depth,
5289 )?;
5290
5291 _prev_end_offset = cur_offset + envelope_size;
5292
5293 Ok(())
5294 }
5295 }
5296
5297 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NdpConfiguration {
5298 #[inline(always)]
5299 fn new_empty() -> Self {
5300 Self::default()
5301 }
5302
5303 unsafe fn decode(
5304 &mut self,
5305 decoder: &mut fidl::encoding::Decoder<'_, D>,
5306 offset: usize,
5307 mut depth: fidl::encoding::Depth,
5308 ) -> fidl::Result<()> {
5309 decoder.debug_check_bounds::<Self>(offset);
5310 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5311 None => return Err(fidl::Error::NotNullable),
5312 Some(len) => len,
5313 };
5314 if len == 0 {
5316 return Ok(());
5317 };
5318 depth.increment()?;
5319 let envelope_size = 8;
5320 let bytes_len = len * envelope_size;
5321 let offset = decoder.out_of_line_offset(bytes_len)?;
5322 let mut _next_ordinal_to_read = 0;
5324 let mut next_offset = offset;
5325 let end_offset = offset + bytes_len;
5326 _next_ordinal_to_read += 1;
5327 if next_offset >= end_offset {
5328 return Ok(());
5329 }
5330
5331 while _next_ordinal_to_read < 1 {
5333 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5334 _next_ordinal_to_read += 1;
5335 next_offset += envelope_size;
5336 }
5337
5338 let next_out_of_line = decoder.next_out_of_line();
5339 let handles_before = decoder.remaining_handles();
5340 if let Some((inlined, num_bytes, num_handles)) =
5341 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5342 {
5343 let member_inline_size =
5344 <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5345 if inlined != (member_inline_size <= 4) {
5346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5347 }
5348 let inner_offset;
5349 let mut inner_depth = depth.clone();
5350 if inlined {
5351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5352 inner_offset = next_offset;
5353 } else {
5354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5355 inner_depth.increment()?;
5356 }
5357 let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
5358 fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5360 {
5361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5362 }
5363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5365 }
5366 }
5367
5368 next_offset += envelope_size;
5369 _next_ordinal_to_read += 1;
5370 if next_offset >= end_offset {
5371 return Ok(());
5372 }
5373
5374 while _next_ordinal_to_read < 2 {
5376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5377 _next_ordinal_to_read += 1;
5378 next_offset += envelope_size;
5379 }
5380
5381 let next_out_of_line = decoder.next_out_of_line();
5382 let handles_before = decoder.remaining_handles();
5383 if let Some((inlined, num_bytes, num_handles)) =
5384 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5385 {
5386 let member_inline_size =
5387 <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5388 if inlined != (member_inline_size <= 4) {
5389 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5390 }
5391 let inner_offset;
5392 let mut inner_depth = depth.clone();
5393 if inlined {
5394 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5395 inner_offset = next_offset;
5396 } else {
5397 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5398 inner_depth.increment()?;
5399 }
5400 let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
5401 fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5402 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5403 {
5404 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5405 }
5406 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5407 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5408 }
5409 }
5410
5411 next_offset += envelope_size;
5412 _next_ordinal_to_read += 1;
5413 if next_offset >= end_offset {
5414 return Ok(());
5415 }
5416
5417 while _next_ordinal_to_read < 3 {
5419 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5420 _next_ordinal_to_read += 1;
5421 next_offset += envelope_size;
5422 }
5423
5424 let next_out_of_line = decoder.next_out_of_line();
5425 let handles_before = decoder.remaining_handles();
5426 if let Some((inlined, num_bytes, num_handles)) =
5427 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5428 {
5429 let member_inline_size =
5430 <SlaacConfiguration as fidl::encoding::TypeMarker>::inline_size(
5431 decoder.context,
5432 );
5433 if inlined != (member_inline_size <= 4) {
5434 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5435 }
5436 let inner_offset;
5437 let mut inner_depth = depth.clone();
5438 if inlined {
5439 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5440 inner_offset = next_offset;
5441 } else {
5442 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5443 inner_depth.increment()?;
5444 }
5445 let val_ref =
5446 self.slaac.get_or_insert_with(|| fidl::new_empty!(SlaacConfiguration, D));
5447 fidl::decode!(SlaacConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5448 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5449 {
5450 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5451 }
5452 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5453 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5454 }
5455 }
5456
5457 next_offset += envelope_size;
5458
5459 while next_offset < end_offset {
5461 _next_ordinal_to_read += 1;
5462 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5463 next_offset += envelope_size;
5464 }
5465
5466 Ok(())
5467 }
5468 }
5469
5470 impl NudConfiguration {
5471 #[inline(always)]
5472 fn max_ordinal_present(&self) -> u64 {
5473 if let Some(_) = self.base_reachable_time {
5474 return 3;
5475 }
5476 if let Some(_) = self.max_unicast_solicitations {
5477 return 2;
5478 }
5479 if let Some(_) = self.max_multicast_solicitations {
5480 return 1;
5481 }
5482 0
5483 }
5484 }
5485
5486 impl fidl::encoding::ValueTypeMarker for NudConfiguration {
5487 type Borrowed<'a> = &'a Self;
5488 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5489 value
5490 }
5491 }
5492
5493 unsafe impl fidl::encoding::TypeMarker for NudConfiguration {
5494 type Owned = Self;
5495
5496 #[inline(always)]
5497 fn inline_align(_context: fidl::encoding::Context) -> usize {
5498 8
5499 }
5500
5501 #[inline(always)]
5502 fn inline_size(_context: fidl::encoding::Context) -> usize {
5503 16
5504 }
5505 }
5506
5507 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NudConfiguration, D>
5508 for &NudConfiguration
5509 {
5510 unsafe fn encode(
5511 self,
5512 encoder: &mut fidl::encoding::Encoder<'_, D>,
5513 offset: usize,
5514 mut depth: fidl::encoding::Depth,
5515 ) -> fidl::Result<()> {
5516 encoder.debug_check_bounds::<NudConfiguration>(offset);
5517 let max_ordinal: u64 = self.max_ordinal_present();
5519 encoder.write_num(max_ordinal, offset);
5520 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5521 if max_ordinal == 0 {
5523 return Ok(());
5524 }
5525 depth.increment()?;
5526 let envelope_size = 8;
5527 let bytes_len = max_ordinal as usize * envelope_size;
5528 #[allow(unused_variables)]
5529 let offset = encoder.out_of_line_offset(bytes_len);
5530 let mut _prev_end_offset: usize = 0;
5531 if 1 > max_ordinal {
5532 return Ok(());
5533 }
5534
5535 let cur_offset: usize = (1 - 1) * envelope_size;
5538
5539 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5541
5542 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5547 self.max_multicast_solicitations
5548 .as_ref()
5549 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5550 encoder,
5551 offset + cur_offset,
5552 depth,
5553 )?;
5554
5555 _prev_end_offset = cur_offset + envelope_size;
5556 if 2 > max_ordinal {
5557 return Ok(());
5558 }
5559
5560 let cur_offset: usize = (2 - 1) * envelope_size;
5563
5564 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5566
5567 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5572 self.max_unicast_solicitations
5573 .as_ref()
5574 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5575 encoder,
5576 offset + cur_offset,
5577 depth,
5578 )?;
5579
5580 _prev_end_offset = cur_offset + envelope_size;
5581 if 3 > max_ordinal {
5582 return Ok(());
5583 }
5584
5585 let cur_offset: usize = (3 - 1) * envelope_size;
5588
5589 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5591
5592 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5597 self.base_reachable_time
5598 .as_ref()
5599 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5600 encoder,
5601 offset + cur_offset,
5602 depth,
5603 )?;
5604
5605 _prev_end_offset = cur_offset + envelope_size;
5606
5607 Ok(())
5608 }
5609 }
5610
5611 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NudConfiguration {
5612 #[inline(always)]
5613 fn new_empty() -> Self {
5614 Self::default()
5615 }
5616
5617 unsafe fn decode(
5618 &mut self,
5619 decoder: &mut fidl::encoding::Decoder<'_, D>,
5620 offset: usize,
5621 mut depth: fidl::encoding::Depth,
5622 ) -> fidl::Result<()> {
5623 decoder.debug_check_bounds::<Self>(offset);
5624 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5625 None => return Err(fidl::Error::NotNullable),
5626 Some(len) => len,
5627 };
5628 if len == 0 {
5630 return Ok(());
5631 };
5632 depth.increment()?;
5633 let envelope_size = 8;
5634 let bytes_len = len * envelope_size;
5635 let offset = decoder.out_of_line_offset(bytes_len)?;
5636 let mut _next_ordinal_to_read = 0;
5638 let mut next_offset = offset;
5639 let end_offset = offset + bytes_len;
5640 _next_ordinal_to_read += 1;
5641 if next_offset >= end_offset {
5642 return Ok(());
5643 }
5644
5645 while _next_ordinal_to_read < 1 {
5647 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5648 _next_ordinal_to_read += 1;
5649 next_offset += envelope_size;
5650 }
5651
5652 let next_out_of_line = decoder.next_out_of_line();
5653 let handles_before = decoder.remaining_handles();
5654 if let Some((inlined, num_bytes, num_handles)) =
5655 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5656 {
5657 let member_inline_size =
5658 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5659 if inlined != (member_inline_size <= 4) {
5660 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5661 }
5662 let inner_offset;
5663 let mut inner_depth = depth.clone();
5664 if inlined {
5665 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5666 inner_offset = next_offset;
5667 } else {
5668 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5669 inner_depth.increment()?;
5670 }
5671 let val_ref = self
5672 .max_multicast_solicitations
5673 .get_or_insert_with(|| fidl::new_empty!(u16, D));
5674 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5675 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5676 {
5677 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5678 }
5679 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5680 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5681 }
5682 }
5683
5684 next_offset += envelope_size;
5685 _next_ordinal_to_read += 1;
5686 if next_offset >= end_offset {
5687 return Ok(());
5688 }
5689
5690 while _next_ordinal_to_read < 2 {
5692 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5693 _next_ordinal_to_read += 1;
5694 next_offset += envelope_size;
5695 }
5696
5697 let next_out_of_line = decoder.next_out_of_line();
5698 let handles_before = decoder.remaining_handles();
5699 if let Some((inlined, num_bytes, num_handles)) =
5700 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5701 {
5702 let member_inline_size =
5703 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5704 if inlined != (member_inline_size <= 4) {
5705 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5706 }
5707 let inner_offset;
5708 let mut inner_depth = depth.clone();
5709 if inlined {
5710 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5711 inner_offset = next_offset;
5712 } else {
5713 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5714 inner_depth.increment()?;
5715 }
5716 let val_ref =
5717 self.max_unicast_solicitations.get_or_insert_with(|| fidl::new_empty!(u16, D));
5718 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5720 {
5721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5722 }
5723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5725 }
5726 }
5727
5728 next_offset += envelope_size;
5729 _next_ordinal_to_read += 1;
5730 if next_offset >= end_offset {
5731 return Ok(());
5732 }
5733
5734 while _next_ordinal_to_read < 3 {
5736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5737 _next_ordinal_to_read += 1;
5738 next_offset += envelope_size;
5739 }
5740
5741 let next_out_of_line = decoder.next_out_of_line();
5742 let handles_before = decoder.remaining_handles();
5743 if let Some((inlined, num_bytes, num_handles)) =
5744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5745 {
5746 let member_inline_size =
5747 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5748 if inlined != (member_inline_size <= 4) {
5749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5750 }
5751 let inner_offset;
5752 let mut inner_depth = depth.clone();
5753 if inlined {
5754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5755 inner_offset = next_offset;
5756 } else {
5757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5758 inner_depth.increment()?;
5759 }
5760 let val_ref =
5761 self.base_reachable_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
5762 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
5763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5764 {
5765 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5766 }
5767 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5768 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5769 }
5770 }
5771
5772 next_offset += envelope_size;
5773
5774 while next_offset < end_offset {
5776 _next_ordinal_to_read += 1;
5777 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5778 next_offset += envelope_size;
5779 }
5780
5781 Ok(())
5782 }
5783 }
5784
5785 impl Options {
5786 #[inline(always)]
5787 fn max_ordinal_present(&self) -> u64 {
5788 if let Some(_) = self.metric {
5789 return 2;
5790 }
5791 if let Some(_) = self.name {
5792 return 1;
5793 }
5794 0
5795 }
5796 }
5797
5798 impl fidl::encoding::ValueTypeMarker for Options {
5799 type Borrowed<'a> = &'a Self;
5800 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5801 value
5802 }
5803 }
5804
5805 unsafe impl fidl::encoding::TypeMarker for Options {
5806 type Owned = Self;
5807
5808 #[inline(always)]
5809 fn inline_align(_context: fidl::encoding::Context) -> usize {
5810 8
5811 }
5812
5813 #[inline(always)]
5814 fn inline_size(_context: fidl::encoding::Context) -> usize {
5815 16
5816 }
5817 }
5818
5819 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
5820 unsafe fn encode(
5821 self,
5822 encoder: &mut fidl::encoding::Encoder<'_, D>,
5823 offset: usize,
5824 mut depth: fidl::encoding::Depth,
5825 ) -> fidl::Result<()> {
5826 encoder.debug_check_bounds::<Options>(offset);
5827 let max_ordinal: u64 = self.max_ordinal_present();
5829 encoder.write_num(max_ordinal, offset);
5830 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5831 if max_ordinal == 0 {
5833 return Ok(());
5834 }
5835 depth.increment()?;
5836 let envelope_size = 8;
5837 let bytes_len = max_ordinal as usize * envelope_size;
5838 #[allow(unused_variables)]
5839 let offset = encoder.out_of_line_offset(bytes_len);
5840 let mut _prev_end_offset: usize = 0;
5841 if 1 > max_ordinal {
5842 return Ok(());
5843 }
5844
5845 let cur_offset: usize = (1 - 1) * envelope_size;
5848
5849 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5851
5852 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<15>, D>(
5857 self.name.as_ref().map(
5858 <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow,
5859 ),
5860 encoder,
5861 offset + cur_offset,
5862 depth,
5863 )?;
5864
5865 _prev_end_offset = cur_offset + envelope_size;
5866 if 2 > max_ordinal {
5867 return Ok(());
5868 }
5869
5870 let cur_offset: usize = (2 - 1) * envelope_size;
5873
5874 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5876
5877 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5882 self.metric.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5883 encoder,
5884 offset + cur_offset,
5885 depth,
5886 )?;
5887
5888 _prev_end_offset = cur_offset + envelope_size;
5889
5890 Ok(())
5891 }
5892 }
5893
5894 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
5895 #[inline(always)]
5896 fn new_empty() -> Self {
5897 Self::default()
5898 }
5899
5900 unsafe fn decode(
5901 &mut self,
5902 decoder: &mut fidl::encoding::Decoder<'_, D>,
5903 offset: usize,
5904 mut depth: fidl::encoding::Depth,
5905 ) -> fidl::Result<()> {
5906 decoder.debug_check_bounds::<Self>(offset);
5907 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5908 None => return Err(fidl::Error::NotNullable),
5909 Some(len) => len,
5910 };
5911 if len == 0 {
5913 return Ok(());
5914 };
5915 depth.increment()?;
5916 let envelope_size = 8;
5917 let bytes_len = len * envelope_size;
5918 let offset = decoder.out_of_line_offset(bytes_len)?;
5919 let mut _next_ordinal_to_read = 0;
5921 let mut next_offset = offset;
5922 let end_offset = offset + bytes_len;
5923 _next_ordinal_to_read += 1;
5924 if next_offset >= end_offset {
5925 return Ok(());
5926 }
5927
5928 while _next_ordinal_to_read < 1 {
5930 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5931 _next_ordinal_to_read += 1;
5932 next_offset += envelope_size;
5933 }
5934
5935 let next_out_of_line = decoder.next_out_of_line();
5936 let handles_before = decoder.remaining_handles();
5937 if let Some((inlined, num_bytes, num_handles)) =
5938 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5939 {
5940 let member_inline_size =
5941 <fidl::encoding::BoundedString<15> as fidl::encoding::TypeMarker>::inline_size(
5942 decoder.context,
5943 );
5944 if inlined != (member_inline_size <= 4) {
5945 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5946 }
5947 let inner_offset;
5948 let mut inner_depth = depth.clone();
5949 if inlined {
5950 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5951 inner_offset = next_offset;
5952 } else {
5953 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5954 inner_depth.increment()?;
5955 }
5956 let val_ref = self
5957 .name
5958 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<15>, D));
5959 fidl::decode!(
5960 fidl::encoding::BoundedString<15>,
5961 D,
5962 val_ref,
5963 decoder,
5964 inner_offset,
5965 inner_depth
5966 )?;
5967 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5968 {
5969 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5970 }
5971 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5972 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5973 }
5974 }
5975
5976 next_offset += envelope_size;
5977 _next_ordinal_to_read += 1;
5978 if next_offset >= end_offset {
5979 return Ok(());
5980 }
5981
5982 while _next_ordinal_to_read < 2 {
5984 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5985 _next_ordinal_to_read += 1;
5986 next_offset += envelope_size;
5987 }
5988
5989 let next_out_of_line = decoder.next_out_of_line();
5990 let handles_before = decoder.remaining_handles();
5991 if let Some((inlined, num_bytes, num_handles)) =
5992 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5993 {
5994 let member_inline_size =
5995 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5996 if inlined != (member_inline_size <= 4) {
5997 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5998 }
5999 let inner_offset;
6000 let mut inner_depth = depth.clone();
6001 if inlined {
6002 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6003 inner_offset = next_offset;
6004 } else {
6005 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6006 inner_depth.increment()?;
6007 }
6008 let val_ref = self.metric.get_or_insert_with(|| fidl::new_empty!(u32, D));
6009 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6010 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6011 {
6012 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6013 }
6014 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6015 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6016 }
6017 }
6018
6019 next_offset += envelope_size;
6020
6021 while next_offset < end_offset {
6023 _next_ordinal_to_read += 1;
6024 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6025 next_offset += envelope_size;
6026 }
6027
6028 Ok(())
6029 }
6030 }
6031
6032 impl SlaacConfiguration {
6033 #[inline(always)]
6034 fn max_ordinal_present(&self) -> u64 {
6035 if let Some(_) = self.temporary_address {
6036 return 1;
6037 }
6038 0
6039 }
6040 }
6041
6042 impl fidl::encoding::ValueTypeMarker for SlaacConfiguration {
6043 type Borrowed<'a> = &'a Self;
6044 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6045 value
6046 }
6047 }
6048
6049 unsafe impl fidl::encoding::TypeMarker for SlaacConfiguration {
6050 type Owned = Self;
6051
6052 #[inline(always)]
6053 fn inline_align(_context: fidl::encoding::Context) -> usize {
6054 8
6055 }
6056
6057 #[inline(always)]
6058 fn inline_size(_context: fidl::encoding::Context) -> usize {
6059 16
6060 }
6061 }
6062
6063 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SlaacConfiguration, D>
6064 for &SlaacConfiguration
6065 {
6066 unsafe fn encode(
6067 self,
6068 encoder: &mut fidl::encoding::Encoder<'_, D>,
6069 offset: usize,
6070 mut depth: fidl::encoding::Depth,
6071 ) -> fidl::Result<()> {
6072 encoder.debug_check_bounds::<SlaacConfiguration>(offset);
6073 let max_ordinal: u64 = self.max_ordinal_present();
6075 encoder.write_num(max_ordinal, offset);
6076 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6077 if max_ordinal == 0 {
6079 return Ok(());
6080 }
6081 depth.increment()?;
6082 let envelope_size = 8;
6083 let bytes_len = max_ordinal as usize * envelope_size;
6084 #[allow(unused_variables)]
6085 let offset = encoder.out_of_line_offset(bytes_len);
6086 let mut _prev_end_offset: usize = 0;
6087 if 1 > max_ordinal {
6088 return Ok(());
6089 }
6090
6091 let cur_offset: usize = (1 - 1) * envelope_size;
6094
6095 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6097
6098 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6103 self.temporary_address
6104 .as_ref()
6105 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6106 encoder,
6107 offset + cur_offset,
6108 depth,
6109 )?;
6110
6111 _prev_end_offset = cur_offset + envelope_size;
6112
6113 Ok(())
6114 }
6115 }
6116
6117 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SlaacConfiguration {
6118 #[inline(always)]
6119 fn new_empty() -> Self {
6120 Self::default()
6121 }
6122
6123 unsafe fn decode(
6124 &mut self,
6125 decoder: &mut fidl::encoding::Decoder<'_, D>,
6126 offset: usize,
6127 mut depth: fidl::encoding::Depth,
6128 ) -> fidl::Result<()> {
6129 decoder.debug_check_bounds::<Self>(offset);
6130 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6131 None => return Err(fidl::Error::NotNullable),
6132 Some(len) => len,
6133 };
6134 if len == 0 {
6136 return Ok(());
6137 };
6138 depth.increment()?;
6139 let envelope_size = 8;
6140 let bytes_len = len * envelope_size;
6141 let offset = decoder.out_of_line_offset(bytes_len)?;
6142 let mut _next_ordinal_to_read = 0;
6144 let mut next_offset = offset;
6145 let end_offset = offset + bytes_len;
6146 _next_ordinal_to_read += 1;
6147 if next_offset >= end_offset {
6148 return Ok(());
6149 }
6150
6151 while _next_ordinal_to_read < 1 {
6153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6154 _next_ordinal_to_read += 1;
6155 next_offset += envelope_size;
6156 }
6157
6158 let next_out_of_line = decoder.next_out_of_line();
6159 let handles_before = decoder.remaining_handles();
6160 if let Some((inlined, num_bytes, num_handles)) =
6161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6162 {
6163 let member_inline_size =
6164 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6165 if inlined != (member_inline_size <= 4) {
6166 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6167 }
6168 let inner_offset;
6169 let mut inner_depth = depth.clone();
6170 if inlined {
6171 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6172 inner_offset = next_offset;
6173 } else {
6174 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6175 inner_depth.increment()?;
6176 }
6177 let val_ref =
6178 self.temporary_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
6179 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6180 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6181 {
6182 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6183 }
6184 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6185 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6186 }
6187 }
6188
6189 next_offset += envelope_size;
6190
6191 while next_offset < end_offset {
6193 _next_ordinal_to_read += 1;
6194 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6195 next_offset += envelope_size;
6196 }
6197
6198 Ok(())
6199 }
6200 }
6201}