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__common::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__common::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__common::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
974pub mod address_state_provider_ordinals {
975 pub const UPDATE_ADDRESS_PROPERTIES: u64 = 0x52bdf5ed96ef573c;
976 pub const WATCH_ADDRESS_ASSIGNMENT_STATE: u64 = 0x740bb58c1b2d3188;
977 pub const DETACH: u64 = 0xc752381d739622f;
978 pub const REMOVE: u64 = 0x554407fe183e78ad;
979 pub const ON_ADDRESS_ADDED: u64 = 0x624f6ea62cce189e;
980 pub const ON_ADDRESS_REMOVED: u64 = 0x2480eb672ffd5962;
981}
982
983pub mod control_ordinals {
984 pub const ADD_ADDRESS: u64 = 0x1349d36da453ce;
985 pub const REMOVE_ADDRESS: u64 = 0x213ba73da997a620;
986 pub const GET_ID: u64 = 0x2a2459768d9ecc6f;
987 pub const SET_CONFIGURATION: u64 = 0x573923b7b4bde27f;
988 pub const GET_CONFIGURATION: u64 = 0x5f5d239820bdcc65;
989 pub const ENABLE: u64 = 0x15c983d3a8ac0b98;
990 pub const DISABLE: u64 = 0x98d3a585d905473;
991 pub const DETACH: u64 = 0x78ee27518b2dbfa;
992 pub const GET_AUTHORIZATION_FOR_INTERFACE: u64 = 0xc1de2ab60b5cb9e;
993 pub const REMOVE: u64 = 0x13aab8bbecc7ff0b;
994 pub const ON_INTERFACE_REMOVED: u64 = 0x800d39e76c1cddd;
995}
996
997pub mod device_control_ordinals {
998 pub const CREATE_INTERFACE: u64 = 0x4ff8be7351d12f86;
999 pub const DETACH: u64 = 0x57489f1554d489d2;
1000}
1001
1002pub mod installer_ordinals {
1003 pub const INSTALL_DEVICE: u64 = 0x3e84524dcecab23a;
1004 pub const INSTALL_BLACKHOLE_INTERFACE: u64 = 0x2ce57e87cdbcb809;
1005}
1006
1007mod internal {
1008 use super::*;
1009 unsafe impl fidl::encoding::TypeMarker for AddressRemovalReason {
1010 type Owned = Self;
1011
1012 #[inline(always)]
1013 fn inline_align(_context: fidl::encoding::Context) -> usize {
1014 std::mem::align_of::<u32>()
1015 }
1016
1017 #[inline(always)]
1018 fn inline_size(_context: fidl::encoding::Context) -> usize {
1019 std::mem::size_of::<u32>()
1020 }
1021
1022 #[inline(always)]
1023 fn encode_is_copy() -> bool {
1024 true
1025 }
1026
1027 #[inline(always)]
1028 fn decode_is_copy() -> bool {
1029 false
1030 }
1031 }
1032
1033 impl fidl::encoding::ValueTypeMarker for AddressRemovalReason {
1034 type Borrowed<'a> = Self;
1035 #[inline(always)]
1036 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1037 *value
1038 }
1039 }
1040
1041 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1042 for AddressRemovalReason
1043 {
1044 #[inline]
1045 unsafe fn encode(
1046 self,
1047 encoder: &mut fidl::encoding::Encoder<'_, D>,
1048 offset: usize,
1049 _depth: fidl::encoding::Depth,
1050 ) -> fidl::Result<()> {
1051 encoder.debug_check_bounds::<Self>(offset);
1052 encoder.write_num(self.into_primitive(), offset);
1053 Ok(())
1054 }
1055 }
1056
1057 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressRemovalReason {
1058 #[inline(always)]
1059 fn new_empty() -> Self {
1060 Self::Invalid
1061 }
1062
1063 #[inline]
1064 unsafe fn decode(
1065 &mut self,
1066 decoder: &mut fidl::encoding::Decoder<'_, D>,
1067 offset: usize,
1068 _depth: fidl::encoding::Depth,
1069 ) -> fidl::Result<()> {
1070 decoder.debug_check_bounds::<Self>(offset);
1071 let prim = decoder.read_num::<u32>(offset);
1072
1073 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1074 Ok(())
1075 }
1076 }
1077 unsafe impl fidl::encoding::TypeMarker for ControlDisableError {
1078 type Owned = Self;
1079
1080 #[inline(always)]
1081 fn inline_align(_context: fidl::encoding::Context) -> usize {
1082 std::mem::align_of::<u32>()
1083 }
1084
1085 #[inline(always)]
1086 fn inline_size(_context: fidl::encoding::Context) -> usize {
1087 std::mem::size_of::<u32>()
1088 }
1089
1090 #[inline(always)]
1091 fn encode_is_copy() -> bool {
1092 false
1093 }
1094
1095 #[inline(always)]
1096 fn decode_is_copy() -> bool {
1097 false
1098 }
1099 }
1100
1101 impl fidl::encoding::ValueTypeMarker for ControlDisableError {
1102 type Borrowed<'a> = Self;
1103 #[inline(always)]
1104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1105 *value
1106 }
1107 }
1108
1109 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1110 for ControlDisableError
1111 {
1112 #[inline]
1113 unsafe fn encode(
1114 self,
1115 encoder: &mut fidl::encoding::Encoder<'_, D>,
1116 offset: usize,
1117 _depth: fidl::encoding::Depth,
1118 ) -> fidl::Result<()> {
1119 encoder.debug_check_bounds::<Self>(offset);
1120 encoder.write_num(self.into_primitive(), offset);
1121 Ok(())
1122 }
1123 }
1124
1125 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlDisableError {
1126 #[inline(always)]
1127 fn new_empty() -> Self {
1128 Self::unknown()
1129 }
1130
1131 #[inline]
1132 unsafe fn decode(
1133 &mut self,
1134 decoder: &mut fidl::encoding::Decoder<'_, D>,
1135 offset: usize,
1136 _depth: fidl::encoding::Depth,
1137 ) -> fidl::Result<()> {
1138 decoder.debug_check_bounds::<Self>(offset);
1139 let prim = decoder.read_num::<u32>(offset);
1140
1141 *self = Self::from_primitive_allow_unknown(prim);
1142 Ok(())
1143 }
1144 }
1145 unsafe impl fidl::encoding::TypeMarker for ControlEnableError {
1146 type Owned = Self;
1147
1148 #[inline(always)]
1149 fn inline_align(_context: fidl::encoding::Context) -> usize {
1150 std::mem::align_of::<u32>()
1151 }
1152
1153 #[inline(always)]
1154 fn inline_size(_context: fidl::encoding::Context) -> usize {
1155 std::mem::size_of::<u32>()
1156 }
1157
1158 #[inline(always)]
1159 fn encode_is_copy() -> bool {
1160 false
1161 }
1162
1163 #[inline(always)]
1164 fn decode_is_copy() -> bool {
1165 false
1166 }
1167 }
1168
1169 impl fidl::encoding::ValueTypeMarker for ControlEnableError {
1170 type Borrowed<'a> = Self;
1171 #[inline(always)]
1172 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1173 *value
1174 }
1175 }
1176
1177 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1178 for ControlEnableError
1179 {
1180 #[inline]
1181 unsafe fn encode(
1182 self,
1183 encoder: &mut fidl::encoding::Encoder<'_, D>,
1184 offset: usize,
1185 _depth: fidl::encoding::Depth,
1186 ) -> fidl::Result<()> {
1187 encoder.debug_check_bounds::<Self>(offset);
1188 encoder.write_num(self.into_primitive(), offset);
1189 Ok(())
1190 }
1191 }
1192
1193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableError {
1194 #[inline(always)]
1195 fn new_empty() -> Self {
1196 Self::unknown()
1197 }
1198
1199 #[inline]
1200 unsafe fn decode(
1201 &mut self,
1202 decoder: &mut fidl::encoding::Decoder<'_, D>,
1203 offset: usize,
1204 _depth: fidl::encoding::Depth,
1205 ) -> fidl::Result<()> {
1206 decoder.debug_check_bounds::<Self>(offset);
1207 let prim = decoder.read_num::<u32>(offset);
1208
1209 *self = Self::from_primitive_allow_unknown(prim);
1210 Ok(())
1211 }
1212 }
1213 unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationError {
1214 type Owned = Self;
1215
1216 #[inline(always)]
1217 fn inline_align(_context: fidl::encoding::Context) -> usize {
1218 std::mem::align_of::<u32>()
1219 }
1220
1221 #[inline(always)]
1222 fn inline_size(_context: fidl::encoding::Context) -> usize {
1223 std::mem::size_of::<u32>()
1224 }
1225
1226 #[inline(always)]
1227 fn encode_is_copy() -> bool {
1228 false
1229 }
1230
1231 #[inline(always)]
1232 fn decode_is_copy() -> bool {
1233 false
1234 }
1235 }
1236
1237 impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationError {
1238 type Borrowed<'a> = Self;
1239 #[inline(always)]
1240 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1241 *value
1242 }
1243 }
1244
1245 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1246 for ControlGetConfigurationError
1247 {
1248 #[inline]
1249 unsafe fn encode(
1250 self,
1251 encoder: &mut fidl::encoding::Encoder<'_, D>,
1252 offset: usize,
1253 _depth: fidl::encoding::Depth,
1254 ) -> fidl::Result<()> {
1255 encoder.debug_check_bounds::<Self>(offset);
1256 encoder.write_num(self.into_primitive(), offset);
1257 Ok(())
1258 }
1259 }
1260
1261 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1262 for ControlGetConfigurationError
1263 {
1264 #[inline(always)]
1265 fn new_empty() -> Self {
1266 Self::unknown()
1267 }
1268
1269 #[inline]
1270 unsafe fn decode(
1271 &mut self,
1272 decoder: &mut fidl::encoding::Decoder<'_, D>,
1273 offset: usize,
1274 _depth: fidl::encoding::Depth,
1275 ) -> fidl::Result<()> {
1276 decoder.debug_check_bounds::<Self>(offset);
1277 let prim = decoder.read_num::<u32>(offset);
1278
1279 *self = Self::from_primitive_allow_unknown(prim);
1280 Ok(())
1281 }
1282 }
1283 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressError {
1284 type Owned = Self;
1285
1286 #[inline(always)]
1287 fn inline_align(_context: fidl::encoding::Context) -> usize {
1288 std::mem::align_of::<u32>()
1289 }
1290
1291 #[inline(always)]
1292 fn inline_size(_context: fidl::encoding::Context) -> usize {
1293 std::mem::size_of::<u32>()
1294 }
1295
1296 #[inline(always)]
1297 fn encode_is_copy() -> bool {
1298 false
1299 }
1300
1301 #[inline(always)]
1302 fn decode_is_copy() -> bool {
1303 false
1304 }
1305 }
1306
1307 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressError {
1308 type Borrowed<'a> = Self;
1309 #[inline(always)]
1310 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1311 *value
1312 }
1313 }
1314
1315 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1316 for ControlRemoveAddressError
1317 {
1318 #[inline]
1319 unsafe fn encode(
1320 self,
1321 encoder: &mut fidl::encoding::Encoder<'_, D>,
1322 offset: usize,
1323 _depth: fidl::encoding::Depth,
1324 ) -> fidl::Result<()> {
1325 encoder.debug_check_bounds::<Self>(offset);
1326 encoder.write_num(self.into_primitive(), offset);
1327 Ok(())
1328 }
1329 }
1330
1331 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1332 for ControlRemoveAddressError
1333 {
1334 #[inline(always)]
1335 fn new_empty() -> Self {
1336 Self::unknown()
1337 }
1338
1339 #[inline]
1340 unsafe fn decode(
1341 &mut self,
1342 decoder: &mut fidl::encoding::Decoder<'_, D>,
1343 offset: usize,
1344 _depth: fidl::encoding::Depth,
1345 ) -> fidl::Result<()> {
1346 decoder.debug_check_bounds::<Self>(offset);
1347 let prim = decoder.read_num::<u32>(offset);
1348
1349 *self = Self::from_primitive_allow_unknown(prim);
1350 Ok(())
1351 }
1352 }
1353 unsafe impl fidl::encoding::TypeMarker for ControlRemoveError {
1354 type Owned = Self;
1355
1356 #[inline(always)]
1357 fn inline_align(_context: fidl::encoding::Context) -> usize {
1358 std::mem::align_of::<u32>()
1359 }
1360
1361 #[inline(always)]
1362 fn inline_size(_context: fidl::encoding::Context) -> usize {
1363 std::mem::size_of::<u32>()
1364 }
1365
1366 #[inline(always)]
1367 fn encode_is_copy() -> bool {
1368 false
1369 }
1370
1371 #[inline(always)]
1372 fn decode_is_copy() -> bool {
1373 false
1374 }
1375 }
1376
1377 impl fidl::encoding::ValueTypeMarker for ControlRemoveError {
1378 type Borrowed<'a> = Self;
1379 #[inline(always)]
1380 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1381 *value
1382 }
1383 }
1384
1385 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1386 for ControlRemoveError
1387 {
1388 #[inline]
1389 unsafe fn encode(
1390 self,
1391 encoder: &mut fidl::encoding::Encoder<'_, D>,
1392 offset: usize,
1393 _depth: fidl::encoding::Depth,
1394 ) -> fidl::Result<()> {
1395 encoder.debug_check_bounds::<Self>(offset);
1396 encoder.write_num(self.into_primitive(), offset);
1397 Ok(())
1398 }
1399 }
1400
1401 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlRemoveError {
1402 #[inline(always)]
1403 fn new_empty() -> Self {
1404 Self::unknown()
1405 }
1406
1407 #[inline]
1408 unsafe fn decode(
1409 &mut self,
1410 decoder: &mut fidl::encoding::Decoder<'_, D>,
1411 offset: usize,
1412 _depth: fidl::encoding::Depth,
1413 ) -> fidl::Result<()> {
1414 decoder.debug_check_bounds::<Self>(offset);
1415 let prim = decoder.read_num::<u32>(offset);
1416
1417 *self = Self::from_primitive_allow_unknown(prim);
1418 Ok(())
1419 }
1420 }
1421 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationError {
1422 type Owned = Self;
1423
1424 #[inline(always)]
1425 fn inline_align(_context: fidl::encoding::Context) -> usize {
1426 std::mem::align_of::<u32>()
1427 }
1428
1429 #[inline(always)]
1430 fn inline_size(_context: fidl::encoding::Context) -> usize {
1431 std::mem::size_of::<u32>()
1432 }
1433
1434 #[inline(always)]
1435 fn encode_is_copy() -> bool {
1436 false
1437 }
1438
1439 #[inline(always)]
1440 fn decode_is_copy() -> bool {
1441 false
1442 }
1443 }
1444
1445 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationError {
1446 type Borrowed<'a> = Self;
1447 #[inline(always)]
1448 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1449 *value
1450 }
1451 }
1452
1453 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1454 for ControlSetConfigurationError
1455 {
1456 #[inline]
1457 unsafe fn encode(
1458 self,
1459 encoder: &mut fidl::encoding::Encoder<'_, D>,
1460 offset: usize,
1461 _depth: fidl::encoding::Depth,
1462 ) -> fidl::Result<()> {
1463 encoder.debug_check_bounds::<Self>(offset);
1464 encoder.write_num(self.into_primitive(), offset);
1465 Ok(())
1466 }
1467 }
1468
1469 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1470 for ControlSetConfigurationError
1471 {
1472 #[inline(always)]
1473 fn new_empty() -> Self {
1474 Self::unknown()
1475 }
1476
1477 #[inline]
1478 unsafe fn decode(
1479 &mut self,
1480 decoder: &mut fidl::encoding::Decoder<'_, D>,
1481 offset: usize,
1482 _depth: fidl::encoding::Depth,
1483 ) -> fidl::Result<()> {
1484 decoder.debug_check_bounds::<Self>(offset);
1485 let prim = decoder.read_num::<u32>(offset);
1486
1487 *self = Self::from_primitive_allow_unknown(prim);
1488 Ok(())
1489 }
1490 }
1491 unsafe impl fidl::encoding::TypeMarker for IgmpVersion {
1492 type Owned = Self;
1493
1494 #[inline(always)]
1495 fn inline_align(_context: fidl::encoding::Context) -> usize {
1496 std::mem::align_of::<u8>()
1497 }
1498
1499 #[inline(always)]
1500 fn inline_size(_context: fidl::encoding::Context) -> usize {
1501 std::mem::size_of::<u8>()
1502 }
1503
1504 #[inline(always)]
1505 fn encode_is_copy() -> bool {
1506 false
1507 }
1508
1509 #[inline(always)]
1510 fn decode_is_copy() -> bool {
1511 false
1512 }
1513 }
1514
1515 impl fidl::encoding::ValueTypeMarker for IgmpVersion {
1516 type Borrowed<'a> = Self;
1517 #[inline(always)]
1518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1519 *value
1520 }
1521 }
1522
1523 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IgmpVersion {
1524 #[inline]
1525 unsafe fn encode(
1526 self,
1527 encoder: &mut fidl::encoding::Encoder<'_, D>,
1528 offset: usize,
1529 _depth: fidl::encoding::Depth,
1530 ) -> fidl::Result<()> {
1531 encoder.debug_check_bounds::<Self>(offset);
1532 encoder.write_num(self.into_primitive(), offset);
1533 Ok(())
1534 }
1535 }
1536
1537 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpVersion {
1538 #[inline(always)]
1539 fn new_empty() -> Self {
1540 Self::unknown()
1541 }
1542
1543 #[inline]
1544 unsafe fn decode(
1545 &mut self,
1546 decoder: &mut fidl::encoding::Decoder<'_, D>,
1547 offset: usize,
1548 _depth: fidl::encoding::Depth,
1549 ) -> fidl::Result<()> {
1550 decoder.debug_check_bounds::<Self>(offset);
1551 let prim = decoder.read_num::<u8>(offset);
1552
1553 *self = Self::from_primitive_allow_unknown(prim);
1554 Ok(())
1555 }
1556 }
1557 unsafe impl fidl::encoding::TypeMarker for InterfaceRemovedReason {
1558 type Owned = Self;
1559
1560 #[inline(always)]
1561 fn inline_align(_context: fidl::encoding::Context) -> usize {
1562 std::mem::align_of::<u32>()
1563 }
1564
1565 #[inline(always)]
1566 fn inline_size(_context: fidl::encoding::Context) -> usize {
1567 std::mem::size_of::<u32>()
1568 }
1569
1570 #[inline(always)]
1571 fn encode_is_copy() -> bool {
1572 false
1573 }
1574
1575 #[inline(always)]
1576 fn decode_is_copy() -> bool {
1577 false
1578 }
1579 }
1580
1581 impl fidl::encoding::ValueTypeMarker for InterfaceRemovedReason {
1582 type Borrowed<'a> = Self;
1583 #[inline(always)]
1584 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1585 *value
1586 }
1587 }
1588
1589 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1590 for InterfaceRemovedReason
1591 {
1592 #[inline]
1593 unsafe fn encode(
1594 self,
1595 encoder: &mut fidl::encoding::Encoder<'_, D>,
1596 offset: usize,
1597 _depth: fidl::encoding::Depth,
1598 ) -> fidl::Result<()> {
1599 encoder.debug_check_bounds::<Self>(offset);
1600 encoder.write_num(self.into_primitive(), offset);
1601 Ok(())
1602 }
1603 }
1604
1605 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1606 for InterfaceRemovedReason
1607 {
1608 #[inline(always)]
1609 fn new_empty() -> Self {
1610 Self::unknown()
1611 }
1612
1613 #[inline]
1614 unsafe fn decode(
1615 &mut self,
1616 decoder: &mut fidl::encoding::Decoder<'_, D>,
1617 offset: usize,
1618 _depth: fidl::encoding::Depth,
1619 ) -> fidl::Result<()> {
1620 decoder.debug_check_bounds::<Self>(offset);
1621 let prim = decoder.read_num::<u32>(offset);
1622
1623 *self = Self::from_primitive_allow_unknown(prim);
1624 Ok(())
1625 }
1626 }
1627 unsafe impl fidl::encoding::TypeMarker for MldVersion {
1628 type Owned = Self;
1629
1630 #[inline(always)]
1631 fn inline_align(_context: fidl::encoding::Context) -> usize {
1632 std::mem::align_of::<u8>()
1633 }
1634
1635 #[inline(always)]
1636 fn inline_size(_context: fidl::encoding::Context) -> usize {
1637 std::mem::size_of::<u8>()
1638 }
1639
1640 #[inline(always)]
1641 fn encode_is_copy() -> bool {
1642 false
1643 }
1644
1645 #[inline(always)]
1646 fn decode_is_copy() -> bool {
1647 false
1648 }
1649 }
1650
1651 impl fidl::encoding::ValueTypeMarker for MldVersion {
1652 type Borrowed<'a> = Self;
1653 #[inline(always)]
1654 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1655 *value
1656 }
1657 }
1658
1659 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MldVersion {
1660 #[inline]
1661 unsafe fn encode(
1662 self,
1663 encoder: &mut fidl::encoding::Encoder<'_, D>,
1664 offset: usize,
1665 _depth: fidl::encoding::Depth,
1666 ) -> fidl::Result<()> {
1667 encoder.debug_check_bounds::<Self>(offset);
1668 encoder.write_num(self.into_primitive(), offset);
1669 Ok(())
1670 }
1671 }
1672
1673 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldVersion {
1674 #[inline(always)]
1675 fn new_empty() -> Self {
1676 Self::unknown()
1677 }
1678
1679 #[inline]
1680 unsafe fn decode(
1681 &mut self,
1682 decoder: &mut fidl::encoding::Decoder<'_, D>,
1683 offset: usize,
1684 _depth: fidl::encoding::Depth,
1685 ) -> fidl::Result<()> {
1686 decoder.debug_check_bounds::<Self>(offset);
1687 let prim = decoder.read_num::<u8>(offset);
1688
1689 *self = Self::from_primitive_allow_unknown(prim);
1690 Ok(())
1691 }
1692 }
1693
1694 impl fidl::encoding::ValueTypeMarker for AddressStateProviderOnAddressRemovedRequest {
1695 type Borrowed<'a> = &'a Self;
1696 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1697 value
1698 }
1699 }
1700
1701 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderOnAddressRemovedRequest {
1702 type Owned = Self;
1703
1704 #[inline(always)]
1705 fn inline_align(_context: fidl::encoding::Context) -> usize {
1706 4
1707 }
1708
1709 #[inline(always)]
1710 fn inline_size(_context: fidl::encoding::Context) -> usize {
1711 4
1712 }
1713 }
1714
1715 unsafe impl<D: fidl::encoding::ResourceDialect>
1716 fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D>
1717 for &AddressStateProviderOnAddressRemovedRequest
1718 {
1719 #[inline]
1720 unsafe fn encode(
1721 self,
1722 encoder: &mut fidl::encoding::Encoder<'_, D>,
1723 offset: usize,
1724 _depth: fidl::encoding::Depth,
1725 ) -> fidl::Result<()> {
1726 encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1727 fidl::encoding::Encode::<AddressStateProviderOnAddressRemovedRequest, D>::encode(
1729 (<AddressRemovalReason as fidl::encoding::ValueTypeMarker>::borrow(&self.error),),
1730 encoder,
1731 offset,
1732 _depth,
1733 )
1734 }
1735 }
1736 unsafe impl<
1737 D: fidl::encoding::ResourceDialect,
1738 T0: fidl::encoding::Encode<AddressRemovalReason, D>,
1739 > fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D> for (T0,)
1740 {
1741 #[inline]
1742 unsafe fn encode(
1743 self,
1744 encoder: &mut fidl::encoding::Encoder<'_, D>,
1745 offset: usize,
1746 depth: fidl::encoding::Depth,
1747 ) -> fidl::Result<()> {
1748 encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1749 self.0.encode(encoder, offset + 0, depth)?;
1753 Ok(())
1754 }
1755 }
1756
1757 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1758 for AddressStateProviderOnAddressRemovedRequest
1759 {
1760 #[inline(always)]
1761 fn new_empty() -> Self {
1762 Self { error: fidl::new_empty!(AddressRemovalReason, D) }
1763 }
1764
1765 #[inline]
1766 unsafe fn decode(
1767 &mut self,
1768 decoder: &mut fidl::encoding::Decoder<'_, D>,
1769 offset: usize,
1770 _depth: fidl::encoding::Depth,
1771 ) -> fidl::Result<()> {
1772 decoder.debug_check_bounds::<Self>(offset);
1773 fidl::decode!(AddressRemovalReason, D, &mut self.error, decoder, offset + 0, _depth)?;
1775 Ok(())
1776 }
1777 }
1778
1779 impl fidl::encoding::ValueTypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1780 type Borrowed<'a> = &'a Self;
1781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1782 value
1783 }
1784 }
1785
1786 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1787 type Owned = Self;
1788
1789 #[inline(always)]
1790 fn inline_align(_context: fidl::encoding::Context) -> usize {
1791 8
1792 }
1793
1794 #[inline(always)]
1795 fn inline_size(_context: fidl::encoding::Context) -> usize {
1796 16
1797 }
1798 }
1799
1800 unsafe impl<D: fidl::encoding::ResourceDialect>
1801 fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D>
1802 for &AddressStateProviderUpdateAddressPropertiesRequest
1803 {
1804 #[inline]
1805 unsafe fn encode(
1806 self,
1807 encoder: &mut fidl::encoding::Encoder<'_, D>,
1808 offset: usize,
1809 _depth: fidl::encoding::Depth,
1810 ) -> fidl::Result<()> {
1811 encoder
1812 .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1813 fidl::encoding::Encode::<AddressStateProviderUpdateAddressPropertiesRequest, D>::encode(
1815 (<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow(
1816 &self.address_properties,
1817 ),),
1818 encoder,
1819 offset,
1820 _depth,
1821 )
1822 }
1823 }
1824 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AddressProperties, D>>
1825 fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D> for (T0,)
1826 {
1827 #[inline]
1828 unsafe fn encode(
1829 self,
1830 encoder: &mut fidl::encoding::Encoder<'_, D>,
1831 offset: usize,
1832 depth: fidl::encoding::Depth,
1833 ) -> fidl::Result<()> {
1834 encoder
1835 .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1836 self.0.encode(encoder, offset + 0, depth)?;
1840 Ok(())
1841 }
1842 }
1843
1844 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1845 for AddressStateProviderUpdateAddressPropertiesRequest
1846 {
1847 #[inline(always)]
1848 fn new_empty() -> Self {
1849 Self { address_properties: fidl::new_empty!(AddressProperties, D) }
1850 }
1851
1852 #[inline]
1853 unsafe fn decode(
1854 &mut self,
1855 decoder: &mut fidl::encoding::Decoder<'_, D>,
1856 offset: usize,
1857 _depth: fidl::encoding::Depth,
1858 ) -> fidl::Result<()> {
1859 decoder.debug_check_bounds::<Self>(offset);
1860 fidl::decode!(
1862 AddressProperties,
1863 D,
1864 &mut self.address_properties,
1865 decoder,
1866 offset + 0,
1867 _depth
1868 )?;
1869 Ok(())
1870 }
1871 }
1872
1873 impl fidl::encoding::ValueTypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1874 type Borrowed<'a> = &'a Self;
1875 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1876 value
1877 }
1878 }
1879
1880 unsafe impl fidl::encoding::TypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1881 type Owned = Self;
1882
1883 #[inline(always)]
1884 fn inline_align(_context: fidl::encoding::Context) -> usize {
1885 4
1886 }
1887
1888 #[inline(always)]
1889 fn inline_size(_context: fidl::encoding::Context) -> usize {
1890 4
1891 }
1892 }
1893
1894 unsafe impl<D: fidl::encoding::ResourceDialect>
1895 fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1896 for &AddressStateProviderWatchAddressAssignmentStateResponse
1897 {
1898 #[inline]
1899 unsafe fn encode(
1900 self,
1901 encoder: &mut fidl::encoding::Encoder<'_, D>,
1902 offset: usize,
1903 _depth: fidl::encoding::Depth,
1904 ) -> fidl::Result<()> {
1905 encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1906 offset,
1907 );
1908 fidl::encoding::Encode::<AddressStateProviderWatchAddressAssignmentStateResponse, D>::encode(
1910 (
1911 <fidl_fuchsia_net_interfaces__common::AddressAssignmentState as fidl::encoding::ValueTypeMarker>::borrow(&self.assignment_state),
1912 ),
1913 encoder, offset, _depth
1914 )
1915 }
1916 }
1917 unsafe impl<
1918 D: fidl::encoding::ResourceDialect,
1919 T0: fidl::encoding::Encode<fidl_fuchsia_net_interfaces__common::AddressAssignmentState, D>,
1920 > fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1921 for (T0,)
1922 {
1923 #[inline]
1924 unsafe fn encode(
1925 self,
1926 encoder: &mut fidl::encoding::Encoder<'_, D>,
1927 offset: usize,
1928 depth: fidl::encoding::Depth,
1929 ) -> fidl::Result<()> {
1930 encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1931 offset,
1932 );
1933 self.0.encode(encoder, offset + 0, depth)?;
1937 Ok(())
1938 }
1939 }
1940
1941 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1942 for AddressStateProviderWatchAddressAssignmentStateResponse
1943 {
1944 #[inline(always)]
1945 fn new_empty() -> Self {
1946 Self {
1947 assignment_state: fidl::new_empty!(
1948 fidl_fuchsia_net_interfaces__common::AddressAssignmentState,
1949 D
1950 ),
1951 }
1952 }
1953
1954 #[inline]
1955 unsafe fn decode(
1956 &mut self,
1957 decoder: &mut fidl::encoding::Decoder<'_, D>,
1958 offset: usize,
1959 _depth: fidl::encoding::Depth,
1960 ) -> fidl::Result<()> {
1961 decoder.debug_check_bounds::<Self>(offset);
1962 fidl::decode!(
1964 fidl_fuchsia_net_interfaces__common::AddressAssignmentState,
1965 D,
1966 &mut self.assignment_state,
1967 decoder,
1968 offset + 0,
1969 _depth
1970 )?;
1971 Ok(())
1972 }
1973 }
1974
1975 impl fidl::encoding::ValueTypeMarker for ControlGetIdResponse {
1976 type Borrowed<'a> = &'a Self;
1977 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978 value
1979 }
1980 }
1981
1982 unsafe impl fidl::encoding::TypeMarker for ControlGetIdResponse {
1983 type Owned = Self;
1984
1985 #[inline(always)]
1986 fn inline_align(_context: fidl::encoding::Context) -> usize {
1987 8
1988 }
1989
1990 #[inline(always)]
1991 fn inline_size(_context: fidl::encoding::Context) -> usize {
1992 8
1993 }
1994 #[inline(always)]
1995 fn encode_is_copy() -> bool {
1996 true
1997 }
1998
1999 #[inline(always)]
2000 fn decode_is_copy() -> bool {
2001 true
2002 }
2003 }
2004
2005 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlGetIdResponse, D>
2006 for &ControlGetIdResponse
2007 {
2008 #[inline]
2009 unsafe fn encode(
2010 self,
2011 encoder: &mut fidl::encoding::Encoder<'_, D>,
2012 offset: usize,
2013 _depth: fidl::encoding::Depth,
2014 ) -> fidl::Result<()> {
2015 encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
2016 unsafe {
2017 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2019 (buf_ptr as *mut ControlGetIdResponse)
2020 .write_unaligned((self as *const ControlGetIdResponse).read());
2021 }
2024 Ok(())
2025 }
2026 }
2027 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2028 fidl::encoding::Encode<ControlGetIdResponse, D> for (T0,)
2029 {
2030 #[inline]
2031 unsafe fn encode(
2032 self,
2033 encoder: &mut fidl::encoding::Encoder<'_, D>,
2034 offset: usize,
2035 depth: fidl::encoding::Depth,
2036 ) -> fidl::Result<()> {
2037 encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
2038 self.0.encode(encoder, offset + 0, depth)?;
2042 Ok(())
2043 }
2044 }
2045
2046 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlGetIdResponse {
2047 #[inline(always)]
2048 fn new_empty() -> Self {
2049 Self { id: fidl::new_empty!(u64, D) }
2050 }
2051
2052 #[inline]
2053 unsafe fn decode(
2054 &mut self,
2055 decoder: &mut fidl::encoding::Decoder<'_, D>,
2056 offset: usize,
2057 _depth: fidl::encoding::Depth,
2058 ) -> fidl::Result<()> {
2059 decoder.debug_check_bounds::<Self>(offset);
2060 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2061 unsafe {
2064 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2065 }
2066 Ok(())
2067 }
2068 }
2069
2070 impl fidl::encoding::ValueTypeMarker for ControlOnInterfaceRemovedRequest {
2071 type Borrowed<'a> = &'a Self;
2072 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2073 value
2074 }
2075 }
2076
2077 unsafe impl fidl::encoding::TypeMarker for ControlOnInterfaceRemovedRequest {
2078 type Owned = Self;
2079
2080 #[inline(always)]
2081 fn inline_align(_context: fidl::encoding::Context) -> usize {
2082 4
2083 }
2084
2085 #[inline(always)]
2086 fn inline_size(_context: fidl::encoding::Context) -> usize {
2087 4
2088 }
2089 }
2090
2091 unsafe impl<D: fidl::encoding::ResourceDialect>
2092 fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D>
2093 for &ControlOnInterfaceRemovedRequest
2094 {
2095 #[inline]
2096 unsafe fn encode(
2097 self,
2098 encoder: &mut fidl::encoding::Encoder<'_, D>,
2099 offset: usize,
2100 _depth: fidl::encoding::Depth,
2101 ) -> fidl::Result<()> {
2102 encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2103 fidl::encoding::Encode::<ControlOnInterfaceRemovedRequest, D>::encode(
2105 (<InterfaceRemovedReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
2106 encoder,
2107 offset,
2108 _depth,
2109 )
2110 }
2111 }
2112 unsafe impl<
2113 D: fidl::encoding::ResourceDialect,
2114 T0: fidl::encoding::Encode<InterfaceRemovedReason, D>,
2115 > fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D> for (T0,)
2116 {
2117 #[inline]
2118 unsafe fn encode(
2119 self,
2120 encoder: &mut fidl::encoding::Encoder<'_, D>,
2121 offset: usize,
2122 depth: fidl::encoding::Depth,
2123 ) -> fidl::Result<()> {
2124 encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2125 self.0.encode(encoder, offset + 0, depth)?;
2129 Ok(())
2130 }
2131 }
2132
2133 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2134 for ControlOnInterfaceRemovedRequest
2135 {
2136 #[inline(always)]
2137 fn new_empty() -> Self {
2138 Self { reason: fidl::new_empty!(InterfaceRemovedReason, D) }
2139 }
2140
2141 #[inline]
2142 unsafe fn decode(
2143 &mut self,
2144 decoder: &mut fidl::encoding::Decoder<'_, D>,
2145 offset: usize,
2146 _depth: fidl::encoding::Depth,
2147 ) -> fidl::Result<()> {
2148 decoder.debug_check_bounds::<Self>(offset);
2149 fidl::decode!(
2151 InterfaceRemovedReason,
2152 D,
2153 &mut self.reason,
2154 decoder,
2155 offset + 0,
2156 _depth
2157 )?;
2158 Ok(())
2159 }
2160 }
2161
2162 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressRequest {
2163 type Borrowed<'a> = &'a Self;
2164 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2165 value
2166 }
2167 }
2168
2169 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressRequest {
2170 type Owned = Self;
2171
2172 #[inline(always)]
2173 fn inline_align(_context: fidl::encoding::Context) -> usize {
2174 8
2175 }
2176
2177 #[inline(always)]
2178 fn inline_size(_context: fidl::encoding::Context) -> usize {
2179 24
2180 }
2181 }
2182
2183 unsafe impl<D: fidl::encoding::ResourceDialect>
2184 fidl::encoding::Encode<ControlRemoveAddressRequest, D> for &ControlRemoveAddressRequest
2185 {
2186 #[inline]
2187 unsafe fn encode(
2188 self,
2189 encoder: &mut fidl::encoding::Encoder<'_, D>,
2190 offset: usize,
2191 _depth: fidl::encoding::Depth,
2192 ) -> fidl::Result<()> {
2193 encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2194 fidl::encoding::Encode::<ControlRemoveAddressRequest, D>::encode(
2196 (<fidl_fuchsia_net__common::Subnet as fidl::encoding::ValueTypeMarker>::borrow(
2197 &self.address,
2198 ),),
2199 encoder,
2200 offset,
2201 _depth,
2202 )
2203 }
2204 }
2205 unsafe impl<
2206 D: fidl::encoding::ResourceDialect,
2207 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Subnet, D>,
2208 > fidl::encoding::Encode<ControlRemoveAddressRequest, D> for (T0,)
2209 {
2210 #[inline]
2211 unsafe fn encode(
2212 self,
2213 encoder: &mut fidl::encoding::Encoder<'_, D>,
2214 offset: usize,
2215 depth: fidl::encoding::Depth,
2216 ) -> fidl::Result<()> {
2217 encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2218 self.0.encode(encoder, offset + 0, depth)?;
2222 Ok(())
2223 }
2224 }
2225
2226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2227 for ControlRemoveAddressRequest
2228 {
2229 #[inline(always)]
2230 fn new_empty() -> Self {
2231 Self { address: fidl::new_empty!(fidl_fuchsia_net__common::Subnet, D) }
2232 }
2233
2234 #[inline]
2235 unsafe fn decode(
2236 &mut self,
2237 decoder: &mut fidl::encoding::Decoder<'_, D>,
2238 offset: usize,
2239 _depth: fidl::encoding::Depth,
2240 ) -> fidl::Result<()> {
2241 decoder.debug_check_bounds::<Self>(offset);
2242 fidl::decode!(
2244 fidl_fuchsia_net__common::Subnet,
2245 D,
2246 &mut self.address,
2247 decoder,
2248 offset + 0,
2249 _depth
2250 )?;
2251 Ok(())
2252 }
2253 }
2254
2255 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationRequest {
2256 type Borrowed<'a> = &'a Self;
2257 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2258 value
2259 }
2260 }
2261
2262 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationRequest {
2263 type Owned = Self;
2264
2265 #[inline(always)]
2266 fn inline_align(_context: fidl::encoding::Context) -> usize {
2267 8
2268 }
2269
2270 #[inline(always)]
2271 fn inline_size(_context: fidl::encoding::Context) -> usize {
2272 16
2273 }
2274 }
2275
2276 unsafe impl<D: fidl::encoding::ResourceDialect>
2277 fidl::encoding::Encode<ControlSetConfigurationRequest, D>
2278 for &ControlSetConfigurationRequest
2279 {
2280 #[inline]
2281 unsafe fn encode(
2282 self,
2283 encoder: &mut fidl::encoding::Encoder<'_, D>,
2284 offset: usize,
2285 _depth: fidl::encoding::Depth,
2286 ) -> fidl::Result<()> {
2287 encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2288 fidl::encoding::Encode::<ControlSetConfigurationRequest, D>::encode(
2290 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2291 encoder,
2292 offset,
2293 _depth,
2294 )
2295 }
2296 }
2297 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2298 fidl::encoding::Encode<ControlSetConfigurationRequest, D> for (T0,)
2299 {
2300 #[inline]
2301 unsafe fn encode(
2302 self,
2303 encoder: &mut fidl::encoding::Encoder<'_, D>,
2304 offset: usize,
2305 depth: fidl::encoding::Depth,
2306 ) -> fidl::Result<()> {
2307 encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2308 self.0.encode(encoder, offset + 0, depth)?;
2312 Ok(())
2313 }
2314 }
2315
2316 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2317 for ControlSetConfigurationRequest
2318 {
2319 #[inline(always)]
2320 fn new_empty() -> Self {
2321 Self { config: fidl::new_empty!(Configuration, D) }
2322 }
2323
2324 #[inline]
2325 unsafe fn decode(
2326 &mut self,
2327 decoder: &mut fidl::encoding::Decoder<'_, D>,
2328 offset: usize,
2329 _depth: fidl::encoding::Depth,
2330 ) -> fidl::Result<()> {
2331 decoder.debug_check_bounds::<Self>(offset);
2332 fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2334 Ok(())
2335 }
2336 }
2337
2338 impl fidl::encoding::ValueTypeMarker for ControlDisableResponse {
2339 type Borrowed<'a> = &'a Self;
2340 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2341 value
2342 }
2343 }
2344
2345 unsafe impl fidl::encoding::TypeMarker for ControlDisableResponse {
2346 type Owned = Self;
2347
2348 #[inline(always)]
2349 fn inline_align(_context: fidl::encoding::Context) -> usize {
2350 1
2351 }
2352
2353 #[inline(always)]
2354 fn inline_size(_context: fidl::encoding::Context) -> usize {
2355 1
2356 }
2357 }
2358
2359 unsafe impl<D: fidl::encoding::ResourceDialect>
2360 fidl::encoding::Encode<ControlDisableResponse, D> for &ControlDisableResponse
2361 {
2362 #[inline]
2363 unsafe fn encode(
2364 self,
2365 encoder: &mut fidl::encoding::Encoder<'_, D>,
2366 offset: usize,
2367 _depth: fidl::encoding::Depth,
2368 ) -> fidl::Result<()> {
2369 encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2370 fidl::encoding::Encode::<ControlDisableResponse, D>::encode(
2372 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_disable),),
2373 encoder,
2374 offset,
2375 _depth,
2376 )
2377 }
2378 }
2379 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2380 fidl::encoding::Encode<ControlDisableResponse, D> for (T0,)
2381 {
2382 #[inline]
2383 unsafe fn encode(
2384 self,
2385 encoder: &mut fidl::encoding::Encoder<'_, D>,
2386 offset: usize,
2387 depth: fidl::encoding::Depth,
2388 ) -> fidl::Result<()> {
2389 encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2390 self.0.encode(encoder, offset + 0, depth)?;
2394 Ok(())
2395 }
2396 }
2397
2398 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2399 for ControlDisableResponse
2400 {
2401 #[inline(always)]
2402 fn new_empty() -> Self {
2403 Self { did_disable: fidl::new_empty!(bool, D) }
2404 }
2405
2406 #[inline]
2407 unsafe fn decode(
2408 &mut self,
2409 decoder: &mut fidl::encoding::Decoder<'_, D>,
2410 offset: usize,
2411 _depth: fidl::encoding::Depth,
2412 ) -> fidl::Result<()> {
2413 decoder.debug_check_bounds::<Self>(offset);
2414 fidl::decode!(bool, D, &mut self.did_disable, decoder, offset + 0, _depth)?;
2416 Ok(())
2417 }
2418 }
2419
2420 impl fidl::encoding::ValueTypeMarker for ControlEnableResponse {
2421 type Borrowed<'a> = &'a Self;
2422 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2423 value
2424 }
2425 }
2426
2427 unsafe impl fidl::encoding::TypeMarker for ControlEnableResponse {
2428 type Owned = Self;
2429
2430 #[inline(always)]
2431 fn inline_align(_context: fidl::encoding::Context) -> usize {
2432 1
2433 }
2434
2435 #[inline(always)]
2436 fn inline_size(_context: fidl::encoding::Context) -> usize {
2437 1
2438 }
2439 }
2440
2441 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlEnableResponse, D>
2442 for &ControlEnableResponse
2443 {
2444 #[inline]
2445 unsafe fn encode(
2446 self,
2447 encoder: &mut fidl::encoding::Encoder<'_, D>,
2448 offset: usize,
2449 _depth: fidl::encoding::Depth,
2450 ) -> fidl::Result<()> {
2451 encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2452 fidl::encoding::Encode::<ControlEnableResponse, D>::encode(
2454 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_enable),),
2455 encoder,
2456 offset,
2457 _depth,
2458 )
2459 }
2460 }
2461 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2462 fidl::encoding::Encode<ControlEnableResponse, D> for (T0,)
2463 {
2464 #[inline]
2465 unsafe fn encode(
2466 self,
2467 encoder: &mut fidl::encoding::Encoder<'_, D>,
2468 offset: usize,
2469 depth: fidl::encoding::Depth,
2470 ) -> fidl::Result<()> {
2471 encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2472 self.0.encode(encoder, offset + 0, depth)?;
2476 Ok(())
2477 }
2478 }
2479
2480 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableResponse {
2481 #[inline(always)]
2482 fn new_empty() -> Self {
2483 Self { did_enable: fidl::new_empty!(bool, D) }
2484 }
2485
2486 #[inline]
2487 unsafe fn decode(
2488 &mut self,
2489 decoder: &mut fidl::encoding::Decoder<'_, D>,
2490 offset: usize,
2491 _depth: fidl::encoding::Depth,
2492 ) -> fidl::Result<()> {
2493 decoder.debug_check_bounds::<Self>(offset);
2494 fidl::decode!(bool, D, &mut self.did_enable, decoder, offset + 0, _depth)?;
2496 Ok(())
2497 }
2498 }
2499
2500 impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationResponse {
2501 type Borrowed<'a> = &'a Self;
2502 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2503 value
2504 }
2505 }
2506
2507 unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationResponse {
2508 type Owned = Self;
2509
2510 #[inline(always)]
2511 fn inline_align(_context: fidl::encoding::Context) -> usize {
2512 8
2513 }
2514
2515 #[inline(always)]
2516 fn inline_size(_context: fidl::encoding::Context) -> usize {
2517 16
2518 }
2519 }
2520
2521 unsafe impl<D: fidl::encoding::ResourceDialect>
2522 fidl::encoding::Encode<ControlGetConfigurationResponse, D>
2523 for &ControlGetConfigurationResponse
2524 {
2525 #[inline]
2526 unsafe fn encode(
2527 self,
2528 encoder: &mut fidl::encoding::Encoder<'_, D>,
2529 offset: usize,
2530 _depth: fidl::encoding::Depth,
2531 ) -> fidl::Result<()> {
2532 encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2533 fidl::encoding::Encode::<ControlGetConfigurationResponse, D>::encode(
2535 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2536 encoder,
2537 offset,
2538 _depth,
2539 )
2540 }
2541 }
2542 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2543 fidl::encoding::Encode<ControlGetConfigurationResponse, D> for (T0,)
2544 {
2545 #[inline]
2546 unsafe fn encode(
2547 self,
2548 encoder: &mut fidl::encoding::Encoder<'_, D>,
2549 offset: usize,
2550 depth: fidl::encoding::Depth,
2551 ) -> fidl::Result<()> {
2552 encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2553 self.0.encode(encoder, offset + 0, depth)?;
2557 Ok(())
2558 }
2559 }
2560
2561 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2562 for ControlGetConfigurationResponse
2563 {
2564 #[inline(always)]
2565 fn new_empty() -> Self {
2566 Self { config: fidl::new_empty!(Configuration, D) }
2567 }
2568
2569 #[inline]
2570 unsafe fn decode(
2571 &mut self,
2572 decoder: &mut fidl::encoding::Decoder<'_, D>,
2573 offset: usize,
2574 _depth: fidl::encoding::Depth,
2575 ) -> fidl::Result<()> {
2576 decoder.debug_check_bounds::<Self>(offset);
2577 fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2579 Ok(())
2580 }
2581 }
2582
2583 impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressResponse {
2584 type Borrowed<'a> = &'a Self;
2585 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2586 value
2587 }
2588 }
2589
2590 unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressResponse {
2591 type Owned = Self;
2592
2593 #[inline(always)]
2594 fn inline_align(_context: fidl::encoding::Context) -> usize {
2595 1
2596 }
2597
2598 #[inline(always)]
2599 fn inline_size(_context: fidl::encoding::Context) -> usize {
2600 1
2601 }
2602 }
2603
2604 unsafe impl<D: fidl::encoding::ResourceDialect>
2605 fidl::encoding::Encode<ControlRemoveAddressResponse, D> for &ControlRemoveAddressResponse
2606 {
2607 #[inline]
2608 unsafe fn encode(
2609 self,
2610 encoder: &mut fidl::encoding::Encoder<'_, D>,
2611 offset: usize,
2612 _depth: fidl::encoding::Depth,
2613 ) -> fidl::Result<()> {
2614 encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2615 fidl::encoding::Encode::<ControlRemoveAddressResponse, D>::encode(
2617 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_remove),),
2618 encoder,
2619 offset,
2620 _depth,
2621 )
2622 }
2623 }
2624 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2625 fidl::encoding::Encode<ControlRemoveAddressResponse, D> for (T0,)
2626 {
2627 #[inline]
2628 unsafe fn encode(
2629 self,
2630 encoder: &mut fidl::encoding::Encoder<'_, D>,
2631 offset: usize,
2632 depth: fidl::encoding::Depth,
2633 ) -> fidl::Result<()> {
2634 encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2635 self.0.encode(encoder, offset + 0, depth)?;
2639 Ok(())
2640 }
2641 }
2642
2643 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2644 for ControlRemoveAddressResponse
2645 {
2646 #[inline(always)]
2647 fn new_empty() -> Self {
2648 Self { did_remove: fidl::new_empty!(bool, D) }
2649 }
2650
2651 #[inline]
2652 unsafe fn decode(
2653 &mut self,
2654 decoder: &mut fidl::encoding::Decoder<'_, D>,
2655 offset: usize,
2656 _depth: fidl::encoding::Depth,
2657 ) -> fidl::Result<()> {
2658 decoder.debug_check_bounds::<Self>(offset);
2659 fidl::decode!(bool, D, &mut self.did_remove, decoder, offset + 0, _depth)?;
2661 Ok(())
2662 }
2663 }
2664
2665 impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationResponse {
2666 type Borrowed<'a> = &'a Self;
2667 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2668 value
2669 }
2670 }
2671
2672 unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationResponse {
2673 type Owned = Self;
2674
2675 #[inline(always)]
2676 fn inline_align(_context: fidl::encoding::Context) -> usize {
2677 8
2678 }
2679
2680 #[inline(always)]
2681 fn inline_size(_context: fidl::encoding::Context) -> usize {
2682 16
2683 }
2684 }
2685
2686 unsafe impl<D: fidl::encoding::ResourceDialect>
2687 fidl::encoding::Encode<ControlSetConfigurationResponse, D>
2688 for &ControlSetConfigurationResponse
2689 {
2690 #[inline]
2691 unsafe fn encode(
2692 self,
2693 encoder: &mut fidl::encoding::Encoder<'_, D>,
2694 offset: usize,
2695 _depth: fidl::encoding::Depth,
2696 ) -> fidl::Result<()> {
2697 encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2698 fidl::encoding::Encode::<ControlSetConfigurationResponse, D>::encode(
2700 (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.previous_config),),
2701 encoder,
2702 offset,
2703 _depth,
2704 )
2705 }
2706 }
2707 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2708 fidl::encoding::Encode<ControlSetConfigurationResponse, D> for (T0,)
2709 {
2710 #[inline]
2711 unsafe fn encode(
2712 self,
2713 encoder: &mut fidl::encoding::Encoder<'_, D>,
2714 offset: usize,
2715 depth: fidl::encoding::Depth,
2716 ) -> fidl::Result<()> {
2717 encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2718 self.0.encode(encoder, offset + 0, depth)?;
2722 Ok(())
2723 }
2724 }
2725
2726 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2727 for ControlSetConfigurationResponse
2728 {
2729 #[inline(always)]
2730 fn new_empty() -> Self {
2731 Self { previous_config: fidl::new_empty!(Configuration, D) }
2732 }
2733
2734 #[inline]
2735 unsafe fn decode(
2736 &mut self,
2737 decoder: &mut fidl::encoding::Decoder<'_, D>,
2738 offset: usize,
2739 _depth: fidl::encoding::Depth,
2740 ) -> fidl::Result<()> {
2741 decoder.debug_check_bounds::<Self>(offset);
2742 fidl::decode!(
2744 Configuration,
2745 D,
2746 &mut self.previous_config,
2747 decoder,
2748 offset + 0,
2749 _depth
2750 )?;
2751 Ok(())
2752 }
2753 }
2754
2755 impl fidl::encoding::ValueTypeMarker for Empty {
2756 type Borrowed<'a> = &'a Self;
2757 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2758 value
2759 }
2760 }
2761
2762 unsafe impl fidl::encoding::TypeMarker for Empty {
2763 type Owned = Self;
2764
2765 #[inline(always)]
2766 fn inline_align(_context: fidl::encoding::Context) -> usize {
2767 1
2768 }
2769
2770 #[inline(always)]
2771 fn inline_size(_context: fidl::encoding::Context) -> usize {
2772 1
2773 }
2774 }
2775
2776 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
2777 #[inline]
2778 unsafe fn encode(
2779 self,
2780 encoder: &mut fidl::encoding::Encoder<'_, D>,
2781 offset: usize,
2782 _depth: fidl::encoding::Depth,
2783 ) -> fidl::Result<()> {
2784 encoder.debug_check_bounds::<Empty>(offset);
2785 encoder.write_num(0u8, offset);
2786 Ok(())
2787 }
2788 }
2789
2790 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
2791 #[inline(always)]
2792 fn new_empty() -> Self {
2793 Self
2794 }
2795
2796 #[inline]
2797 unsafe fn decode(
2798 &mut self,
2799 decoder: &mut fidl::encoding::Decoder<'_, D>,
2800 offset: usize,
2801 _depth: fidl::encoding::Depth,
2802 ) -> fidl::Result<()> {
2803 decoder.debug_check_bounds::<Self>(offset);
2804 match decoder.read_num::<u8>(offset) {
2805 0 => Ok(()),
2806 _ => Err(fidl::Error::Invalid),
2807 }
2808 }
2809 }
2810
2811 impl AddressParameters {
2812 #[inline(always)]
2813 fn max_ordinal_present(&self) -> u64 {
2814 if let Some(_) = self.perform_dad {
2815 return 4;
2816 }
2817 if let Some(_) = self.add_subnet_route {
2818 return 3;
2819 }
2820 if let Some(_) = self.temporary {
2821 return 2;
2822 }
2823 if let Some(_) = self.initial_properties {
2824 return 1;
2825 }
2826 0
2827 }
2828 }
2829
2830 impl fidl::encoding::ValueTypeMarker for AddressParameters {
2831 type Borrowed<'a> = &'a Self;
2832 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2833 value
2834 }
2835 }
2836
2837 unsafe impl fidl::encoding::TypeMarker for AddressParameters {
2838 type Owned = Self;
2839
2840 #[inline(always)]
2841 fn inline_align(_context: fidl::encoding::Context) -> usize {
2842 8
2843 }
2844
2845 #[inline(always)]
2846 fn inline_size(_context: fidl::encoding::Context) -> usize {
2847 16
2848 }
2849 }
2850
2851 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressParameters, D>
2852 for &AddressParameters
2853 {
2854 unsafe fn encode(
2855 self,
2856 encoder: &mut fidl::encoding::Encoder<'_, D>,
2857 offset: usize,
2858 mut depth: fidl::encoding::Depth,
2859 ) -> fidl::Result<()> {
2860 encoder.debug_check_bounds::<AddressParameters>(offset);
2861 let max_ordinal: u64 = self.max_ordinal_present();
2863 encoder.write_num(max_ordinal, offset);
2864 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2865 if max_ordinal == 0 {
2867 return Ok(());
2868 }
2869 depth.increment()?;
2870 let envelope_size = 8;
2871 let bytes_len = max_ordinal as usize * envelope_size;
2872 #[allow(unused_variables)]
2873 let offset = encoder.out_of_line_offset(bytes_len);
2874 let mut _prev_end_offset: usize = 0;
2875 if 1 > max_ordinal {
2876 return Ok(());
2877 }
2878
2879 let cur_offset: usize = (1 - 1) * envelope_size;
2882
2883 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2885
2886 fidl::encoding::encode_in_envelope_optional::<AddressProperties, D>(
2891 self.initial_properties
2892 .as_ref()
2893 .map(<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow),
2894 encoder,
2895 offset + cur_offset,
2896 depth,
2897 )?;
2898
2899 _prev_end_offset = cur_offset + envelope_size;
2900 if 2 > max_ordinal {
2901 return Ok(());
2902 }
2903
2904 let cur_offset: usize = (2 - 1) * envelope_size;
2907
2908 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2910
2911 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2916 self.temporary.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2917 encoder,
2918 offset + cur_offset,
2919 depth,
2920 )?;
2921
2922 _prev_end_offset = cur_offset + envelope_size;
2923 if 3 > max_ordinal {
2924 return Ok(());
2925 }
2926
2927 let cur_offset: usize = (3 - 1) * envelope_size;
2930
2931 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2933
2934 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2939 self.add_subnet_route
2940 .as_ref()
2941 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2942 encoder,
2943 offset + cur_offset,
2944 depth,
2945 )?;
2946
2947 _prev_end_offset = cur_offset + envelope_size;
2948 if 4 > max_ordinal {
2949 return Ok(());
2950 }
2951
2952 let cur_offset: usize = (4 - 1) * envelope_size;
2955
2956 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2958
2959 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2964 self.perform_dad.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2965 encoder,
2966 offset + cur_offset,
2967 depth,
2968 )?;
2969
2970 _prev_end_offset = cur_offset + envelope_size;
2971
2972 Ok(())
2973 }
2974 }
2975
2976 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressParameters {
2977 #[inline(always)]
2978 fn new_empty() -> Self {
2979 Self::default()
2980 }
2981
2982 unsafe fn decode(
2983 &mut self,
2984 decoder: &mut fidl::encoding::Decoder<'_, D>,
2985 offset: usize,
2986 mut depth: fidl::encoding::Depth,
2987 ) -> fidl::Result<()> {
2988 decoder.debug_check_bounds::<Self>(offset);
2989 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2990 None => return Err(fidl::Error::NotNullable),
2991 Some(len) => len,
2992 };
2993 if len == 0 {
2995 return Ok(());
2996 };
2997 depth.increment()?;
2998 let envelope_size = 8;
2999 let bytes_len = len * envelope_size;
3000 let offset = decoder.out_of_line_offset(bytes_len)?;
3001 let mut _next_ordinal_to_read = 0;
3003 let mut next_offset = offset;
3004 let end_offset = offset + bytes_len;
3005 _next_ordinal_to_read += 1;
3006 if next_offset >= end_offset {
3007 return Ok(());
3008 }
3009
3010 while _next_ordinal_to_read < 1 {
3012 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3013 _next_ordinal_to_read += 1;
3014 next_offset += envelope_size;
3015 }
3016
3017 let next_out_of_line = decoder.next_out_of_line();
3018 let handles_before = decoder.remaining_handles();
3019 if let Some((inlined, num_bytes, num_handles)) =
3020 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3021 {
3022 let member_inline_size =
3023 <AddressProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3024 if inlined != (member_inline_size <= 4) {
3025 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3026 }
3027 let inner_offset;
3028 let mut inner_depth = depth.clone();
3029 if inlined {
3030 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3031 inner_offset = next_offset;
3032 } else {
3033 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3034 inner_depth.increment()?;
3035 }
3036 let val_ref = self
3037 .initial_properties
3038 .get_or_insert_with(|| fidl::new_empty!(AddressProperties, D));
3039 fidl::decode!(AddressProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3040 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3041 {
3042 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3043 }
3044 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3045 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3046 }
3047 }
3048
3049 next_offset += envelope_size;
3050 _next_ordinal_to_read += 1;
3051 if next_offset >= end_offset {
3052 return Ok(());
3053 }
3054
3055 while _next_ordinal_to_read < 2 {
3057 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3058 _next_ordinal_to_read += 1;
3059 next_offset += envelope_size;
3060 }
3061
3062 let next_out_of_line = decoder.next_out_of_line();
3063 let handles_before = decoder.remaining_handles();
3064 if let Some((inlined, num_bytes, num_handles)) =
3065 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3066 {
3067 let member_inline_size =
3068 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3069 if inlined != (member_inline_size <= 4) {
3070 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3071 }
3072 let inner_offset;
3073 let mut inner_depth = depth.clone();
3074 if inlined {
3075 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3076 inner_offset = next_offset;
3077 } else {
3078 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3079 inner_depth.increment()?;
3080 }
3081 let val_ref = self.temporary.get_or_insert_with(|| fidl::new_empty!(bool, D));
3082 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3083 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3084 {
3085 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3086 }
3087 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3088 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3089 }
3090 }
3091
3092 next_offset += envelope_size;
3093 _next_ordinal_to_read += 1;
3094 if next_offset >= end_offset {
3095 return Ok(());
3096 }
3097
3098 while _next_ordinal_to_read < 3 {
3100 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3101 _next_ordinal_to_read += 1;
3102 next_offset += envelope_size;
3103 }
3104
3105 let next_out_of_line = decoder.next_out_of_line();
3106 let handles_before = decoder.remaining_handles();
3107 if let Some((inlined, num_bytes, num_handles)) =
3108 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3109 {
3110 let member_inline_size =
3111 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3112 if inlined != (member_inline_size <= 4) {
3113 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3114 }
3115 let inner_offset;
3116 let mut inner_depth = depth.clone();
3117 if inlined {
3118 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3119 inner_offset = next_offset;
3120 } else {
3121 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3122 inner_depth.increment()?;
3123 }
3124 let val_ref =
3125 self.add_subnet_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
3126 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3127 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3128 {
3129 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3130 }
3131 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3132 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3133 }
3134 }
3135
3136 next_offset += envelope_size;
3137 _next_ordinal_to_read += 1;
3138 if next_offset >= end_offset {
3139 return Ok(());
3140 }
3141
3142 while _next_ordinal_to_read < 4 {
3144 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3145 _next_ordinal_to_read += 1;
3146 next_offset += envelope_size;
3147 }
3148
3149 let next_out_of_line = decoder.next_out_of_line();
3150 let handles_before = decoder.remaining_handles();
3151 if let Some((inlined, num_bytes, num_handles)) =
3152 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3153 {
3154 let member_inline_size =
3155 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3156 if inlined != (member_inline_size <= 4) {
3157 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3158 }
3159 let inner_offset;
3160 let mut inner_depth = depth.clone();
3161 if inlined {
3162 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3163 inner_offset = next_offset;
3164 } else {
3165 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3166 inner_depth.increment()?;
3167 }
3168 let val_ref = self.perform_dad.get_or_insert_with(|| fidl::new_empty!(bool, D));
3169 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3170 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3171 {
3172 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3173 }
3174 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3175 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3176 }
3177 }
3178
3179 next_offset += envelope_size;
3180
3181 while next_offset < end_offset {
3183 _next_ordinal_to_read += 1;
3184 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3185 next_offset += envelope_size;
3186 }
3187
3188 Ok(())
3189 }
3190 }
3191
3192 impl AddressProperties {
3193 #[inline(always)]
3194 fn max_ordinal_present(&self) -> u64 {
3195 if let Some(_) = self.valid_lifetime_end {
3196 return 2;
3197 }
3198 if let Some(_) = self.preferred_lifetime_info {
3199 return 1;
3200 }
3201 0
3202 }
3203 }
3204
3205 impl fidl::encoding::ValueTypeMarker for AddressProperties {
3206 type Borrowed<'a> = &'a Self;
3207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3208 value
3209 }
3210 }
3211
3212 unsafe impl fidl::encoding::TypeMarker for AddressProperties {
3213 type Owned = Self;
3214
3215 #[inline(always)]
3216 fn inline_align(_context: fidl::encoding::Context) -> usize {
3217 8
3218 }
3219
3220 #[inline(always)]
3221 fn inline_size(_context: fidl::encoding::Context) -> usize {
3222 16
3223 }
3224 }
3225
3226 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressProperties, D>
3227 for &AddressProperties
3228 {
3229 unsafe fn encode(
3230 self,
3231 encoder: &mut fidl::encoding::Encoder<'_, D>,
3232 offset: usize,
3233 mut depth: fidl::encoding::Depth,
3234 ) -> fidl::Result<()> {
3235 encoder.debug_check_bounds::<AddressProperties>(offset);
3236 let max_ordinal: u64 = self.max_ordinal_present();
3238 encoder.write_num(max_ordinal, offset);
3239 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3240 if max_ordinal == 0 {
3242 return Ok(());
3243 }
3244 depth.increment()?;
3245 let envelope_size = 8;
3246 let bytes_len = max_ordinal as usize * envelope_size;
3247 #[allow(unused_variables)]
3248 let offset = encoder.out_of_line_offset(bytes_len);
3249 let mut _prev_end_offset: usize = 0;
3250 if 1 > max_ordinal {
3251 return Ok(());
3252 }
3253
3254 let cur_offset: usize = (1 - 1) * envelope_size;
3257
3258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3260
3261 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo, D>(
3266 self.preferred_lifetime_info.as_ref().map(<fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3267 encoder, offset + cur_offset, depth
3268 )?;
3269
3270 _prev_end_offset = cur_offset + envelope_size;
3271 if 2 > max_ordinal {
3272 return Ok(());
3273 }
3274
3275 let cur_offset: usize = (2 - 1) * envelope_size;
3278
3279 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3281
3282 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3287 self.valid_lifetime_end
3288 .as_ref()
3289 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3290 encoder,
3291 offset + cur_offset,
3292 depth,
3293 )?;
3294
3295 _prev_end_offset = cur_offset + envelope_size;
3296
3297 Ok(())
3298 }
3299 }
3300
3301 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressProperties {
3302 #[inline(always)]
3303 fn new_empty() -> Self {
3304 Self::default()
3305 }
3306
3307 unsafe fn decode(
3308 &mut self,
3309 decoder: &mut fidl::encoding::Decoder<'_, D>,
3310 offset: usize,
3311 mut depth: fidl::encoding::Depth,
3312 ) -> fidl::Result<()> {
3313 decoder.debug_check_bounds::<Self>(offset);
3314 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3315 None => return Err(fidl::Error::NotNullable),
3316 Some(len) => len,
3317 };
3318 if len == 0 {
3320 return Ok(());
3321 };
3322 depth.increment()?;
3323 let envelope_size = 8;
3324 let bytes_len = len * envelope_size;
3325 let offset = decoder.out_of_line_offset(bytes_len)?;
3326 let mut _next_ordinal_to_read = 0;
3328 let mut next_offset = offset;
3329 let end_offset = offset + bytes_len;
3330 _next_ordinal_to_read += 1;
3331 if next_offset >= end_offset {
3332 return Ok(());
3333 }
3334
3335 while _next_ordinal_to_read < 1 {
3337 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3338 _next_ordinal_to_read += 1;
3339 next_offset += envelope_size;
3340 }
3341
3342 let next_out_of_line = decoder.next_out_of_line();
3343 let handles_before = decoder.remaining_handles();
3344 if let Some((inlined, num_bytes, num_handles)) =
3345 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3346 {
3347 let member_inline_size = <fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3348 if inlined != (member_inline_size <= 4) {
3349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3350 }
3351 let inner_offset;
3352 let mut inner_depth = depth.clone();
3353 if inlined {
3354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3355 inner_offset = next_offset;
3356 } else {
3357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3358 inner_depth.increment()?;
3359 }
3360 let val_ref = self.preferred_lifetime_info.get_or_insert_with(|| {
3361 fidl::new_empty!(fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo, D)
3362 });
3363 fidl::decode!(
3364 fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo,
3365 D,
3366 val_ref,
3367 decoder,
3368 inner_offset,
3369 inner_depth
3370 )?;
3371 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3372 {
3373 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3374 }
3375 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3376 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3377 }
3378 }
3379
3380 next_offset += envelope_size;
3381 _next_ordinal_to_read += 1;
3382 if next_offset >= end_offset {
3383 return Ok(());
3384 }
3385
3386 while _next_ordinal_to_read < 2 {
3388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3389 _next_ordinal_to_read += 1;
3390 next_offset += envelope_size;
3391 }
3392
3393 let next_out_of_line = decoder.next_out_of_line();
3394 let handles_before = decoder.remaining_handles();
3395 if let Some((inlined, num_bytes, num_handles)) =
3396 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3397 {
3398 let member_inline_size =
3399 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3400 if inlined != (member_inline_size <= 4) {
3401 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3402 }
3403 let inner_offset;
3404 let mut inner_depth = depth.clone();
3405 if inlined {
3406 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3407 inner_offset = next_offset;
3408 } else {
3409 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3410 inner_depth.increment()?;
3411 }
3412 let val_ref =
3413 self.valid_lifetime_end.get_or_insert_with(|| fidl::new_empty!(i64, D));
3414 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3415 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3416 {
3417 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3418 }
3419 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3420 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3421 }
3422 }
3423
3424 next_offset += envelope_size;
3425
3426 while next_offset < end_offset {
3428 _next_ordinal_to_read += 1;
3429 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3430 next_offset += envelope_size;
3431 }
3432
3433 Ok(())
3434 }
3435 }
3436
3437 impl ArpConfiguration {
3438 #[inline(always)]
3439 fn max_ordinal_present(&self) -> u64 {
3440 if let Some(_) = self.dad {
3441 return 2;
3442 }
3443 if let Some(_) = self.nud {
3444 return 1;
3445 }
3446 0
3447 }
3448 }
3449
3450 impl fidl::encoding::ValueTypeMarker for ArpConfiguration {
3451 type Borrowed<'a> = &'a Self;
3452 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3453 value
3454 }
3455 }
3456
3457 unsafe impl fidl::encoding::TypeMarker for ArpConfiguration {
3458 type Owned = Self;
3459
3460 #[inline(always)]
3461 fn inline_align(_context: fidl::encoding::Context) -> usize {
3462 8
3463 }
3464
3465 #[inline(always)]
3466 fn inline_size(_context: fidl::encoding::Context) -> usize {
3467 16
3468 }
3469 }
3470
3471 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ArpConfiguration, D>
3472 for &ArpConfiguration
3473 {
3474 unsafe fn encode(
3475 self,
3476 encoder: &mut fidl::encoding::Encoder<'_, D>,
3477 offset: usize,
3478 mut depth: fidl::encoding::Depth,
3479 ) -> fidl::Result<()> {
3480 encoder.debug_check_bounds::<ArpConfiguration>(offset);
3481 let max_ordinal: u64 = self.max_ordinal_present();
3483 encoder.write_num(max_ordinal, offset);
3484 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3485 if max_ordinal == 0 {
3487 return Ok(());
3488 }
3489 depth.increment()?;
3490 let envelope_size = 8;
3491 let bytes_len = max_ordinal as usize * envelope_size;
3492 #[allow(unused_variables)]
3493 let offset = encoder.out_of_line_offset(bytes_len);
3494 let mut _prev_end_offset: usize = 0;
3495 if 1 > max_ordinal {
3496 return Ok(());
3497 }
3498
3499 let cur_offset: usize = (1 - 1) * envelope_size;
3502
3503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3505
3506 fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
3511 self.nud
3512 .as_ref()
3513 .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3514 encoder,
3515 offset + cur_offset,
3516 depth,
3517 )?;
3518
3519 _prev_end_offset = cur_offset + envelope_size;
3520 if 2 > max_ordinal {
3521 return Ok(());
3522 }
3523
3524 let cur_offset: usize = (2 - 1) * envelope_size;
3527
3528 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3530
3531 fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
3536 self.dad
3537 .as_ref()
3538 .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3539 encoder,
3540 offset + cur_offset,
3541 depth,
3542 )?;
3543
3544 _prev_end_offset = cur_offset + envelope_size;
3545
3546 Ok(())
3547 }
3548 }
3549
3550 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ArpConfiguration {
3551 #[inline(always)]
3552 fn new_empty() -> Self {
3553 Self::default()
3554 }
3555
3556 unsafe fn decode(
3557 &mut self,
3558 decoder: &mut fidl::encoding::Decoder<'_, D>,
3559 offset: usize,
3560 mut depth: fidl::encoding::Depth,
3561 ) -> fidl::Result<()> {
3562 decoder.debug_check_bounds::<Self>(offset);
3563 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3564 None => return Err(fidl::Error::NotNullable),
3565 Some(len) => len,
3566 };
3567 if len == 0 {
3569 return Ok(());
3570 };
3571 depth.increment()?;
3572 let envelope_size = 8;
3573 let bytes_len = len * envelope_size;
3574 let offset = decoder.out_of_line_offset(bytes_len)?;
3575 let mut _next_ordinal_to_read = 0;
3577 let mut next_offset = offset;
3578 let end_offset = offset + bytes_len;
3579 _next_ordinal_to_read += 1;
3580 if next_offset >= end_offset {
3581 return Ok(());
3582 }
3583
3584 while _next_ordinal_to_read < 1 {
3586 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3587 _next_ordinal_to_read += 1;
3588 next_offset += envelope_size;
3589 }
3590
3591 let next_out_of_line = decoder.next_out_of_line();
3592 let handles_before = decoder.remaining_handles();
3593 if let Some((inlined, num_bytes, num_handles)) =
3594 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3595 {
3596 let member_inline_size =
3597 <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3598 if inlined != (member_inline_size <= 4) {
3599 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3600 }
3601 let inner_offset;
3602 let mut inner_depth = depth.clone();
3603 if inlined {
3604 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3605 inner_offset = next_offset;
3606 } else {
3607 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3608 inner_depth.increment()?;
3609 }
3610 let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
3611 fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3612 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3613 {
3614 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3615 }
3616 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3617 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3618 }
3619 }
3620
3621 next_offset += envelope_size;
3622 _next_ordinal_to_read += 1;
3623 if next_offset >= end_offset {
3624 return Ok(());
3625 }
3626
3627 while _next_ordinal_to_read < 2 {
3629 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3630 _next_ordinal_to_read += 1;
3631 next_offset += envelope_size;
3632 }
3633
3634 let next_out_of_line = decoder.next_out_of_line();
3635 let handles_before = decoder.remaining_handles();
3636 if let Some((inlined, num_bytes, num_handles)) =
3637 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3638 {
3639 let member_inline_size =
3640 <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3641 if inlined != (member_inline_size <= 4) {
3642 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3643 }
3644 let inner_offset;
3645 let mut inner_depth = depth.clone();
3646 if inlined {
3647 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3648 inner_offset = next_offset;
3649 } else {
3650 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3651 inner_depth.increment()?;
3652 }
3653 let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
3654 fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3655 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3656 {
3657 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3658 }
3659 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3660 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3661 }
3662 }
3663
3664 next_offset += envelope_size;
3665
3666 while next_offset < end_offset {
3668 _next_ordinal_to_read += 1;
3669 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3670 next_offset += envelope_size;
3671 }
3672
3673 Ok(())
3674 }
3675 }
3676
3677 impl Configuration {
3678 #[inline(always)]
3679 fn max_ordinal_present(&self) -> u64 {
3680 if let Some(_) = self.ipv6 {
3681 return 2;
3682 }
3683 if let Some(_) = self.ipv4 {
3684 return 1;
3685 }
3686 0
3687 }
3688 }
3689
3690 impl fidl::encoding::ValueTypeMarker for Configuration {
3691 type Borrowed<'a> = &'a Self;
3692 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3693 value
3694 }
3695 }
3696
3697 unsafe impl fidl::encoding::TypeMarker for Configuration {
3698 type Owned = Self;
3699
3700 #[inline(always)]
3701 fn inline_align(_context: fidl::encoding::Context) -> usize {
3702 8
3703 }
3704
3705 #[inline(always)]
3706 fn inline_size(_context: fidl::encoding::Context) -> usize {
3707 16
3708 }
3709 }
3710
3711 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
3712 for &Configuration
3713 {
3714 unsafe fn encode(
3715 self,
3716 encoder: &mut fidl::encoding::Encoder<'_, D>,
3717 offset: usize,
3718 mut depth: fidl::encoding::Depth,
3719 ) -> fidl::Result<()> {
3720 encoder.debug_check_bounds::<Configuration>(offset);
3721 let max_ordinal: u64 = self.max_ordinal_present();
3723 encoder.write_num(max_ordinal, offset);
3724 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3725 if max_ordinal == 0 {
3727 return Ok(());
3728 }
3729 depth.increment()?;
3730 let envelope_size = 8;
3731 let bytes_len = max_ordinal as usize * envelope_size;
3732 #[allow(unused_variables)]
3733 let offset = encoder.out_of_line_offset(bytes_len);
3734 let mut _prev_end_offset: usize = 0;
3735 if 1 > max_ordinal {
3736 return Ok(());
3737 }
3738
3739 let cur_offset: usize = (1 - 1) * envelope_size;
3742
3743 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3745
3746 fidl::encoding::encode_in_envelope_optional::<Ipv4Configuration, D>(
3751 self.ipv4
3752 .as_ref()
3753 .map(<Ipv4Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3754 encoder,
3755 offset + cur_offset,
3756 depth,
3757 )?;
3758
3759 _prev_end_offset = cur_offset + envelope_size;
3760 if 2 > max_ordinal {
3761 return Ok(());
3762 }
3763
3764 let cur_offset: usize = (2 - 1) * envelope_size;
3767
3768 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3770
3771 fidl::encoding::encode_in_envelope_optional::<Ipv6Configuration, D>(
3776 self.ipv6
3777 .as_ref()
3778 .map(<Ipv6Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3779 encoder,
3780 offset + cur_offset,
3781 depth,
3782 )?;
3783
3784 _prev_end_offset = cur_offset + envelope_size;
3785
3786 Ok(())
3787 }
3788 }
3789
3790 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
3791 #[inline(always)]
3792 fn new_empty() -> Self {
3793 Self::default()
3794 }
3795
3796 unsafe fn decode(
3797 &mut self,
3798 decoder: &mut fidl::encoding::Decoder<'_, D>,
3799 offset: usize,
3800 mut depth: fidl::encoding::Depth,
3801 ) -> fidl::Result<()> {
3802 decoder.debug_check_bounds::<Self>(offset);
3803 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3804 None => return Err(fidl::Error::NotNullable),
3805 Some(len) => len,
3806 };
3807 if len == 0 {
3809 return Ok(());
3810 };
3811 depth.increment()?;
3812 let envelope_size = 8;
3813 let bytes_len = len * envelope_size;
3814 let offset = decoder.out_of_line_offset(bytes_len)?;
3815 let mut _next_ordinal_to_read = 0;
3817 let mut next_offset = offset;
3818 let end_offset = offset + bytes_len;
3819 _next_ordinal_to_read += 1;
3820 if next_offset >= end_offset {
3821 return Ok(());
3822 }
3823
3824 while _next_ordinal_to_read < 1 {
3826 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3827 _next_ordinal_to_read += 1;
3828 next_offset += envelope_size;
3829 }
3830
3831 let next_out_of_line = decoder.next_out_of_line();
3832 let handles_before = decoder.remaining_handles();
3833 if let Some((inlined, num_bytes, num_handles)) =
3834 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3835 {
3836 let member_inline_size =
3837 <Ipv4Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3838 if inlined != (member_inline_size <= 4) {
3839 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3840 }
3841 let inner_offset;
3842 let mut inner_depth = depth.clone();
3843 if inlined {
3844 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3845 inner_offset = next_offset;
3846 } else {
3847 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3848 inner_depth.increment()?;
3849 }
3850 let val_ref =
3851 self.ipv4.get_or_insert_with(|| fidl::new_empty!(Ipv4Configuration, D));
3852 fidl::decode!(Ipv4Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3853 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3854 {
3855 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3856 }
3857 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3858 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3859 }
3860 }
3861
3862 next_offset += envelope_size;
3863 _next_ordinal_to_read += 1;
3864 if next_offset >= end_offset {
3865 return Ok(());
3866 }
3867
3868 while _next_ordinal_to_read < 2 {
3870 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871 _next_ordinal_to_read += 1;
3872 next_offset += envelope_size;
3873 }
3874
3875 let next_out_of_line = decoder.next_out_of_line();
3876 let handles_before = decoder.remaining_handles();
3877 if let Some((inlined, num_bytes, num_handles)) =
3878 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879 {
3880 let member_inline_size =
3881 <Ipv6Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3882 if inlined != (member_inline_size <= 4) {
3883 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3884 }
3885 let inner_offset;
3886 let mut inner_depth = depth.clone();
3887 if inlined {
3888 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3889 inner_offset = next_offset;
3890 } else {
3891 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3892 inner_depth.increment()?;
3893 }
3894 let val_ref =
3895 self.ipv6.get_or_insert_with(|| fidl::new_empty!(Ipv6Configuration, D));
3896 fidl::decode!(Ipv6Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3897 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3898 {
3899 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3900 }
3901 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3902 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3903 }
3904 }
3905
3906 next_offset += envelope_size;
3907
3908 while next_offset < end_offset {
3910 _next_ordinal_to_read += 1;
3911 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3912 next_offset += envelope_size;
3913 }
3914
3915 Ok(())
3916 }
3917 }
3918
3919 impl DadConfiguration {
3920 #[inline(always)]
3921 fn max_ordinal_present(&self) -> u64 {
3922 if let Some(_) = self.transmits {
3923 return 1;
3924 }
3925 0
3926 }
3927 }
3928
3929 impl fidl::encoding::ValueTypeMarker for DadConfiguration {
3930 type Borrowed<'a> = &'a Self;
3931 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3932 value
3933 }
3934 }
3935
3936 unsafe impl fidl::encoding::TypeMarker for DadConfiguration {
3937 type Owned = Self;
3938
3939 #[inline(always)]
3940 fn inline_align(_context: fidl::encoding::Context) -> usize {
3941 8
3942 }
3943
3944 #[inline(always)]
3945 fn inline_size(_context: fidl::encoding::Context) -> usize {
3946 16
3947 }
3948 }
3949
3950 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DadConfiguration, D>
3951 for &DadConfiguration
3952 {
3953 unsafe fn encode(
3954 self,
3955 encoder: &mut fidl::encoding::Encoder<'_, D>,
3956 offset: usize,
3957 mut depth: fidl::encoding::Depth,
3958 ) -> fidl::Result<()> {
3959 encoder.debug_check_bounds::<DadConfiguration>(offset);
3960 let max_ordinal: u64 = self.max_ordinal_present();
3962 encoder.write_num(max_ordinal, offset);
3963 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3964 if max_ordinal == 0 {
3966 return Ok(());
3967 }
3968 depth.increment()?;
3969 let envelope_size = 8;
3970 let bytes_len = max_ordinal as usize * envelope_size;
3971 #[allow(unused_variables)]
3972 let offset = encoder.out_of_line_offset(bytes_len);
3973 let mut _prev_end_offset: usize = 0;
3974 if 1 > max_ordinal {
3975 return Ok(());
3976 }
3977
3978 let cur_offset: usize = (1 - 1) * envelope_size;
3981
3982 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3984
3985 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3990 self.transmits.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3991 encoder,
3992 offset + cur_offset,
3993 depth,
3994 )?;
3995
3996 _prev_end_offset = cur_offset + envelope_size;
3997
3998 Ok(())
3999 }
4000 }
4001
4002 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DadConfiguration {
4003 #[inline(always)]
4004 fn new_empty() -> Self {
4005 Self::default()
4006 }
4007
4008 unsafe fn decode(
4009 &mut self,
4010 decoder: &mut fidl::encoding::Decoder<'_, D>,
4011 offset: usize,
4012 mut depth: fidl::encoding::Depth,
4013 ) -> fidl::Result<()> {
4014 decoder.debug_check_bounds::<Self>(offset);
4015 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4016 None => return Err(fidl::Error::NotNullable),
4017 Some(len) => len,
4018 };
4019 if len == 0 {
4021 return Ok(());
4022 };
4023 depth.increment()?;
4024 let envelope_size = 8;
4025 let bytes_len = len * envelope_size;
4026 let offset = decoder.out_of_line_offset(bytes_len)?;
4027 let mut _next_ordinal_to_read = 0;
4029 let mut next_offset = offset;
4030 let end_offset = offset + bytes_len;
4031 _next_ordinal_to_read += 1;
4032 if next_offset >= end_offset {
4033 return Ok(());
4034 }
4035
4036 while _next_ordinal_to_read < 1 {
4038 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4039 _next_ordinal_to_read += 1;
4040 next_offset += envelope_size;
4041 }
4042
4043 let next_out_of_line = decoder.next_out_of_line();
4044 let handles_before = decoder.remaining_handles();
4045 if let Some((inlined, num_bytes, num_handles)) =
4046 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4047 {
4048 let member_inline_size =
4049 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4050 if inlined != (member_inline_size <= 4) {
4051 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4052 }
4053 let inner_offset;
4054 let mut inner_depth = depth.clone();
4055 if inlined {
4056 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4057 inner_offset = next_offset;
4058 } else {
4059 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4060 inner_depth.increment()?;
4061 }
4062 let val_ref = self.transmits.get_or_insert_with(|| fidl::new_empty!(u16, D));
4063 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4064 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4065 {
4066 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4067 }
4068 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4069 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4070 }
4071 }
4072
4073 next_offset += envelope_size;
4074
4075 while next_offset < end_offset {
4077 _next_ordinal_to_read += 1;
4078 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4079 next_offset += envelope_size;
4080 }
4081
4082 Ok(())
4083 }
4084 }
4085
4086 impl IgmpConfiguration {
4087 #[inline(always)]
4088 fn max_ordinal_present(&self) -> u64 {
4089 if let Some(_) = self.version {
4090 return 1;
4091 }
4092 0
4093 }
4094 }
4095
4096 impl fidl::encoding::ValueTypeMarker for IgmpConfiguration {
4097 type Borrowed<'a> = &'a Self;
4098 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4099 value
4100 }
4101 }
4102
4103 unsafe impl fidl::encoding::TypeMarker for IgmpConfiguration {
4104 type Owned = Self;
4105
4106 #[inline(always)]
4107 fn inline_align(_context: fidl::encoding::Context) -> usize {
4108 8
4109 }
4110
4111 #[inline(always)]
4112 fn inline_size(_context: fidl::encoding::Context) -> usize {
4113 16
4114 }
4115 }
4116
4117 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IgmpConfiguration, D>
4118 for &IgmpConfiguration
4119 {
4120 unsafe fn encode(
4121 self,
4122 encoder: &mut fidl::encoding::Encoder<'_, D>,
4123 offset: usize,
4124 mut depth: fidl::encoding::Depth,
4125 ) -> fidl::Result<()> {
4126 encoder.debug_check_bounds::<IgmpConfiguration>(offset);
4127 let max_ordinal: u64 = self.max_ordinal_present();
4129 encoder.write_num(max_ordinal, offset);
4130 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4131 if max_ordinal == 0 {
4133 return Ok(());
4134 }
4135 depth.increment()?;
4136 let envelope_size = 8;
4137 let bytes_len = max_ordinal as usize * envelope_size;
4138 #[allow(unused_variables)]
4139 let offset = encoder.out_of_line_offset(bytes_len);
4140 let mut _prev_end_offset: usize = 0;
4141 if 1 > max_ordinal {
4142 return Ok(());
4143 }
4144
4145 let cur_offset: usize = (1 - 1) * envelope_size;
4148
4149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4151
4152 fidl::encoding::encode_in_envelope_optional::<IgmpVersion, D>(
4157 self.version.as_ref().map(<IgmpVersion as fidl::encoding::ValueTypeMarker>::borrow),
4158 encoder,
4159 offset + cur_offset,
4160 depth,
4161 )?;
4162
4163 _prev_end_offset = cur_offset + envelope_size;
4164
4165 Ok(())
4166 }
4167 }
4168
4169 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpConfiguration {
4170 #[inline(always)]
4171 fn new_empty() -> Self {
4172 Self::default()
4173 }
4174
4175 unsafe fn decode(
4176 &mut self,
4177 decoder: &mut fidl::encoding::Decoder<'_, D>,
4178 offset: usize,
4179 mut depth: fidl::encoding::Depth,
4180 ) -> fidl::Result<()> {
4181 decoder.debug_check_bounds::<Self>(offset);
4182 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4183 None => return Err(fidl::Error::NotNullable),
4184 Some(len) => len,
4185 };
4186 if len == 0 {
4188 return Ok(());
4189 };
4190 depth.increment()?;
4191 let envelope_size = 8;
4192 let bytes_len = len * envelope_size;
4193 let offset = decoder.out_of_line_offset(bytes_len)?;
4194 let mut _next_ordinal_to_read = 0;
4196 let mut next_offset = offset;
4197 let end_offset = offset + bytes_len;
4198 _next_ordinal_to_read += 1;
4199 if next_offset >= end_offset {
4200 return Ok(());
4201 }
4202
4203 while _next_ordinal_to_read < 1 {
4205 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4206 _next_ordinal_to_read += 1;
4207 next_offset += envelope_size;
4208 }
4209
4210 let next_out_of_line = decoder.next_out_of_line();
4211 let handles_before = decoder.remaining_handles();
4212 if let Some((inlined, num_bytes, num_handles)) =
4213 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4214 {
4215 let member_inline_size =
4216 <IgmpVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4217 if inlined != (member_inline_size <= 4) {
4218 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4219 }
4220 let inner_offset;
4221 let mut inner_depth = depth.clone();
4222 if inlined {
4223 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4224 inner_offset = next_offset;
4225 } else {
4226 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4227 inner_depth.increment()?;
4228 }
4229 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(IgmpVersion, D));
4230 fidl::decode!(IgmpVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
4231 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4232 {
4233 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4234 }
4235 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4236 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4237 }
4238 }
4239
4240 next_offset += envelope_size;
4241
4242 while next_offset < end_offset {
4244 _next_ordinal_to_read += 1;
4245 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4246 next_offset += envelope_size;
4247 }
4248
4249 Ok(())
4250 }
4251 }
4252
4253 impl Ipv4Configuration {
4254 #[inline(always)]
4255 fn max_ordinal_present(&self) -> u64 {
4256 if let Some(_) = self.arp {
4257 return 4;
4258 }
4259 if let Some(_) = self.igmp {
4260 return 3;
4261 }
4262 if let Some(_) = self.multicast_forwarding {
4263 return 2;
4264 }
4265 if let Some(_) = self.unicast_forwarding {
4266 return 1;
4267 }
4268 0
4269 }
4270 }
4271
4272 impl fidl::encoding::ValueTypeMarker for Ipv4Configuration {
4273 type Borrowed<'a> = &'a Self;
4274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4275 value
4276 }
4277 }
4278
4279 unsafe impl fidl::encoding::TypeMarker for Ipv4Configuration {
4280 type Owned = Self;
4281
4282 #[inline(always)]
4283 fn inline_align(_context: fidl::encoding::Context) -> usize {
4284 8
4285 }
4286
4287 #[inline(always)]
4288 fn inline_size(_context: fidl::encoding::Context) -> usize {
4289 16
4290 }
4291 }
4292
4293 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv4Configuration, D>
4294 for &Ipv4Configuration
4295 {
4296 unsafe fn encode(
4297 self,
4298 encoder: &mut fidl::encoding::Encoder<'_, D>,
4299 offset: usize,
4300 mut depth: fidl::encoding::Depth,
4301 ) -> fidl::Result<()> {
4302 encoder.debug_check_bounds::<Ipv4Configuration>(offset);
4303 let max_ordinal: u64 = self.max_ordinal_present();
4305 encoder.write_num(max_ordinal, offset);
4306 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4307 if max_ordinal == 0 {
4309 return Ok(());
4310 }
4311 depth.increment()?;
4312 let envelope_size = 8;
4313 let bytes_len = max_ordinal as usize * envelope_size;
4314 #[allow(unused_variables)]
4315 let offset = encoder.out_of_line_offset(bytes_len);
4316 let mut _prev_end_offset: usize = 0;
4317 if 1 > max_ordinal {
4318 return Ok(());
4319 }
4320
4321 let cur_offset: usize = (1 - 1) * envelope_size;
4324
4325 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4327
4328 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4333 self.unicast_forwarding
4334 .as_ref()
4335 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4336 encoder,
4337 offset + cur_offset,
4338 depth,
4339 )?;
4340
4341 _prev_end_offset = cur_offset + envelope_size;
4342 if 2 > max_ordinal {
4343 return Ok(());
4344 }
4345
4346 let cur_offset: usize = (2 - 1) * envelope_size;
4349
4350 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4352
4353 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4358 self.multicast_forwarding
4359 .as_ref()
4360 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4361 encoder,
4362 offset + cur_offset,
4363 depth,
4364 )?;
4365
4366 _prev_end_offset = cur_offset + envelope_size;
4367 if 3 > max_ordinal {
4368 return Ok(());
4369 }
4370
4371 let cur_offset: usize = (3 - 1) * envelope_size;
4374
4375 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4377
4378 fidl::encoding::encode_in_envelope_optional::<IgmpConfiguration, D>(
4383 self.igmp
4384 .as_ref()
4385 .map(<IgmpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4386 encoder,
4387 offset + cur_offset,
4388 depth,
4389 )?;
4390
4391 _prev_end_offset = cur_offset + envelope_size;
4392 if 4 > max_ordinal {
4393 return Ok(());
4394 }
4395
4396 let cur_offset: usize = (4 - 1) * envelope_size;
4399
4400 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4402
4403 fidl::encoding::encode_in_envelope_optional::<ArpConfiguration, D>(
4408 self.arp
4409 .as_ref()
4410 .map(<ArpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4411 encoder,
4412 offset + cur_offset,
4413 depth,
4414 )?;
4415
4416 _prev_end_offset = cur_offset + envelope_size;
4417
4418 Ok(())
4419 }
4420 }
4421
4422 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv4Configuration {
4423 #[inline(always)]
4424 fn new_empty() -> Self {
4425 Self::default()
4426 }
4427
4428 unsafe fn decode(
4429 &mut self,
4430 decoder: &mut fidl::encoding::Decoder<'_, D>,
4431 offset: usize,
4432 mut depth: fidl::encoding::Depth,
4433 ) -> fidl::Result<()> {
4434 decoder.debug_check_bounds::<Self>(offset);
4435 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4436 None => return Err(fidl::Error::NotNullable),
4437 Some(len) => len,
4438 };
4439 if len == 0 {
4441 return Ok(());
4442 };
4443 depth.increment()?;
4444 let envelope_size = 8;
4445 let bytes_len = len * envelope_size;
4446 let offset = decoder.out_of_line_offset(bytes_len)?;
4447 let mut _next_ordinal_to_read = 0;
4449 let mut next_offset = offset;
4450 let end_offset = offset + bytes_len;
4451 _next_ordinal_to_read += 1;
4452 if next_offset >= end_offset {
4453 return Ok(());
4454 }
4455
4456 while _next_ordinal_to_read < 1 {
4458 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4459 _next_ordinal_to_read += 1;
4460 next_offset += envelope_size;
4461 }
4462
4463 let next_out_of_line = decoder.next_out_of_line();
4464 let handles_before = decoder.remaining_handles();
4465 if let Some((inlined, num_bytes, num_handles)) =
4466 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4467 {
4468 let member_inline_size =
4469 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4470 if inlined != (member_inline_size <= 4) {
4471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4472 }
4473 let inner_offset;
4474 let mut inner_depth = depth.clone();
4475 if inlined {
4476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4477 inner_offset = next_offset;
4478 } else {
4479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4480 inner_depth.increment()?;
4481 }
4482 let val_ref =
4483 self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4484 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4486 {
4487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4488 }
4489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4491 }
4492 }
4493
4494 next_offset += envelope_size;
4495 _next_ordinal_to_read += 1;
4496 if next_offset >= end_offset {
4497 return Ok(());
4498 }
4499
4500 while _next_ordinal_to_read < 2 {
4502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4503 _next_ordinal_to_read += 1;
4504 next_offset += envelope_size;
4505 }
4506
4507 let next_out_of_line = decoder.next_out_of_line();
4508 let handles_before = decoder.remaining_handles();
4509 if let Some((inlined, num_bytes, num_handles)) =
4510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4511 {
4512 let member_inline_size =
4513 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4514 if inlined != (member_inline_size <= 4) {
4515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4516 }
4517 let inner_offset;
4518 let mut inner_depth = depth.clone();
4519 if inlined {
4520 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4521 inner_offset = next_offset;
4522 } else {
4523 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4524 inner_depth.increment()?;
4525 }
4526 let val_ref =
4527 self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4528 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4529 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4530 {
4531 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4532 }
4533 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4534 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4535 }
4536 }
4537
4538 next_offset += envelope_size;
4539 _next_ordinal_to_read += 1;
4540 if next_offset >= end_offset {
4541 return Ok(());
4542 }
4543
4544 while _next_ordinal_to_read < 3 {
4546 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4547 _next_ordinal_to_read += 1;
4548 next_offset += envelope_size;
4549 }
4550
4551 let next_out_of_line = decoder.next_out_of_line();
4552 let handles_before = decoder.remaining_handles();
4553 if let Some((inlined, num_bytes, num_handles)) =
4554 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4555 {
4556 let member_inline_size =
4557 <IgmpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4558 if inlined != (member_inline_size <= 4) {
4559 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4560 }
4561 let inner_offset;
4562 let mut inner_depth = depth.clone();
4563 if inlined {
4564 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4565 inner_offset = next_offset;
4566 } else {
4567 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4568 inner_depth.increment()?;
4569 }
4570 let val_ref =
4571 self.igmp.get_or_insert_with(|| fidl::new_empty!(IgmpConfiguration, D));
4572 fidl::decode!(IgmpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4573 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4574 {
4575 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4576 }
4577 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4578 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4579 }
4580 }
4581
4582 next_offset += envelope_size;
4583 _next_ordinal_to_read += 1;
4584 if next_offset >= end_offset {
4585 return Ok(());
4586 }
4587
4588 while _next_ordinal_to_read < 4 {
4590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4591 _next_ordinal_to_read += 1;
4592 next_offset += envelope_size;
4593 }
4594
4595 let next_out_of_line = decoder.next_out_of_line();
4596 let handles_before = decoder.remaining_handles();
4597 if let Some((inlined, num_bytes, num_handles)) =
4598 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4599 {
4600 let member_inline_size =
4601 <ArpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4602 if inlined != (member_inline_size <= 4) {
4603 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4604 }
4605 let inner_offset;
4606 let mut inner_depth = depth.clone();
4607 if inlined {
4608 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4609 inner_offset = next_offset;
4610 } else {
4611 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4612 inner_depth.increment()?;
4613 }
4614 let val_ref = self.arp.get_or_insert_with(|| fidl::new_empty!(ArpConfiguration, D));
4615 fidl::decode!(ArpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4617 {
4618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4619 }
4620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4622 }
4623 }
4624
4625 next_offset += envelope_size;
4626
4627 while next_offset < end_offset {
4629 _next_ordinal_to_read += 1;
4630 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4631 next_offset += envelope_size;
4632 }
4633
4634 Ok(())
4635 }
4636 }
4637
4638 impl Ipv6Configuration {
4639 #[inline(always)]
4640 fn max_ordinal_present(&self) -> u64 {
4641 if let Some(_) = self.ndp {
4642 return 4;
4643 }
4644 if let Some(_) = self.mld {
4645 return 3;
4646 }
4647 if let Some(_) = self.multicast_forwarding {
4648 return 2;
4649 }
4650 if let Some(_) = self.unicast_forwarding {
4651 return 1;
4652 }
4653 0
4654 }
4655 }
4656
4657 impl fidl::encoding::ValueTypeMarker for Ipv6Configuration {
4658 type Borrowed<'a> = &'a Self;
4659 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4660 value
4661 }
4662 }
4663
4664 unsafe impl fidl::encoding::TypeMarker for Ipv6Configuration {
4665 type Owned = Self;
4666
4667 #[inline(always)]
4668 fn inline_align(_context: fidl::encoding::Context) -> usize {
4669 8
4670 }
4671
4672 #[inline(always)]
4673 fn inline_size(_context: fidl::encoding::Context) -> usize {
4674 16
4675 }
4676 }
4677
4678 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv6Configuration, D>
4679 for &Ipv6Configuration
4680 {
4681 unsafe fn encode(
4682 self,
4683 encoder: &mut fidl::encoding::Encoder<'_, D>,
4684 offset: usize,
4685 mut depth: fidl::encoding::Depth,
4686 ) -> fidl::Result<()> {
4687 encoder.debug_check_bounds::<Ipv6Configuration>(offset);
4688 let max_ordinal: u64 = self.max_ordinal_present();
4690 encoder.write_num(max_ordinal, offset);
4691 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4692 if max_ordinal == 0 {
4694 return Ok(());
4695 }
4696 depth.increment()?;
4697 let envelope_size = 8;
4698 let bytes_len = max_ordinal as usize * envelope_size;
4699 #[allow(unused_variables)]
4700 let offset = encoder.out_of_line_offset(bytes_len);
4701 let mut _prev_end_offset: usize = 0;
4702 if 1 > max_ordinal {
4703 return Ok(());
4704 }
4705
4706 let cur_offset: usize = (1 - 1) * envelope_size;
4709
4710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4712
4713 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4718 self.unicast_forwarding
4719 .as_ref()
4720 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4721 encoder,
4722 offset + cur_offset,
4723 depth,
4724 )?;
4725
4726 _prev_end_offset = cur_offset + envelope_size;
4727 if 2 > max_ordinal {
4728 return Ok(());
4729 }
4730
4731 let cur_offset: usize = (2 - 1) * envelope_size;
4734
4735 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4737
4738 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4743 self.multicast_forwarding
4744 .as_ref()
4745 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4746 encoder,
4747 offset + cur_offset,
4748 depth,
4749 )?;
4750
4751 _prev_end_offset = cur_offset + envelope_size;
4752 if 3 > max_ordinal {
4753 return Ok(());
4754 }
4755
4756 let cur_offset: usize = (3 - 1) * envelope_size;
4759
4760 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4762
4763 fidl::encoding::encode_in_envelope_optional::<MldConfiguration, D>(
4768 self.mld
4769 .as_ref()
4770 .map(<MldConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4771 encoder,
4772 offset + cur_offset,
4773 depth,
4774 )?;
4775
4776 _prev_end_offset = cur_offset + envelope_size;
4777 if 4 > max_ordinal {
4778 return Ok(());
4779 }
4780
4781 let cur_offset: usize = (4 - 1) * envelope_size;
4784
4785 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4787
4788 fidl::encoding::encode_in_envelope_optional::<NdpConfiguration, D>(
4793 self.ndp
4794 .as_ref()
4795 .map(<NdpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4796 encoder,
4797 offset + cur_offset,
4798 depth,
4799 )?;
4800
4801 _prev_end_offset = cur_offset + envelope_size;
4802
4803 Ok(())
4804 }
4805 }
4806
4807 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv6Configuration {
4808 #[inline(always)]
4809 fn new_empty() -> Self {
4810 Self::default()
4811 }
4812
4813 unsafe fn decode(
4814 &mut self,
4815 decoder: &mut fidl::encoding::Decoder<'_, D>,
4816 offset: usize,
4817 mut depth: fidl::encoding::Depth,
4818 ) -> fidl::Result<()> {
4819 decoder.debug_check_bounds::<Self>(offset);
4820 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4821 None => return Err(fidl::Error::NotNullable),
4822 Some(len) => len,
4823 };
4824 if len == 0 {
4826 return Ok(());
4827 };
4828 depth.increment()?;
4829 let envelope_size = 8;
4830 let bytes_len = len * envelope_size;
4831 let offset = decoder.out_of_line_offset(bytes_len)?;
4832 let mut _next_ordinal_to_read = 0;
4834 let mut next_offset = offset;
4835 let end_offset = offset + bytes_len;
4836 _next_ordinal_to_read += 1;
4837 if next_offset >= end_offset {
4838 return Ok(());
4839 }
4840
4841 while _next_ordinal_to_read < 1 {
4843 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4844 _next_ordinal_to_read += 1;
4845 next_offset += envelope_size;
4846 }
4847
4848 let next_out_of_line = decoder.next_out_of_line();
4849 let handles_before = decoder.remaining_handles();
4850 if let Some((inlined, num_bytes, num_handles)) =
4851 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4852 {
4853 let member_inline_size =
4854 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4855 if inlined != (member_inline_size <= 4) {
4856 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4857 }
4858 let inner_offset;
4859 let mut inner_depth = depth.clone();
4860 if inlined {
4861 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4862 inner_offset = next_offset;
4863 } else {
4864 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4865 inner_depth.increment()?;
4866 }
4867 let val_ref =
4868 self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4869 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4870 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4871 {
4872 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4873 }
4874 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4875 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4876 }
4877 }
4878
4879 next_offset += envelope_size;
4880 _next_ordinal_to_read += 1;
4881 if next_offset >= end_offset {
4882 return Ok(());
4883 }
4884
4885 while _next_ordinal_to_read < 2 {
4887 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4888 _next_ordinal_to_read += 1;
4889 next_offset += envelope_size;
4890 }
4891
4892 let next_out_of_line = decoder.next_out_of_line();
4893 let handles_before = decoder.remaining_handles();
4894 if let Some((inlined, num_bytes, num_handles)) =
4895 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4896 {
4897 let member_inline_size =
4898 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4899 if inlined != (member_inline_size <= 4) {
4900 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4901 }
4902 let inner_offset;
4903 let mut inner_depth = depth.clone();
4904 if inlined {
4905 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4906 inner_offset = next_offset;
4907 } else {
4908 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4909 inner_depth.increment()?;
4910 }
4911 let val_ref =
4912 self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4913 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4914 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4915 {
4916 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4917 }
4918 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4919 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4920 }
4921 }
4922
4923 next_offset += envelope_size;
4924 _next_ordinal_to_read += 1;
4925 if next_offset >= end_offset {
4926 return Ok(());
4927 }
4928
4929 while _next_ordinal_to_read < 3 {
4931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4932 _next_ordinal_to_read += 1;
4933 next_offset += envelope_size;
4934 }
4935
4936 let next_out_of_line = decoder.next_out_of_line();
4937 let handles_before = decoder.remaining_handles();
4938 if let Some((inlined, num_bytes, num_handles)) =
4939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4940 {
4941 let member_inline_size =
4942 <MldConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4943 if inlined != (member_inline_size <= 4) {
4944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4945 }
4946 let inner_offset;
4947 let mut inner_depth = depth.clone();
4948 if inlined {
4949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4950 inner_offset = next_offset;
4951 } else {
4952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4953 inner_depth.increment()?;
4954 }
4955 let val_ref = self.mld.get_or_insert_with(|| fidl::new_empty!(MldConfiguration, D));
4956 fidl::decode!(MldConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4958 {
4959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4960 }
4961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4963 }
4964 }
4965
4966 next_offset += envelope_size;
4967 _next_ordinal_to_read += 1;
4968 if next_offset >= end_offset {
4969 return Ok(());
4970 }
4971
4972 while _next_ordinal_to_read < 4 {
4974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4975 _next_ordinal_to_read += 1;
4976 next_offset += envelope_size;
4977 }
4978
4979 let next_out_of_line = decoder.next_out_of_line();
4980 let handles_before = decoder.remaining_handles();
4981 if let Some((inlined, num_bytes, num_handles)) =
4982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4983 {
4984 let member_inline_size =
4985 <NdpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4986 if inlined != (member_inline_size <= 4) {
4987 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4988 }
4989 let inner_offset;
4990 let mut inner_depth = depth.clone();
4991 if inlined {
4992 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4993 inner_offset = next_offset;
4994 } else {
4995 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4996 inner_depth.increment()?;
4997 }
4998 let val_ref = self.ndp.get_or_insert_with(|| fidl::new_empty!(NdpConfiguration, D));
4999 fidl::decode!(NdpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5000 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5001 {
5002 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5003 }
5004 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5005 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5006 }
5007 }
5008
5009 next_offset += envelope_size;
5010
5011 while next_offset < end_offset {
5013 _next_ordinal_to_read += 1;
5014 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5015 next_offset += envelope_size;
5016 }
5017
5018 Ok(())
5019 }
5020 }
5021
5022 impl MldConfiguration {
5023 #[inline(always)]
5024 fn max_ordinal_present(&self) -> u64 {
5025 if let Some(_) = self.version {
5026 return 1;
5027 }
5028 0
5029 }
5030 }
5031
5032 impl fidl::encoding::ValueTypeMarker for MldConfiguration {
5033 type Borrowed<'a> = &'a Self;
5034 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5035 value
5036 }
5037 }
5038
5039 unsafe impl fidl::encoding::TypeMarker for MldConfiguration {
5040 type Owned = Self;
5041
5042 #[inline(always)]
5043 fn inline_align(_context: fidl::encoding::Context) -> usize {
5044 8
5045 }
5046
5047 #[inline(always)]
5048 fn inline_size(_context: fidl::encoding::Context) -> usize {
5049 16
5050 }
5051 }
5052
5053 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MldConfiguration, D>
5054 for &MldConfiguration
5055 {
5056 unsafe fn encode(
5057 self,
5058 encoder: &mut fidl::encoding::Encoder<'_, D>,
5059 offset: usize,
5060 mut depth: fidl::encoding::Depth,
5061 ) -> fidl::Result<()> {
5062 encoder.debug_check_bounds::<MldConfiguration>(offset);
5063 let max_ordinal: u64 = self.max_ordinal_present();
5065 encoder.write_num(max_ordinal, offset);
5066 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5067 if max_ordinal == 0 {
5069 return Ok(());
5070 }
5071 depth.increment()?;
5072 let envelope_size = 8;
5073 let bytes_len = max_ordinal as usize * envelope_size;
5074 #[allow(unused_variables)]
5075 let offset = encoder.out_of_line_offset(bytes_len);
5076 let mut _prev_end_offset: usize = 0;
5077 if 1 > max_ordinal {
5078 return Ok(());
5079 }
5080
5081 let cur_offset: usize = (1 - 1) * envelope_size;
5084
5085 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5087
5088 fidl::encoding::encode_in_envelope_optional::<MldVersion, D>(
5093 self.version.as_ref().map(<MldVersion as fidl::encoding::ValueTypeMarker>::borrow),
5094 encoder,
5095 offset + cur_offset,
5096 depth,
5097 )?;
5098
5099 _prev_end_offset = cur_offset + envelope_size;
5100
5101 Ok(())
5102 }
5103 }
5104
5105 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldConfiguration {
5106 #[inline(always)]
5107 fn new_empty() -> Self {
5108 Self::default()
5109 }
5110
5111 unsafe fn decode(
5112 &mut self,
5113 decoder: &mut fidl::encoding::Decoder<'_, D>,
5114 offset: usize,
5115 mut depth: fidl::encoding::Depth,
5116 ) -> fidl::Result<()> {
5117 decoder.debug_check_bounds::<Self>(offset);
5118 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5119 None => return Err(fidl::Error::NotNullable),
5120 Some(len) => len,
5121 };
5122 if len == 0 {
5124 return Ok(());
5125 };
5126 depth.increment()?;
5127 let envelope_size = 8;
5128 let bytes_len = len * envelope_size;
5129 let offset = decoder.out_of_line_offset(bytes_len)?;
5130 let mut _next_ordinal_to_read = 0;
5132 let mut next_offset = offset;
5133 let end_offset = offset + bytes_len;
5134 _next_ordinal_to_read += 1;
5135 if next_offset >= end_offset {
5136 return Ok(());
5137 }
5138
5139 while _next_ordinal_to_read < 1 {
5141 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5142 _next_ordinal_to_read += 1;
5143 next_offset += envelope_size;
5144 }
5145
5146 let next_out_of_line = decoder.next_out_of_line();
5147 let handles_before = decoder.remaining_handles();
5148 if let Some((inlined, num_bytes, num_handles)) =
5149 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5150 {
5151 let member_inline_size =
5152 <MldVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5153 if inlined != (member_inline_size <= 4) {
5154 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5155 }
5156 let inner_offset;
5157 let mut inner_depth = depth.clone();
5158 if inlined {
5159 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5160 inner_offset = next_offset;
5161 } else {
5162 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5163 inner_depth.increment()?;
5164 }
5165 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(MldVersion, D));
5166 fidl::decode!(MldVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
5167 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5168 {
5169 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5170 }
5171 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5172 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5173 }
5174 }
5175
5176 next_offset += envelope_size;
5177
5178 while next_offset < end_offset {
5180 _next_ordinal_to_read += 1;
5181 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5182 next_offset += envelope_size;
5183 }
5184
5185 Ok(())
5186 }
5187 }
5188
5189 impl NdpConfiguration {
5190 #[inline(always)]
5191 fn max_ordinal_present(&self) -> u64 {
5192 if let Some(_) = self.slaac {
5193 return 3;
5194 }
5195 if let Some(_) = self.dad {
5196 return 2;
5197 }
5198 if let Some(_) = self.nud {
5199 return 1;
5200 }
5201 0
5202 }
5203 }
5204
5205 impl fidl::encoding::ValueTypeMarker for NdpConfiguration {
5206 type Borrowed<'a> = &'a Self;
5207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5208 value
5209 }
5210 }
5211
5212 unsafe impl fidl::encoding::TypeMarker for NdpConfiguration {
5213 type Owned = Self;
5214
5215 #[inline(always)]
5216 fn inline_align(_context: fidl::encoding::Context) -> usize {
5217 8
5218 }
5219
5220 #[inline(always)]
5221 fn inline_size(_context: fidl::encoding::Context) -> usize {
5222 16
5223 }
5224 }
5225
5226 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NdpConfiguration, D>
5227 for &NdpConfiguration
5228 {
5229 unsafe fn encode(
5230 self,
5231 encoder: &mut fidl::encoding::Encoder<'_, D>,
5232 offset: usize,
5233 mut depth: fidl::encoding::Depth,
5234 ) -> fidl::Result<()> {
5235 encoder.debug_check_bounds::<NdpConfiguration>(offset);
5236 let max_ordinal: u64 = self.max_ordinal_present();
5238 encoder.write_num(max_ordinal, offset);
5239 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5240 if max_ordinal == 0 {
5242 return Ok(());
5243 }
5244 depth.increment()?;
5245 let envelope_size = 8;
5246 let bytes_len = max_ordinal as usize * envelope_size;
5247 #[allow(unused_variables)]
5248 let offset = encoder.out_of_line_offset(bytes_len);
5249 let mut _prev_end_offset: usize = 0;
5250 if 1 > max_ordinal {
5251 return Ok(());
5252 }
5253
5254 let cur_offset: usize = (1 - 1) * envelope_size;
5257
5258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5260
5261 fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
5266 self.nud
5267 .as_ref()
5268 .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5269 encoder,
5270 offset + cur_offset,
5271 depth,
5272 )?;
5273
5274 _prev_end_offset = cur_offset + envelope_size;
5275 if 2 > max_ordinal {
5276 return Ok(());
5277 }
5278
5279 let cur_offset: usize = (2 - 1) * envelope_size;
5282
5283 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5285
5286 fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
5291 self.dad
5292 .as_ref()
5293 .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5294 encoder,
5295 offset + cur_offset,
5296 depth,
5297 )?;
5298
5299 _prev_end_offset = cur_offset + envelope_size;
5300 if 3 > max_ordinal {
5301 return Ok(());
5302 }
5303
5304 let cur_offset: usize = (3 - 1) * envelope_size;
5307
5308 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5310
5311 fidl::encoding::encode_in_envelope_optional::<SlaacConfiguration, D>(
5316 self.slaac
5317 .as_ref()
5318 .map(<SlaacConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5319 encoder,
5320 offset + cur_offset,
5321 depth,
5322 )?;
5323
5324 _prev_end_offset = cur_offset + envelope_size;
5325
5326 Ok(())
5327 }
5328 }
5329
5330 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NdpConfiguration {
5331 #[inline(always)]
5332 fn new_empty() -> Self {
5333 Self::default()
5334 }
5335
5336 unsafe fn decode(
5337 &mut self,
5338 decoder: &mut fidl::encoding::Decoder<'_, D>,
5339 offset: usize,
5340 mut depth: fidl::encoding::Depth,
5341 ) -> fidl::Result<()> {
5342 decoder.debug_check_bounds::<Self>(offset);
5343 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5344 None => return Err(fidl::Error::NotNullable),
5345 Some(len) => len,
5346 };
5347 if len == 0 {
5349 return Ok(());
5350 };
5351 depth.increment()?;
5352 let envelope_size = 8;
5353 let bytes_len = len * envelope_size;
5354 let offset = decoder.out_of_line_offset(bytes_len)?;
5355 let mut _next_ordinal_to_read = 0;
5357 let mut next_offset = offset;
5358 let end_offset = offset + bytes_len;
5359 _next_ordinal_to_read += 1;
5360 if next_offset >= end_offset {
5361 return Ok(());
5362 }
5363
5364 while _next_ordinal_to_read < 1 {
5366 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5367 _next_ordinal_to_read += 1;
5368 next_offset += envelope_size;
5369 }
5370
5371 let next_out_of_line = decoder.next_out_of_line();
5372 let handles_before = decoder.remaining_handles();
5373 if let Some((inlined, num_bytes, num_handles)) =
5374 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5375 {
5376 let member_inline_size =
5377 <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5378 if inlined != (member_inline_size <= 4) {
5379 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5380 }
5381 let inner_offset;
5382 let mut inner_depth = depth.clone();
5383 if inlined {
5384 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5385 inner_offset = next_offset;
5386 } else {
5387 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5388 inner_depth.increment()?;
5389 }
5390 let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
5391 fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5392 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5393 {
5394 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5395 }
5396 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5397 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5398 }
5399 }
5400
5401 next_offset += envelope_size;
5402 _next_ordinal_to_read += 1;
5403 if next_offset >= end_offset {
5404 return Ok(());
5405 }
5406
5407 while _next_ordinal_to_read < 2 {
5409 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5410 _next_ordinal_to_read += 1;
5411 next_offset += envelope_size;
5412 }
5413
5414 let next_out_of_line = decoder.next_out_of_line();
5415 let handles_before = decoder.remaining_handles();
5416 if let Some((inlined, num_bytes, num_handles)) =
5417 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5418 {
5419 let member_inline_size =
5420 <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5421 if inlined != (member_inline_size <= 4) {
5422 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5423 }
5424 let inner_offset;
5425 let mut inner_depth = depth.clone();
5426 if inlined {
5427 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5428 inner_offset = next_offset;
5429 } else {
5430 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5431 inner_depth.increment()?;
5432 }
5433 let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
5434 fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5435 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5436 {
5437 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5438 }
5439 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5440 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5441 }
5442 }
5443
5444 next_offset += envelope_size;
5445 _next_ordinal_to_read += 1;
5446 if next_offset >= end_offset {
5447 return Ok(());
5448 }
5449
5450 while _next_ordinal_to_read < 3 {
5452 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5453 _next_ordinal_to_read += 1;
5454 next_offset += envelope_size;
5455 }
5456
5457 let next_out_of_line = decoder.next_out_of_line();
5458 let handles_before = decoder.remaining_handles();
5459 if let Some((inlined, num_bytes, num_handles)) =
5460 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5461 {
5462 let member_inline_size =
5463 <SlaacConfiguration as fidl::encoding::TypeMarker>::inline_size(
5464 decoder.context,
5465 );
5466 if inlined != (member_inline_size <= 4) {
5467 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5468 }
5469 let inner_offset;
5470 let mut inner_depth = depth.clone();
5471 if inlined {
5472 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5473 inner_offset = next_offset;
5474 } else {
5475 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5476 inner_depth.increment()?;
5477 }
5478 let val_ref =
5479 self.slaac.get_or_insert_with(|| fidl::new_empty!(SlaacConfiguration, D));
5480 fidl::decode!(SlaacConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5481 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5482 {
5483 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5484 }
5485 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5486 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5487 }
5488 }
5489
5490 next_offset += envelope_size;
5491
5492 while next_offset < end_offset {
5494 _next_ordinal_to_read += 1;
5495 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5496 next_offset += envelope_size;
5497 }
5498
5499 Ok(())
5500 }
5501 }
5502
5503 impl NudConfiguration {
5504 #[inline(always)]
5505 fn max_ordinal_present(&self) -> u64 {
5506 if let Some(_) = self.base_reachable_time {
5507 return 3;
5508 }
5509 if let Some(_) = self.max_unicast_solicitations {
5510 return 2;
5511 }
5512 if let Some(_) = self.max_multicast_solicitations {
5513 return 1;
5514 }
5515 0
5516 }
5517 }
5518
5519 impl fidl::encoding::ValueTypeMarker for NudConfiguration {
5520 type Borrowed<'a> = &'a Self;
5521 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5522 value
5523 }
5524 }
5525
5526 unsafe impl fidl::encoding::TypeMarker for NudConfiguration {
5527 type Owned = Self;
5528
5529 #[inline(always)]
5530 fn inline_align(_context: fidl::encoding::Context) -> usize {
5531 8
5532 }
5533
5534 #[inline(always)]
5535 fn inline_size(_context: fidl::encoding::Context) -> usize {
5536 16
5537 }
5538 }
5539
5540 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NudConfiguration, D>
5541 for &NudConfiguration
5542 {
5543 unsafe fn encode(
5544 self,
5545 encoder: &mut fidl::encoding::Encoder<'_, D>,
5546 offset: usize,
5547 mut depth: fidl::encoding::Depth,
5548 ) -> fidl::Result<()> {
5549 encoder.debug_check_bounds::<NudConfiguration>(offset);
5550 let max_ordinal: u64 = self.max_ordinal_present();
5552 encoder.write_num(max_ordinal, offset);
5553 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5554 if max_ordinal == 0 {
5556 return Ok(());
5557 }
5558 depth.increment()?;
5559 let envelope_size = 8;
5560 let bytes_len = max_ordinal as usize * envelope_size;
5561 #[allow(unused_variables)]
5562 let offset = encoder.out_of_line_offset(bytes_len);
5563 let mut _prev_end_offset: usize = 0;
5564 if 1 > max_ordinal {
5565 return Ok(());
5566 }
5567
5568 let cur_offset: usize = (1 - 1) * envelope_size;
5571
5572 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5574
5575 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5580 self.max_multicast_solicitations
5581 .as_ref()
5582 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5583 encoder,
5584 offset + cur_offset,
5585 depth,
5586 )?;
5587
5588 _prev_end_offset = cur_offset + envelope_size;
5589 if 2 > max_ordinal {
5590 return Ok(());
5591 }
5592
5593 let cur_offset: usize = (2 - 1) * envelope_size;
5596
5597 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5599
5600 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5605 self.max_unicast_solicitations
5606 .as_ref()
5607 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5608 encoder,
5609 offset + cur_offset,
5610 depth,
5611 )?;
5612
5613 _prev_end_offset = cur_offset + envelope_size;
5614 if 3 > max_ordinal {
5615 return Ok(());
5616 }
5617
5618 let cur_offset: usize = (3 - 1) * envelope_size;
5621
5622 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5624
5625 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5630 self.base_reachable_time
5631 .as_ref()
5632 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5633 encoder,
5634 offset + cur_offset,
5635 depth,
5636 )?;
5637
5638 _prev_end_offset = cur_offset + envelope_size;
5639
5640 Ok(())
5641 }
5642 }
5643
5644 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NudConfiguration {
5645 #[inline(always)]
5646 fn new_empty() -> Self {
5647 Self::default()
5648 }
5649
5650 unsafe fn decode(
5651 &mut self,
5652 decoder: &mut fidl::encoding::Decoder<'_, D>,
5653 offset: usize,
5654 mut depth: fidl::encoding::Depth,
5655 ) -> fidl::Result<()> {
5656 decoder.debug_check_bounds::<Self>(offset);
5657 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5658 None => return Err(fidl::Error::NotNullable),
5659 Some(len) => len,
5660 };
5661 if len == 0 {
5663 return Ok(());
5664 };
5665 depth.increment()?;
5666 let envelope_size = 8;
5667 let bytes_len = len * envelope_size;
5668 let offset = decoder.out_of_line_offset(bytes_len)?;
5669 let mut _next_ordinal_to_read = 0;
5671 let mut next_offset = offset;
5672 let end_offset = offset + bytes_len;
5673 _next_ordinal_to_read += 1;
5674 if next_offset >= end_offset {
5675 return Ok(());
5676 }
5677
5678 while _next_ordinal_to_read < 1 {
5680 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5681 _next_ordinal_to_read += 1;
5682 next_offset += envelope_size;
5683 }
5684
5685 let next_out_of_line = decoder.next_out_of_line();
5686 let handles_before = decoder.remaining_handles();
5687 if let Some((inlined, num_bytes, num_handles)) =
5688 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5689 {
5690 let member_inline_size =
5691 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5692 if inlined != (member_inline_size <= 4) {
5693 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5694 }
5695 let inner_offset;
5696 let mut inner_depth = depth.clone();
5697 if inlined {
5698 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5699 inner_offset = next_offset;
5700 } else {
5701 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5702 inner_depth.increment()?;
5703 }
5704 let val_ref = self
5705 .max_multicast_solicitations
5706 .get_or_insert_with(|| fidl::new_empty!(u16, D));
5707 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5708 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5709 {
5710 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5711 }
5712 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5713 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5714 }
5715 }
5716
5717 next_offset += envelope_size;
5718 _next_ordinal_to_read += 1;
5719 if next_offset >= end_offset {
5720 return Ok(());
5721 }
5722
5723 while _next_ordinal_to_read < 2 {
5725 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5726 _next_ordinal_to_read += 1;
5727 next_offset += envelope_size;
5728 }
5729
5730 let next_out_of_line = decoder.next_out_of_line();
5731 let handles_before = decoder.remaining_handles();
5732 if let Some((inlined, num_bytes, num_handles)) =
5733 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5734 {
5735 let member_inline_size =
5736 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5737 if inlined != (member_inline_size <= 4) {
5738 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5739 }
5740 let inner_offset;
5741 let mut inner_depth = depth.clone();
5742 if inlined {
5743 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5744 inner_offset = next_offset;
5745 } else {
5746 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5747 inner_depth.increment()?;
5748 }
5749 let val_ref =
5750 self.max_unicast_solicitations.get_or_insert_with(|| fidl::new_empty!(u16, D));
5751 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5752 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5753 {
5754 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5755 }
5756 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5757 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5758 }
5759 }
5760
5761 next_offset += envelope_size;
5762 _next_ordinal_to_read += 1;
5763 if next_offset >= end_offset {
5764 return Ok(());
5765 }
5766
5767 while _next_ordinal_to_read < 3 {
5769 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5770 _next_ordinal_to_read += 1;
5771 next_offset += envelope_size;
5772 }
5773
5774 let next_out_of_line = decoder.next_out_of_line();
5775 let handles_before = decoder.remaining_handles();
5776 if let Some((inlined, num_bytes, num_handles)) =
5777 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5778 {
5779 let member_inline_size =
5780 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5781 if inlined != (member_inline_size <= 4) {
5782 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5783 }
5784 let inner_offset;
5785 let mut inner_depth = depth.clone();
5786 if inlined {
5787 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5788 inner_offset = next_offset;
5789 } else {
5790 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5791 inner_depth.increment()?;
5792 }
5793 let val_ref =
5794 self.base_reachable_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
5795 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
5796 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5797 {
5798 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5799 }
5800 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5801 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5802 }
5803 }
5804
5805 next_offset += envelope_size;
5806
5807 while next_offset < end_offset {
5809 _next_ordinal_to_read += 1;
5810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5811 next_offset += envelope_size;
5812 }
5813
5814 Ok(())
5815 }
5816 }
5817
5818 impl Options {
5819 #[inline(always)]
5820 fn max_ordinal_present(&self) -> u64 {
5821 if let Some(_) = self.metric {
5822 return 2;
5823 }
5824 if let Some(_) = self.name {
5825 return 1;
5826 }
5827 0
5828 }
5829 }
5830
5831 impl fidl::encoding::ValueTypeMarker for Options {
5832 type Borrowed<'a> = &'a Self;
5833 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5834 value
5835 }
5836 }
5837
5838 unsafe impl fidl::encoding::TypeMarker for Options {
5839 type Owned = Self;
5840
5841 #[inline(always)]
5842 fn inline_align(_context: fidl::encoding::Context) -> usize {
5843 8
5844 }
5845
5846 #[inline(always)]
5847 fn inline_size(_context: fidl::encoding::Context) -> usize {
5848 16
5849 }
5850 }
5851
5852 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
5853 unsafe fn encode(
5854 self,
5855 encoder: &mut fidl::encoding::Encoder<'_, D>,
5856 offset: usize,
5857 mut depth: fidl::encoding::Depth,
5858 ) -> fidl::Result<()> {
5859 encoder.debug_check_bounds::<Options>(offset);
5860 let max_ordinal: u64 = self.max_ordinal_present();
5862 encoder.write_num(max_ordinal, offset);
5863 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5864 if max_ordinal == 0 {
5866 return Ok(());
5867 }
5868 depth.increment()?;
5869 let envelope_size = 8;
5870 let bytes_len = max_ordinal as usize * envelope_size;
5871 #[allow(unused_variables)]
5872 let offset = encoder.out_of_line_offset(bytes_len);
5873 let mut _prev_end_offset: usize = 0;
5874 if 1 > max_ordinal {
5875 return Ok(());
5876 }
5877
5878 let cur_offset: usize = (1 - 1) * envelope_size;
5881
5882 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5884
5885 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<15>, D>(
5890 self.name.as_ref().map(
5891 <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow,
5892 ),
5893 encoder,
5894 offset + cur_offset,
5895 depth,
5896 )?;
5897
5898 _prev_end_offset = cur_offset + envelope_size;
5899 if 2 > max_ordinal {
5900 return Ok(());
5901 }
5902
5903 let cur_offset: usize = (2 - 1) * envelope_size;
5906
5907 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5909
5910 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5915 self.metric.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5916 encoder,
5917 offset + cur_offset,
5918 depth,
5919 )?;
5920
5921 _prev_end_offset = cur_offset + envelope_size;
5922
5923 Ok(())
5924 }
5925 }
5926
5927 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
5928 #[inline(always)]
5929 fn new_empty() -> Self {
5930 Self::default()
5931 }
5932
5933 unsafe fn decode(
5934 &mut self,
5935 decoder: &mut fidl::encoding::Decoder<'_, D>,
5936 offset: usize,
5937 mut depth: fidl::encoding::Depth,
5938 ) -> fidl::Result<()> {
5939 decoder.debug_check_bounds::<Self>(offset);
5940 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5941 None => return Err(fidl::Error::NotNullable),
5942 Some(len) => len,
5943 };
5944 if len == 0 {
5946 return Ok(());
5947 };
5948 depth.increment()?;
5949 let envelope_size = 8;
5950 let bytes_len = len * envelope_size;
5951 let offset = decoder.out_of_line_offset(bytes_len)?;
5952 let mut _next_ordinal_to_read = 0;
5954 let mut next_offset = offset;
5955 let end_offset = offset + bytes_len;
5956 _next_ordinal_to_read += 1;
5957 if next_offset >= end_offset {
5958 return Ok(());
5959 }
5960
5961 while _next_ordinal_to_read < 1 {
5963 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5964 _next_ordinal_to_read += 1;
5965 next_offset += envelope_size;
5966 }
5967
5968 let next_out_of_line = decoder.next_out_of_line();
5969 let handles_before = decoder.remaining_handles();
5970 if let Some((inlined, num_bytes, num_handles)) =
5971 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5972 {
5973 let member_inline_size =
5974 <fidl::encoding::BoundedString<15> as fidl::encoding::TypeMarker>::inline_size(
5975 decoder.context,
5976 );
5977 if inlined != (member_inline_size <= 4) {
5978 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5979 }
5980 let inner_offset;
5981 let mut inner_depth = depth.clone();
5982 if inlined {
5983 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5984 inner_offset = next_offset;
5985 } else {
5986 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5987 inner_depth.increment()?;
5988 }
5989 let val_ref = self
5990 .name
5991 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<15>, D));
5992 fidl::decode!(
5993 fidl::encoding::BoundedString<15>,
5994 D,
5995 val_ref,
5996 decoder,
5997 inner_offset,
5998 inner_depth
5999 )?;
6000 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6001 {
6002 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6003 }
6004 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6005 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6006 }
6007 }
6008
6009 next_offset += envelope_size;
6010 _next_ordinal_to_read += 1;
6011 if next_offset >= end_offset {
6012 return Ok(());
6013 }
6014
6015 while _next_ordinal_to_read < 2 {
6017 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6018 _next_ordinal_to_read += 1;
6019 next_offset += envelope_size;
6020 }
6021
6022 let next_out_of_line = decoder.next_out_of_line();
6023 let handles_before = decoder.remaining_handles();
6024 if let Some((inlined, num_bytes, num_handles)) =
6025 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6026 {
6027 let member_inline_size =
6028 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6029 if inlined != (member_inline_size <= 4) {
6030 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6031 }
6032 let inner_offset;
6033 let mut inner_depth = depth.clone();
6034 if inlined {
6035 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6036 inner_offset = next_offset;
6037 } else {
6038 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6039 inner_depth.increment()?;
6040 }
6041 let val_ref = self.metric.get_or_insert_with(|| fidl::new_empty!(u32, D));
6042 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6043 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6044 {
6045 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6046 }
6047 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6048 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6049 }
6050 }
6051
6052 next_offset += envelope_size;
6053
6054 while next_offset < end_offset {
6056 _next_ordinal_to_read += 1;
6057 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6058 next_offset += envelope_size;
6059 }
6060
6061 Ok(())
6062 }
6063 }
6064
6065 impl SlaacConfiguration {
6066 #[inline(always)]
6067 fn max_ordinal_present(&self) -> u64 {
6068 if let Some(_) = self.temporary_address {
6069 return 1;
6070 }
6071 0
6072 }
6073 }
6074
6075 impl fidl::encoding::ValueTypeMarker for SlaacConfiguration {
6076 type Borrowed<'a> = &'a Self;
6077 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6078 value
6079 }
6080 }
6081
6082 unsafe impl fidl::encoding::TypeMarker for SlaacConfiguration {
6083 type Owned = Self;
6084
6085 #[inline(always)]
6086 fn inline_align(_context: fidl::encoding::Context) -> usize {
6087 8
6088 }
6089
6090 #[inline(always)]
6091 fn inline_size(_context: fidl::encoding::Context) -> usize {
6092 16
6093 }
6094 }
6095
6096 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SlaacConfiguration, D>
6097 for &SlaacConfiguration
6098 {
6099 unsafe fn encode(
6100 self,
6101 encoder: &mut fidl::encoding::Encoder<'_, D>,
6102 offset: usize,
6103 mut depth: fidl::encoding::Depth,
6104 ) -> fidl::Result<()> {
6105 encoder.debug_check_bounds::<SlaacConfiguration>(offset);
6106 let max_ordinal: u64 = self.max_ordinal_present();
6108 encoder.write_num(max_ordinal, offset);
6109 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6110 if max_ordinal == 0 {
6112 return Ok(());
6113 }
6114 depth.increment()?;
6115 let envelope_size = 8;
6116 let bytes_len = max_ordinal as usize * envelope_size;
6117 #[allow(unused_variables)]
6118 let offset = encoder.out_of_line_offset(bytes_len);
6119 let mut _prev_end_offset: usize = 0;
6120 if 1 > max_ordinal {
6121 return Ok(());
6122 }
6123
6124 let cur_offset: usize = (1 - 1) * envelope_size;
6127
6128 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6130
6131 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6136 self.temporary_address
6137 .as_ref()
6138 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6139 encoder,
6140 offset + cur_offset,
6141 depth,
6142 )?;
6143
6144 _prev_end_offset = cur_offset + envelope_size;
6145
6146 Ok(())
6147 }
6148 }
6149
6150 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SlaacConfiguration {
6151 #[inline(always)]
6152 fn new_empty() -> Self {
6153 Self::default()
6154 }
6155
6156 unsafe fn decode(
6157 &mut self,
6158 decoder: &mut fidl::encoding::Decoder<'_, D>,
6159 offset: usize,
6160 mut depth: fidl::encoding::Depth,
6161 ) -> fidl::Result<()> {
6162 decoder.debug_check_bounds::<Self>(offset);
6163 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6164 None => return Err(fidl::Error::NotNullable),
6165 Some(len) => len,
6166 };
6167 if len == 0 {
6169 return Ok(());
6170 };
6171 depth.increment()?;
6172 let envelope_size = 8;
6173 let bytes_len = len * envelope_size;
6174 let offset = decoder.out_of_line_offset(bytes_len)?;
6175 let mut _next_ordinal_to_read = 0;
6177 let mut next_offset = offset;
6178 let end_offset = offset + bytes_len;
6179 _next_ordinal_to_read += 1;
6180 if next_offset >= end_offset {
6181 return Ok(());
6182 }
6183
6184 while _next_ordinal_to_read < 1 {
6186 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6187 _next_ordinal_to_read += 1;
6188 next_offset += envelope_size;
6189 }
6190
6191 let next_out_of_line = decoder.next_out_of_line();
6192 let handles_before = decoder.remaining_handles();
6193 if let Some((inlined, num_bytes, num_handles)) =
6194 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6195 {
6196 let member_inline_size =
6197 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6198 if inlined != (member_inline_size <= 4) {
6199 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6200 }
6201 let inner_offset;
6202 let mut inner_depth = depth.clone();
6203 if inlined {
6204 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6205 inner_offset = next_offset;
6206 } else {
6207 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6208 inner_depth.increment()?;
6209 }
6210 let val_ref =
6211 self.temporary_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
6212 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6213 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6214 {
6215 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6216 }
6217 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6218 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6219 }
6220 }
6221
6222 next_offset += envelope_size;
6223
6224 while next_offset < end_offset {
6226 _next_ordinal_to_read += 1;
6227 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6228 next_offset += envelope_size;
6229 }
6230
6231 Ok(())
6232 }
6233 }
6234}