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
11pub type Addresses = Vec<fidl_fuchsia_net__common::Ipv4Address>;
19
20pub type AsciiString = String;
28
29pub type Duration = u32;
33
34pub const MAX_DNS_SERVERS: u8 = 64;
48
49pub const MAX_ROUTERS: u8 = 64;
63
64bitflags! {
65 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
68 pub struct NodeTypes: u8 {
69 const B_NODE = 1;
71 const P_NODE = 2;
73 const M_NODE = 4;
75 const H_NODE = 8;
77 }
78}
79
80impl NodeTypes {}
81
82#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
83#[repr(u32)]
84pub enum ClientExitReason {
85 ClientAlreadyExistsOnInterface = 1,
87 WatchConfigurationAlreadyPending = 2,
89 InvalidInterface = 3,
91 InvalidParams = 4,
93 NetworkUnreachable = 5,
96 UnableToOpenSocket = 6,
98 GracefulShutdown = 7,
100 AddressRemovedByUser = 8,
102 AddressStateProviderError = 9,
106}
107
108impl ClientExitReason {
109 #[inline]
110 pub fn from_primitive(prim: u32) -> Option<Self> {
111 match prim {
112 1 => Some(Self::ClientAlreadyExistsOnInterface),
113 2 => Some(Self::WatchConfigurationAlreadyPending),
114 3 => Some(Self::InvalidInterface),
115 4 => Some(Self::InvalidParams),
116 5 => Some(Self::NetworkUnreachable),
117 6 => Some(Self::UnableToOpenSocket),
118 7 => Some(Self::GracefulShutdown),
119 8 => Some(Self::AddressRemovedByUser),
120 9 => Some(Self::AddressStateProviderError),
121 _ => None,
122 }
123 }
124
125 #[inline]
126 pub const fn into_primitive(self) -> u32 {
127 self as u32
128 }
129}
130
131#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
135#[repr(u8)]
136pub enum MessageType {
137 Dhcpdiscover = 1,
139 Dhcpoffer = 2,
141 Dhcprequest = 3,
143 Dhcpdecline = 4,
145 Dhcpack = 5,
147 Dhcpnak = 6,
149 Dhcprelease = 7,
151 Dhcpinform = 8,
153}
154
155impl MessageType {
156 #[inline]
157 pub fn from_primitive(prim: u8) -> Option<Self> {
158 match prim {
159 1 => Some(Self::Dhcpdiscover),
160 2 => Some(Self::Dhcpoffer),
161 3 => Some(Self::Dhcprequest),
162 4 => Some(Self::Dhcpdecline),
163 5 => Some(Self::Dhcpack),
164 6 => Some(Self::Dhcpnak),
165 7 => Some(Self::Dhcprelease),
166 8 => Some(Self::Dhcpinform),
167 _ => None,
168 }
169 }
170
171 #[inline]
172 pub const fn into_primitive(self) -> u8 {
173 self as u8
174 }
175}
176
177#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
181#[repr(u32)]
182pub enum OptionCode {
183 SubnetMask = 1,
184 TimeOffset = 2,
185 Router = 3,
186 TimeServer = 4,
187 NameServer = 5,
188 DomainNameServer = 6,
189 LogServer = 7,
190 CookieServer = 8,
191 LprServer = 9,
192 ImpressServer = 10,
193 ResourceLocationServer = 11,
194 HostName = 12,
195 BootFileSize = 13,
196 MeritDumpFile = 14,
197 DomainName = 15,
198 SwapServer = 16,
199 RootPath = 17,
200 ExtensionsPath = 18,
201 IpForwarding = 19,
202 NonLocalSourceRouting = 20,
203 PolicyFilter = 21,
204 MaxDatagramReassemblySize = 22,
205 DefaultIpTtl = 23,
206 PathMtuAgingTimeout = 24,
207 PathMtuPlateauTable = 25,
208 InterfaceMtu = 26,
209 AllSubnetsLocal = 27,
210 BroadcastAddress = 28,
211 PerformMaskDiscovery = 29,
212 MaskSupplier = 30,
213 PerformRouterDiscovery = 31,
214 RouterSolicitationAddress = 32,
215 StaticRoute = 33,
216 TrailerEncapsulation = 34,
217 ArpCacheTimeout = 35,
218 EthernetEncapsulation = 36,
219 TcpDefaultTtl = 37,
220 TcpKeepaliveInterval = 38,
221 TcpKeepaliveGarbage = 39,
222 NetworkInformationServiceDomain = 40,
223 NetworkInformationServers = 41,
224 NetworkTimeProtocolServers = 42,
225 VendorSpecificInformation = 43,
226 NetbiosOverTcpipNameServer = 44,
227 NetbiosOverTcpipDatagramDistributionServer = 45,
228 NetbiosOverTcpipNodeType = 46,
229 NetbiosOverTcpipScope = 47,
230 XWindowSystemFontServer = 48,
231 XWindowSystemDisplayManager = 49,
232 NetworkInformationServicePlusDomain = 64,
233 NetworkInformationServicePlusServers = 65,
234 MobileIpHomeAgent = 68,
235 SmtpServer = 69,
236 Pop3Server = 70,
237 NntpServer = 71,
238 DefaultWwwServer = 72,
239 DefaultFingerServer = 73,
240 DefaultIrcServer = 74,
241 StreettalkServer = 75,
242 StreettalkDirectoryAssistanceServer = 76,
243 OptionOverload = 52,
244 TftpServerName = 66,
245 BootfileName = 67,
246 MaxDhcpMessageSize = 57,
247 RenewalTimeValue = 58,
248 RebindingTimeValue = 59,
249}
250
251impl OptionCode {
252 #[inline]
253 pub fn from_primitive(prim: u32) -> Option<Self> {
254 match prim {
255 1 => Some(Self::SubnetMask),
256 2 => Some(Self::TimeOffset),
257 3 => Some(Self::Router),
258 4 => Some(Self::TimeServer),
259 5 => Some(Self::NameServer),
260 6 => Some(Self::DomainNameServer),
261 7 => Some(Self::LogServer),
262 8 => Some(Self::CookieServer),
263 9 => Some(Self::LprServer),
264 10 => Some(Self::ImpressServer),
265 11 => Some(Self::ResourceLocationServer),
266 12 => Some(Self::HostName),
267 13 => Some(Self::BootFileSize),
268 14 => Some(Self::MeritDumpFile),
269 15 => Some(Self::DomainName),
270 16 => Some(Self::SwapServer),
271 17 => Some(Self::RootPath),
272 18 => Some(Self::ExtensionsPath),
273 19 => Some(Self::IpForwarding),
274 20 => Some(Self::NonLocalSourceRouting),
275 21 => Some(Self::PolicyFilter),
276 22 => Some(Self::MaxDatagramReassemblySize),
277 23 => Some(Self::DefaultIpTtl),
278 24 => Some(Self::PathMtuAgingTimeout),
279 25 => Some(Self::PathMtuPlateauTable),
280 26 => Some(Self::InterfaceMtu),
281 27 => Some(Self::AllSubnetsLocal),
282 28 => Some(Self::BroadcastAddress),
283 29 => Some(Self::PerformMaskDiscovery),
284 30 => Some(Self::MaskSupplier),
285 31 => Some(Self::PerformRouterDiscovery),
286 32 => Some(Self::RouterSolicitationAddress),
287 33 => Some(Self::StaticRoute),
288 34 => Some(Self::TrailerEncapsulation),
289 35 => Some(Self::ArpCacheTimeout),
290 36 => Some(Self::EthernetEncapsulation),
291 37 => Some(Self::TcpDefaultTtl),
292 38 => Some(Self::TcpKeepaliveInterval),
293 39 => Some(Self::TcpKeepaliveGarbage),
294 40 => Some(Self::NetworkInformationServiceDomain),
295 41 => Some(Self::NetworkInformationServers),
296 42 => Some(Self::NetworkTimeProtocolServers),
297 43 => Some(Self::VendorSpecificInformation),
298 44 => Some(Self::NetbiosOverTcpipNameServer),
299 45 => Some(Self::NetbiosOverTcpipDatagramDistributionServer),
300 46 => Some(Self::NetbiosOverTcpipNodeType),
301 47 => Some(Self::NetbiosOverTcpipScope),
302 48 => Some(Self::XWindowSystemFontServer),
303 49 => Some(Self::XWindowSystemDisplayManager),
304 64 => Some(Self::NetworkInformationServicePlusDomain),
305 65 => Some(Self::NetworkInformationServicePlusServers),
306 68 => Some(Self::MobileIpHomeAgent),
307 69 => Some(Self::SmtpServer),
308 70 => Some(Self::Pop3Server),
309 71 => Some(Self::NntpServer),
310 72 => Some(Self::DefaultWwwServer),
311 73 => Some(Self::DefaultFingerServer),
312 74 => Some(Self::DefaultIrcServer),
313 75 => Some(Self::StreettalkServer),
314 76 => Some(Self::StreettalkDirectoryAssistanceServer),
315 52 => Some(Self::OptionOverload),
316 66 => Some(Self::TftpServerName),
317 67 => Some(Self::BootfileName),
318 57 => Some(Self::MaxDhcpMessageSize),
319 58 => Some(Self::RenewalTimeValue),
320 59 => Some(Self::RebindingTimeValue),
321 _ => None,
322 }
323 }
324
325 #[inline]
326 pub const fn into_primitive(self) -> u32 {
327 self as u32
328 }
329}
330
331#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
333#[repr(u8)]
334pub enum OptionOverloadValue {
335 File = 1,
337 Sname = 2,
339 Both = 3,
341}
342
343impl OptionOverloadValue {
344 #[inline]
345 pub fn from_primitive(prim: u8) -> Option<Self> {
346 match prim {
347 1 => Some(Self::File),
348 2 => Some(Self::Sname),
349 3 => Some(Self::Both),
350 _ => None,
351 }
352 }
353
354 #[inline]
355 pub const fn into_primitive(self) -> u8 {
356 self as u8
357 }
358}
359
360#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
362#[repr(u32)]
363pub enum ParameterName {
364 IpAddrs = 0,
365 AddressPool = 1,
366 LeaseLength = 2,
367 PermittedMacs = 3,
368 StaticallyAssignedAddrs = 4,
369 ArpProbe = 5,
370 BoundDeviceNames = 6,
371}
372
373impl ParameterName {
374 #[inline]
375 pub fn from_primitive(prim: u32) -> Option<Self> {
376 match prim {
377 0 => Some(Self::IpAddrs),
378 1 => Some(Self::AddressPool),
379 2 => Some(Self::LeaseLength),
380 3 => Some(Self::PermittedMacs),
381 4 => Some(Self::StaticallyAssignedAddrs),
382 5 => Some(Self::ArpProbe),
383 6 => Some(Self::BoundDeviceNames),
384 _ => None,
385 }
386 }
387
388 #[inline]
389 pub const fn into_primitive(self) -> u32 {
390 self as u32
391 }
392}
393
394#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
395pub struct ClientOnExitRequest {
396 pub reason: ClientExitReason,
397}
398
399impl fidl::Persistable for ClientOnExitRequest {}
400
401#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
402pub struct ServerGetOptionRequest {
403 pub code: OptionCode,
404}
405
406impl fidl::Persistable for ServerGetOptionRequest {}
407
408#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
409pub struct ServerGetParameterRequest {
410 pub name: ParameterName,
411}
412
413impl fidl::Persistable for ServerGetParameterRequest {}
414
415#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
416pub struct ServerIsServingResponse {
417 pub enabled: bool,
418}
419
420impl fidl::Persistable for ServerIsServingResponse {}
421
422#[derive(Clone, Debug, PartialEq)]
423pub struct ServerSetOptionRequest {
424 pub value: Option_,
425}
426
427impl fidl::Persistable for ServerSetOptionRequest {}
428
429#[derive(Clone, Debug, PartialEq)]
430pub struct ServerSetParameterRequest {
431 pub value: Parameter,
432}
433
434impl fidl::Persistable for ServerSetParameterRequest {}
435
436#[derive(Clone, Debug, PartialEq)]
437pub struct ServerGetOptionResponse {
438 pub value: Option_,
439}
440
441impl fidl::Persistable for ServerGetOptionResponse {}
442
443#[derive(Clone, Debug, PartialEq)]
444pub struct ServerGetParameterResponse {
445 pub value: Parameter,
446}
447
448impl fidl::Persistable for ServerGetParameterResponse {}
449
450#[derive(Clone, Debug, PartialEq)]
451pub struct ServerListOptionsResponse {
452 pub options: Vec<Option_>,
453}
454
455impl fidl::Persistable for ServerListOptionsResponse {}
456
457#[derive(Clone, Debug, PartialEq)]
458pub struct ServerListParametersResponse {
459 pub parameters: Vec<Parameter>,
460}
461
462impl fidl::Persistable for ServerListParametersResponse {}
463
464#[derive(Clone, Debug, Default, PartialEq)]
465pub struct AddressPool {
466 pub prefix_length: Option<u8>,
468 pub range_start: Option<fidl_fuchsia_net__common::Ipv4Address>,
471 pub range_stop: Option<fidl_fuchsia_net__common::Ipv4Address>,
474 #[doc(hidden)]
475 pub __source_breaking: fidl::marker::SourceBreaking,
476}
477
478impl fidl::Persistable for AddressPool {}
479
480#[derive(Clone, Debug, Default, PartialEq)]
483pub struct ConfigurationToRequest {
484 pub routers: Option<bool>,
490 pub dns_servers: Option<bool>,
495 #[doc(hidden)]
496 pub __source_breaking: fidl::marker::SourceBreaking,
497}
498
499impl fidl::Persistable for ConfigurationToRequest {}
500
501#[derive(Clone, Debug, Default, PartialEq)]
502pub struct LeaseLength {
503 pub default: Option<u32>,
506 pub max: Option<u32>,
510 #[doc(hidden)]
511 pub __source_breaking: fidl::marker::SourceBreaking,
512}
513
514impl fidl::Persistable for LeaseLength {}
515
516#[derive(Clone, Debug, Default, PartialEq)]
517pub struct NewClientParams {
518 pub configuration_to_request: Option<ConfigurationToRequest>,
524 pub request_ip_address: Option<bool>,
530 #[doc(hidden)]
531 pub __source_breaking: fidl::marker::SourceBreaking,
532}
533
534impl fidl::Persistable for NewClientParams {}
535
536#[derive(Clone, Debug, Default, PartialEq)]
537pub struct StaticAssignment {
538 pub host: Option<fidl_fuchsia_net__common::MacAddress>,
541 pub assigned_addr: Option<fidl_fuchsia_net__common::Ipv4Address>,
544 #[doc(hidden)]
545 pub __source_breaking: fidl::marker::SourceBreaking,
546}
547
548impl fidl::Persistable for StaticAssignment {}
549
550#[derive(Clone, Debug)]
567pub enum Option_ {
568 SubnetMask(fidl_fuchsia_net__common::Ipv4Address),
570 TimeOffset(i32),
573 Router(Vec<fidl_fuchsia_net__common::Ipv4Address>),
575 TimeServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
577 NameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
579 DomainNameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
581 LogServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
583 CookieServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
585 LprServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
587 ImpressServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
589 ResourceLocationServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
591 HostName(String),
593 BootFileSize(u16),
595 MeritDumpFile(String),
597 DomainName(String),
599 SwapServer(fidl_fuchsia_net__common::Ipv4Address),
601 RootPath(String),
603 ExtensionsPath(String),
607 IpForwarding(bool),
609 NonLocalSourceRouting(bool),
611 PolicyFilter(Vec<fidl_fuchsia_net__common::Ipv4Address>),
615 MaxDatagramReassemblySize(u16),
618 DefaultIpTtl(u8),
621 PathMtuAgingTimeout(u32),
623 PathMtuPlateauTable(Vec<u16>),
627 InterfaceMtu(u16),
629 AllSubnetsLocal(bool),
632 BroadcastAddress(fidl_fuchsia_net__common::Ipv4Address),
634 PerformMaskDiscovery(bool),
636 MaskSupplier(bool),
639 PerformRouterDiscovery(bool),
642 RouterSolicitationAddress(fidl_fuchsia_net__common::Ipv4Address),
644 StaticRoute(Vec<fidl_fuchsia_net__common::Ipv4Address>),
649 TrailerEncapsulation(bool),
652 ArpCacheTimeout(u32),
654 EthernetEncapsulation(bool),
657 TcpDefaultTtl(u8),
660 TcpKeepaliveInterval(u32),
664 TcpKeepaliveGarbage(bool),
667 NetworkInformationServiceDomain(String),
669 NetworkInformationServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
672 NetworkTimeProtocolServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
675 VendorSpecificInformation(Vec<u8>),
677 NetbiosOverTcpipNameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
680 NetbiosOverTcpipDatagramDistributionServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
683 NetbiosOverTcpipNodeType(NodeTypes),
685 NetbiosOverTcpipScope(String),
687 XWindowSystemFontServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
690 XWindowSystemDisplayManager(Vec<fidl_fuchsia_net__common::Ipv4Address>),
693 NetworkInformationServicePlusDomain(String),
695 NetworkInformationServicePlusServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
698 MobileIpHomeAgent(Vec<fidl_fuchsia_net__common::Ipv4Address>),
701 SmtpServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
704 Pop3Server(Vec<fidl_fuchsia_net__common::Ipv4Address>),
707 NntpServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
710 DefaultWwwServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
713 DefaultFingerServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
716 DefaultIrcServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
719 StreettalkServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
722 StreettalkDirectoryAssistanceServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
725 OptionOverload(OptionOverloadValue),
729 TftpServerName(String),
732 BootfileName(String),
735 MaxDhcpMessageSize(u16),
738 RenewalTimeValue(u32),
741 RebindingTimeValue(u32),
744 #[doc(hidden)]
745 __SourceBreaking { unknown_ordinal: u64 },
746}
747
748#[macro_export]
750macro_rules! Option_Unknown {
751 () => {
752 _
753 };
754}
755
756impl PartialEq for Option_ {
758 fn eq(&self, other: &Self) -> bool {
759 match (self, other) {
760 (Self::SubnetMask(x), Self::SubnetMask(y)) => *x == *y,
761 (Self::TimeOffset(x), Self::TimeOffset(y)) => *x == *y,
762 (Self::Router(x), Self::Router(y)) => *x == *y,
763 (Self::TimeServer(x), Self::TimeServer(y)) => *x == *y,
764 (Self::NameServer(x), Self::NameServer(y)) => *x == *y,
765 (Self::DomainNameServer(x), Self::DomainNameServer(y)) => *x == *y,
766 (Self::LogServer(x), Self::LogServer(y)) => *x == *y,
767 (Self::CookieServer(x), Self::CookieServer(y)) => *x == *y,
768 (Self::LprServer(x), Self::LprServer(y)) => *x == *y,
769 (Self::ImpressServer(x), Self::ImpressServer(y)) => *x == *y,
770 (Self::ResourceLocationServer(x), Self::ResourceLocationServer(y)) => *x == *y,
771 (Self::HostName(x), Self::HostName(y)) => *x == *y,
772 (Self::BootFileSize(x), Self::BootFileSize(y)) => *x == *y,
773 (Self::MeritDumpFile(x), Self::MeritDumpFile(y)) => *x == *y,
774 (Self::DomainName(x), Self::DomainName(y)) => *x == *y,
775 (Self::SwapServer(x), Self::SwapServer(y)) => *x == *y,
776 (Self::RootPath(x), Self::RootPath(y)) => *x == *y,
777 (Self::ExtensionsPath(x), Self::ExtensionsPath(y)) => *x == *y,
778 (Self::IpForwarding(x), Self::IpForwarding(y)) => *x == *y,
779 (Self::NonLocalSourceRouting(x), Self::NonLocalSourceRouting(y)) => *x == *y,
780 (Self::PolicyFilter(x), Self::PolicyFilter(y)) => *x == *y,
781 (Self::MaxDatagramReassemblySize(x), Self::MaxDatagramReassemblySize(y)) => *x == *y,
782 (Self::DefaultIpTtl(x), Self::DefaultIpTtl(y)) => *x == *y,
783 (Self::PathMtuAgingTimeout(x), Self::PathMtuAgingTimeout(y)) => *x == *y,
784 (Self::PathMtuPlateauTable(x), Self::PathMtuPlateauTable(y)) => *x == *y,
785 (Self::InterfaceMtu(x), Self::InterfaceMtu(y)) => *x == *y,
786 (Self::AllSubnetsLocal(x), Self::AllSubnetsLocal(y)) => *x == *y,
787 (Self::BroadcastAddress(x), Self::BroadcastAddress(y)) => *x == *y,
788 (Self::PerformMaskDiscovery(x), Self::PerformMaskDiscovery(y)) => *x == *y,
789 (Self::MaskSupplier(x), Self::MaskSupplier(y)) => *x == *y,
790 (Self::PerformRouterDiscovery(x), Self::PerformRouterDiscovery(y)) => *x == *y,
791 (Self::RouterSolicitationAddress(x), Self::RouterSolicitationAddress(y)) => *x == *y,
792 (Self::StaticRoute(x), Self::StaticRoute(y)) => *x == *y,
793 (Self::TrailerEncapsulation(x), Self::TrailerEncapsulation(y)) => *x == *y,
794 (Self::ArpCacheTimeout(x), Self::ArpCacheTimeout(y)) => *x == *y,
795 (Self::EthernetEncapsulation(x), Self::EthernetEncapsulation(y)) => *x == *y,
796 (Self::TcpDefaultTtl(x), Self::TcpDefaultTtl(y)) => *x == *y,
797 (Self::TcpKeepaliveInterval(x), Self::TcpKeepaliveInterval(y)) => *x == *y,
798 (Self::TcpKeepaliveGarbage(x), Self::TcpKeepaliveGarbage(y)) => *x == *y,
799 (
800 Self::NetworkInformationServiceDomain(x),
801 Self::NetworkInformationServiceDomain(y),
802 ) => *x == *y,
803 (Self::NetworkInformationServers(x), Self::NetworkInformationServers(y)) => *x == *y,
804 (Self::NetworkTimeProtocolServers(x), Self::NetworkTimeProtocolServers(y)) => *x == *y,
805 (Self::VendorSpecificInformation(x), Self::VendorSpecificInformation(y)) => *x == *y,
806 (Self::NetbiosOverTcpipNameServer(x), Self::NetbiosOverTcpipNameServer(y)) => *x == *y,
807 (
808 Self::NetbiosOverTcpipDatagramDistributionServer(x),
809 Self::NetbiosOverTcpipDatagramDistributionServer(y),
810 ) => *x == *y,
811 (Self::NetbiosOverTcpipNodeType(x), Self::NetbiosOverTcpipNodeType(y)) => *x == *y,
812 (Self::NetbiosOverTcpipScope(x), Self::NetbiosOverTcpipScope(y)) => *x == *y,
813 (Self::XWindowSystemFontServer(x), Self::XWindowSystemFontServer(y)) => *x == *y,
814 (Self::XWindowSystemDisplayManager(x), Self::XWindowSystemDisplayManager(y)) => {
815 *x == *y
816 }
817 (
818 Self::NetworkInformationServicePlusDomain(x),
819 Self::NetworkInformationServicePlusDomain(y),
820 ) => *x == *y,
821 (
822 Self::NetworkInformationServicePlusServers(x),
823 Self::NetworkInformationServicePlusServers(y),
824 ) => *x == *y,
825 (Self::MobileIpHomeAgent(x), Self::MobileIpHomeAgent(y)) => *x == *y,
826 (Self::SmtpServer(x), Self::SmtpServer(y)) => *x == *y,
827 (Self::Pop3Server(x), Self::Pop3Server(y)) => *x == *y,
828 (Self::NntpServer(x), Self::NntpServer(y)) => *x == *y,
829 (Self::DefaultWwwServer(x), Self::DefaultWwwServer(y)) => *x == *y,
830 (Self::DefaultFingerServer(x), Self::DefaultFingerServer(y)) => *x == *y,
831 (Self::DefaultIrcServer(x), Self::DefaultIrcServer(y)) => *x == *y,
832 (Self::StreettalkServer(x), Self::StreettalkServer(y)) => *x == *y,
833 (
834 Self::StreettalkDirectoryAssistanceServer(x),
835 Self::StreettalkDirectoryAssistanceServer(y),
836 ) => *x == *y,
837 (Self::OptionOverload(x), Self::OptionOverload(y)) => *x == *y,
838 (Self::TftpServerName(x), Self::TftpServerName(y)) => *x == *y,
839 (Self::BootfileName(x), Self::BootfileName(y)) => *x == *y,
840 (Self::MaxDhcpMessageSize(x), Self::MaxDhcpMessageSize(y)) => *x == *y,
841 (Self::RenewalTimeValue(x), Self::RenewalTimeValue(y)) => *x == *y,
842 (Self::RebindingTimeValue(x), Self::RebindingTimeValue(y)) => *x == *y,
843 _ => false,
844 }
845 }
846}
847
848impl Option_ {
849 #[inline]
850 pub fn ordinal(&self) -> u64 {
851 match *self {
852 Self::SubnetMask(_) => 1,
853 Self::TimeOffset(_) => 2,
854 Self::Router(_) => 3,
855 Self::TimeServer(_) => 4,
856 Self::NameServer(_) => 5,
857 Self::DomainNameServer(_) => 6,
858 Self::LogServer(_) => 7,
859 Self::CookieServer(_) => 8,
860 Self::LprServer(_) => 9,
861 Self::ImpressServer(_) => 10,
862 Self::ResourceLocationServer(_) => 11,
863 Self::HostName(_) => 12,
864 Self::BootFileSize(_) => 13,
865 Self::MeritDumpFile(_) => 14,
866 Self::DomainName(_) => 15,
867 Self::SwapServer(_) => 16,
868 Self::RootPath(_) => 17,
869 Self::ExtensionsPath(_) => 18,
870 Self::IpForwarding(_) => 19,
871 Self::NonLocalSourceRouting(_) => 20,
872 Self::PolicyFilter(_) => 21,
873 Self::MaxDatagramReassemblySize(_) => 22,
874 Self::DefaultIpTtl(_) => 23,
875 Self::PathMtuAgingTimeout(_) => 24,
876 Self::PathMtuPlateauTable(_) => 25,
877 Self::InterfaceMtu(_) => 26,
878 Self::AllSubnetsLocal(_) => 27,
879 Self::BroadcastAddress(_) => 28,
880 Self::PerformMaskDiscovery(_) => 29,
881 Self::MaskSupplier(_) => 30,
882 Self::PerformRouterDiscovery(_) => 31,
883 Self::RouterSolicitationAddress(_) => 32,
884 Self::StaticRoute(_) => 33,
885 Self::TrailerEncapsulation(_) => 34,
886 Self::ArpCacheTimeout(_) => 35,
887 Self::EthernetEncapsulation(_) => 36,
888 Self::TcpDefaultTtl(_) => 37,
889 Self::TcpKeepaliveInterval(_) => 38,
890 Self::TcpKeepaliveGarbage(_) => 39,
891 Self::NetworkInformationServiceDomain(_) => 40,
892 Self::NetworkInformationServers(_) => 41,
893 Self::NetworkTimeProtocolServers(_) => 42,
894 Self::VendorSpecificInformation(_) => 43,
895 Self::NetbiosOverTcpipNameServer(_) => 44,
896 Self::NetbiosOverTcpipDatagramDistributionServer(_) => 45,
897 Self::NetbiosOverTcpipNodeType(_) => 46,
898 Self::NetbiosOverTcpipScope(_) => 47,
899 Self::XWindowSystemFontServer(_) => 48,
900 Self::XWindowSystemDisplayManager(_) => 49,
901 Self::NetworkInformationServicePlusDomain(_) => 50,
902 Self::NetworkInformationServicePlusServers(_) => 51,
903 Self::MobileIpHomeAgent(_) => 52,
904 Self::SmtpServer(_) => 53,
905 Self::Pop3Server(_) => 54,
906 Self::NntpServer(_) => 55,
907 Self::DefaultWwwServer(_) => 56,
908 Self::DefaultFingerServer(_) => 57,
909 Self::DefaultIrcServer(_) => 58,
910 Self::StreettalkServer(_) => 59,
911 Self::StreettalkDirectoryAssistanceServer(_) => 60,
912 Self::OptionOverload(_) => 61,
913 Self::TftpServerName(_) => 62,
914 Self::BootfileName(_) => 63,
915 Self::MaxDhcpMessageSize(_) => 64,
916 Self::RenewalTimeValue(_) => 65,
917 Self::RebindingTimeValue(_) => 66,
918 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
919 }
920 }
921
922 #[inline]
923 pub fn unknown_variant_for_testing() -> Self {
924 Self::__SourceBreaking { unknown_ordinal: 0 }
925 }
926
927 #[inline]
928 pub fn is_unknown(&self) -> bool {
929 match self {
930 Self::__SourceBreaking { .. } => true,
931 _ => false,
932 }
933 }
934}
935
936impl fidl::Persistable for Option_ {}
937
938#[derive(Clone, Debug)]
940pub enum Parameter {
941 IpAddrs(Vec<fidl_fuchsia_net__common::Ipv4Address>),
944 AddressPool(AddressPool),
966 Lease(LeaseLength),
968 PermittedMacs(Vec<fidl_fuchsia_net__common::MacAddress>),
975 StaticallyAssignedAddrs(Vec<StaticAssignment>),
981 ArpProbe(bool),
985 BoundDeviceNames(Vec<String>),
993 #[doc(hidden)]
994 __SourceBreaking { unknown_ordinal: u64 },
995}
996
997#[macro_export]
999macro_rules! ParameterUnknown {
1000 () => {
1001 _
1002 };
1003}
1004
1005impl PartialEq for Parameter {
1007 fn eq(&self, other: &Self) -> bool {
1008 match (self, other) {
1009 (Self::IpAddrs(x), Self::IpAddrs(y)) => *x == *y,
1010 (Self::AddressPool(x), Self::AddressPool(y)) => *x == *y,
1011 (Self::Lease(x), Self::Lease(y)) => *x == *y,
1012 (Self::PermittedMacs(x), Self::PermittedMacs(y)) => *x == *y,
1013 (Self::StaticallyAssignedAddrs(x), Self::StaticallyAssignedAddrs(y)) => *x == *y,
1014 (Self::ArpProbe(x), Self::ArpProbe(y)) => *x == *y,
1015 (Self::BoundDeviceNames(x), Self::BoundDeviceNames(y)) => *x == *y,
1016 _ => false,
1017 }
1018 }
1019}
1020
1021impl Parameter {
1022 #[inline]
1023 pub fn ordinal(&self) -> u64 {
1024 match *self {
1025 Self::IpAddrs(_) => 1,
1026 Self::AddressPool(_) => 2,
1027 Self::Lease(_) => 3,
1028 Self::PermittedMacs(_) => 4,
1029 Self::StaticallyAssignedAddrs(_) => 5,
1030 Self::ArpProbe(_) => 6,
1031 Self::BoundDeviceNames(_) => 7,
1032 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1033 }
1034 }
1035
1036 #[inline]
1037 pub fn unknown_variant_for_testing() -> Self {
1038 Self::__SourceBreaking { unknown_ordinal: 0 }
1039 }
1040
1041 #[inline]
1042 pub fn is_unknown(&self) -> bool {
1043 match self {
1044 Self::__SourceBreaking { .. } => true,
1045 _ => false,
1046 }
1047 }
1048}
1049
1050impl fidl::Persistable for Parameter {}
1051
1052pub mod client_ordinals {
1053 pub const WATCH_CONFIGURATION: u64 = 0x2b6f7c7d3bcc6682;
1054 pub const SHUTDOWN: u64 = 0x265a3213e9a8abde;
1055 pub const ON_EXIT: u64 = 0x2a2a052260f657c0;
1056}
1057
1058pub mod client_provider_ordinals {
1059 pub const NEW_CLIENT: u64 = 0x317e9af2e462cbcd;
1060 pub const CHECK_PRESENCE: u64 = 0x7ba657cd730bbf60;
1061}
1062
1063pub mod server__ordinals {
1064 pub const START_SERVING: u64 = 0x10990e324ac53cd1;
1065 pub const STOP_SERVING: u64 = 0x7776cfe9f68a0dbe;
1066 pub const IS_SERVING: u64 = 0x45aadc35fcbe3826;
1067 pub const GET_OPTION: u64 = 0x5305ee2c593f68a;
1068 pub const GET_PARAMETER: u64 = 0x1e8c98758fb82714;
1069 pub const SET_OPTION: u64 = 0x63c98b670db8d96a;
1070 pub const SET_PARAMETER: u64 = 0x3002d0d956eb4bdc;
1071 pub const LIST_OPTIONS: u64 = 0x72c8161c69ca67b;
1072 pub const LIST_PARAMETERS: u64 = 0xa201b1d6d121c59;
1073 pub const RESET_OPTIONS: u64 = 0x31014911fd21cc13;
1074 pub const RESET_PARAMETERS: u64 = 0x353fba50bcf4ecec;
1075 pub const CLEAR_LEASES: u64 = 0xe39e35cda85a04d;
1076}
1077
1078mod internal {
1079 use super::*;
1080 unsafe impl fidl::encoding::TypeMarker for NodeTypes {
1081 type Owned = Self;
1082
1083 #[inline(always)]
1084 fn inline_align(_context: fidl::encoding::Context) -> usize {
1085 1
1086 }
1087
1088 #[inline(always)]
1089 fn inline_size(_context: fidl::encoding::Context) -> usize {
1090 1
1091 }
1092 }
1093
1094 impl fidl::encoding::ValueTypeMarker for NodeTypes {
1095 type Borrowed<'a> = Self;
1096 #[inline(always)]
1097 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1098 *value
1099 }
1100 }
1101
1102 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeTypes {
1103 #[inline]
1104 unsafe fn encode(
1105 self,
1106 encoder: &mut fidl::encoding::Encoder<'_, D>,
1107 offset: usize,
1108 _depth: fidl::encoding::Depth,
1109 ) -> fidl::Result<()> {
1110 encoder.debug_check_bounds::<Self>(offset);
1111 if self.bits() & Self::all().bits() != self.bits() {
1112 return Err(fidl::Error::InvalidBitsValue);
1113 }
1114 encoder.write_num(self.bits(), offset);
1115 Ok(())
1116 }
1117 }
1118
1119 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeTypes {
1120 #[inline(always)]
1121 fn new_empty() -> Self {
1122 Self::empty()
1123 }
1124
1125 #[inline]
1126 unsafe fn decode(
1127 &mut self,
1128 decoder: &mut fidl::encoding::Decoder<'_, D>,
1129 offset: usize,
1130 _depth: fidl::encoding::Depth,
1131 ) -> fidl::Result<()> {
1132 decoder.debug_check_bounds::<Self>(offset);
1133 let prim = decoder.read_num::<u8>(offset);
1134 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1135 Ok(())
1136 }
1137 }
1138 unsafe impl fidl::encoding::TypeMarker for ClientExitReason {
1139 type Owned = Self;
1140
1141 #[inline(always)]
1142 fn inline_align(_context: fidl::encoding::Context) -> usize {
1143 std::mem::align_of::<u32>()
1144 }
1145
1146 #[inline(always)]
1147 fn inline_size(_context: fidl::encoding::Context) -> usize {
1148 std::mem::size_of::<u32>()
1149 }
1150
1151 #[inline(always)]
1152 fn encode_is_copy() -> bool {
1153 true
1154 }
1155
1156 #[inline(always)]
1157 fn decode_is_copy() -> bool {
1158 false
1159 }
1160 }
1161
1162 impl fidl::encoding::ValueTypeMarker for ClientExitReason {
1163 type Borrowed<'a> = Self;
1164 #[inline(always)]
1165 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1166 *value
1167 }
1168 }
1169
1170 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1171 for ClientExitReason
1172 {
1173 #[inline]
1174 unsafe fn encode(
1175 self,
1176 encoder: &mut fidl::encoding::Encoder<'_, D>,
1177 offset: usize,
1178 _depth: fidl::encoding::Depth,
1179 ) -> fidl::Result<()> {
1180 encoder.debug_check_bounds::<Self>(offset);
1181 encoder.write_num(self.into_primitive(), offset);
1182 Ok(())
1183 }
1184 }
1185
1186 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientExitReason {
1187 #[inline(always)]
1188 fn new_empty() -> Self {
1189 Self::ClientAlreadyExistsOnInterface
1190 }
1191
1192 #[inline]
1193 unsafe fn decode(
1194 &mut self,
1195 decoder: &mut fidl::encoding::Decoder<'_, D>,
1196 offset: usize,
1197 _depth: fidl::encoding::Depth,
1198 ) -> fidl::Result<()> {
1199 decoder.debug_check_bounds::<Self>(offset);
1200 let prim = decoder.read_num::<u32>(offset);
1201
1202 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1203 Ok(())
1204 }
1205 }
1206 unsafe impl fidl::encoding::TypeMarker for MessageType {
1207 type Owned = Self;
1208
1209 #[inline(always)]
1210 fn inline_align(_context: fidl::encoding::Context) -> usize {
1211 std::mem::align_of::<u8>()
1212 }
1213
1214 #[inline(always)]
1215 fn inline_size(_context: fidl::encoding::Context) -> usize {
1216 std::mem::size_of::<u8>()
1217 }
1218
1219 #[inline(always)]
1220 fn encode_is_copy() -> bool {
1221 true
1222 }
1223
1224 #[inline(always)]
1225 fn decode_is_copy() -> bool {
1226 false
1227 }
1228 }
1229
1230 impl fidl::encoding::ValueTypeMarker for MessageType {
1231 type Borrowed<'a> = Self;
1232 #[inline(always)]
1233 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1234 *value
1235 }
1236 }
1237
1238 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
1239 #[inline]
1240 unsafe fn encode(
1241 self,
1242 encoder: &mut fidl::encoding::Encoder<'_, D>,
1243 offset: usize,
1244 _depth: fidl::encoding::Depth,
1245 ) -> fidl::Result<()> {
1246 encoder.debug_check_bounds::<Self>(offset);
1247 encoder.write_num(self.into_primitive(), offset);
1248 Ok(())
1249 }
1250 }
1251
1252 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
1253 #[inline(always)]
1254 fn new_empty() -> Self {
1255 Self::Dhcpdiscover
1256 }
1257
1258 #[inline]
1259 unsafe fn decode(
1260 &mut self,
1261 decoder: &mut fidl::encoding::Decoder<'_, D>,
1262 offset: usize,
1263 _depth: fidl::encoding::Depth,
1264 ) -> fidl::Result<()> {
1265 decoder.debug_check_bounds::<Self>(offset);
1266 let prim = decoder.read_num::<u8>(offset);
1267
1268 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1269 Ok(())
1270 }
1271 }
1272 unsafe impl fidl::encoding::TypeMarker for OptionCode {
1273 type Owned = Self;
1274
1275 #[inline(always)]
1276 fn inline_align(_context: fidl::encoding::Context) -> usize {
1277 std::mem::align_of::<u32>()
1278 }
1279
1280 #[inline(always)]
1281 fn inline_size(_context: fidl::encoding::Context) -> usize {
1282 std::mem::size_of::<u32>()
1283 }
1284
1285 #[inline(always)]
1286 fn encode_is_copy() -> bool {
1287 true
1288 }
1289
1290 #[inline(always)]
1291 fn decode_is_copy() -> bool {
1292 false
1293 }
1294 }
1295
1296 impl fidl::encoding::ValueTypeMarker for OptionCode {
1297 type Borrowed<'a> = Self;
1298 #[inline(always)]
1299 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1300 *value
1301 }
1302 }
1303
1304 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OptionCode {
1305 #[inline]
1306 unsafe fn encode(
1307 self,
1308 encoder: &mut fidl::encoding::Encoder<'_, D>,
1309 offset: usize,
1310 _depth: fidl::encoding::Depth,
1311 ) -> fidl::Result<()> {
1312 encoder.debug_check_bounds::<Self>(offset);
1313 encoder.write_num(self.into_primitive(), offset);
1314 Ok(())
1315 }
1316 }
1317
1318 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionCode {
1319 #[inline(always)]
1320 fn new_empty() -> Self {
1321 Self::SubnetMask
1322 }
1323
1324 #[inline]
1325 unsafe fn decode(
1326 &mut self,
1327 decoder: &mut fidl::encoding::Decoder<'_, D>,
1328 offset: usize,
1329 _depth: fidl::encoding::Depth,
1330 ) -> fidl::Result<()> {
1331 decoder.debug_check_bounds::<Self>(offset);
1332 let prim = decoder.read_num::<u32>(offset);
1333
1334 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1335 Ok(())
1336 }
1337 }
1338 unsafe impl fidl::encoding::TypeMarker for OptionOverloadValue {
1339 type Owned = Self;
1340
1341 #[inline(always)]
1342 fn inline_align(_context: fidl::encoding::Context) -> usize {
1343 std::mem::align_of::<u8>()
1344 }
1345
1346 #[inline(always)]
1347 fn inline_size(_context: fidl::encoding::Context) -> usize {
1348 std::mem::size_of::<u8>()
1349 }
1350
1351 #[inline(always)]
1352 fn encode_is_copy() -> bool {
1353 true
1354 }
1355
1356 #[inline(always)]
1357 fn decode_is_copy() -> bool {
1358 false
1359 }
1360 }
1361
1362 impl fidl::encoding::ValueTypeMarker for OptionOverloadValue {
1363 type Borrowed<'a> = Self;
1364 #[inline(always)]
1365 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1366 *value
1367 }
1368 }
1369
1370 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1371 for OptionOverloadValue
1372 {
1373 #[inline]
1374 unsafe fn encode(
1375 self,
1376 encoder: &mut fidl::encoding::Encoder<'_, D>,
1377 offset: usize,
1378 _depth: fidl::encoding::Depth,
1379 ) -> fidl::Result<()> {
1380 encoder.debug_check_bounds::<Self>(offset);
1381 encoder.write_num(self.into_primitive(), offset);
1382 Ok(())
1383 }
1384 }
1385
1386 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionOverloadValue {
1387 #[inline(always)]
1388 fn new_empty() -> Self {
1389 Self::File
1390 }
1391
1392 #[inline]
1393 unsafe fn decode(
1394 &mut self,
1395 decoder: &mut fidl::encoding::Decoder<'_, D>,
1396 offset: usize,
1397 _depth: fidl::encoding::Depth,
1398 ) -> fidl::Result<()> {
1399 decoder.debug_check_bounds::<Self>(offset);
1400 let prim = decoder.read_num::<u8>(offset);
1401
1402 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1403 Ok(())
1404 }
1405 }
1406 unsafe impl fidl::encoding::TypeMarker for ParameterName {
1407 type Owned = Self;
1408
1409 #[inline(always)]
1410 fn inline_align(_context: fidl::encoding::Context) -> usize {
1411 std::mem::align_of::<u32>()
1412 }
1413
1414 #[inline(always)]
1415 fn inline_size(_context: fidl::encoding::Context) -> usize {
1416 std::mem::size_of::<u32>()
1417 }
1418
1419 #[inline(always)]
1420 fn encode_is_copy() -> bool {
1421 true
1422 }
1423
1424 #[inline(always)]
1425 fn decode_is_copy() -> bool {
1426 false
1427 }
1428 }
1429
1430 impl fidl::encoding::ValueTypeMarker for ParameterName {
1431 type Borrowed<'a> = Self;
1432 #[inline(always)]
1433 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1434 *value
1435 }
1436 }
1437
1438 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ParameterName {
1439 #[inline]
1440 unsafe fn encode(
1441 self,
1442 encoder: &mut fidl::encoding::Encoder<'_, D>,
1443 offset: usize,
1444 _depth: fidl::encoding::Depth,
1445 ) -> fidl::Result<()> {
1446 encoder.debug_check_bounds::<Self>(offset);
1447 encoder.write_num(self.into_primitive(), offset);
1448 Ok(())
1449 }
1450 }
1451
1452 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParameterName {
1453 #[inline(always)]
1454 fn new_empty() -> Self {
1455 Self::IpAddrs
1456 }
1457
1458 #[inline]
1459 unsafe fn decode(
1460 &mut self,
1461 decoder: &mut fidl::encoding::Decoder<'_, D>,
1462 offset: usize,
1463 _depth: fidl::encoding::Depth,
1464 ) -> fidl::Result<()> {
1465 decoder.debug_check_bounds::<Self>(offset);
1466 let prim = decoder.read_num::<u32>(offset);
1467
1468 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1469 Ok(())
1470 }
1471 }
1472
1473 impl fidl::encoding::ValueTypeMarker for ClientOnExitRequest {
1474 type Borrowed<'a> = &'a Self;
1475 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1476 value
1477 }
1478 }
1479
1480 unsafe impl fidl::encoding::TypeMarker for ClientOnExitRequest {
1481 type Owned = Self;
1482
1483 #[inline(always)]
1484 fn inline_align(_context: fidl::encoding::Context) -> usize {
1485 4
1486 }
1487
1488 #[inline(always)]
1489 fn inline_size(_context: fidl::encoding::Context) -> usize {
1490 4
1491 }
1492 }
1493
1494 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClientOnExitRequest, D>
1495 for &ClientOnExitRequest
1496 {
1497 #[inline]
1498 unsafe fn encode(
1499 self,
1500 encoder: &mut fidl::encoding::Encoder<'_, D>,
1501 offset: usize,
1502 _depth: fidl::encoding::Depth,
1503 ) -> fidl::Result<()> {
1504 encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
1505 fidl::encoding::Encode::<ClientOnExitRequest, D>::encode(
1507 (<ClientExitReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
1508 encoder,
1509 offset,
1510 _depth,
1511 )
1512 }
1513 }
1514 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ClientExitReason, D>>
1515 fidl::encoding::Encode<ClientOnExitRequest, D> for (T0,)
1516 {
1517 #[inline]
1518 unsafe fn encode(
1519 self,
1520 encoder: &mut fidl::encoding::Encoder<'_, D>,
1521 offset: usize,
1522 depth: fidl::encoding::Depth,
1523 ) -> fidl::Result<()> {
1524 encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
1525 self.0.encode(encoder, offset + 0, depth)?;
1529 Ok(())
1530 }
1531 }
1532
1533 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientOnExitRequest {
1534 #[inline(always)]
1535 fn new_empty() -> Self {
1536 Self { reason: fidl::new_empty!(ClientExitReason, D) }
1537 }
1538
1539 #[inline]
1540 unsafe fn decode(
1541 &mut self,
1542 decoder: &mut fidl::encoding::Decoder<'_, D>,
1543 offset: usize,
1544 _depth: fidl::encoding::Depth,
1545 ) -> fidl::Result<()> {
1546 decoder.debug_check_bounds::<Self>(offset);
1547 fidl::decode!(ClientExitReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
1549 Ok(())
1550 }
1551 }
1552
1553 impl fidl::encoding::ValueTypeMarker for ServerGetOptionRequest {
1554 type Borrowed<'a> = &'a Self;
1555 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1556 value
1557 }
1558 }
1559
1560 unsafe impl fidl::encoding::TypeMarker for ServerGetOptionRequest {
1561 type Owned = Self;
1562
1563 #[inline(always)]
1564 fn inline_align(_context: fidl::encoding::Context) -> usize {
1565 4
1566 }
1567
1568 #[inline(always)]
1569 fn inline_size(_context: fidl::encoding::Context) -> usize {
1570 4
1571 }
1572 }
1573
1574 unsafe impl<D: fidl::encoding::ResourceDialect>
1575 fidl::encoding::Encode<ServerGetOptionRequest, D> for &ServerGetOptionRequest
1576 {
1577 #[inline]
1578 unsafe fn encode(
1579 self,
1580 encoder: &mut fidl::encoding::Encoder<'_, D>,
1581 offset: usize,
1582 _depth: fidl::encoding::Depth,
1583 ) -> fidl::Result<()> {
1584 encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
1585 fidl::encoding::Encode::<ServerGetOptionRequest, D>::encode(
1587 (<OptionCode as fidl::encoding::ValueTypeMarker>::borrow(&self.code),),
1588 encoder,
1589 offset,
1590 _depth,
1591 )
1592 }
1593 }
1594 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OptionCode, D>>
1595 fidl::encoding::Encode<ServerGetOptionRequest, D> for (T0,)
1596 {
1597 #[inline]
1598 unsafe fn encode(
1599 self,
1600 encoder: &mut fidl::encoding::Encoder<'_, D>,
1601 offset: usize,
1602 depth: fidl::encoding::Depth,
1603 ) -> fidl::Result<()> {
1604 encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
1605 self.0.encode(encoder, offset + 0, depth)?;
1609 Ok(())
1610 }
1611 }
1612
1613 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1614 for ServerGetOptionRequest
1615 {
1616 #[inline(always)]
1617 fn new_empty() -> Self {
1618 Self { code: fidl::new_empty!(OptionCode, D) }
1619 }
1620
1621 #[inline]
1622 unsafe fn decode(
1623 &mut self,
1624 decoder: &mut fidl::encoding::Decoder<'_, D>,
1625 offset: usize,
1626 _depth: fidl::encoding::Depth,
1627 ) -> fidl::Result<()> {
1628 decoder.debug_check_bounds::<Self>(offset);
1629 fidl::decode!(OptionCode, D, &mut self.code, decoder, offset + 0, _depth)?;
1631 Ok(())
1632 }
1633 }
1634
1635 impl fidl::encoding::ValueTypeMarker for ServerGetParameterRequest {
1636 type Borrowed<'a> = &'a Self;
1637 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1638 value
1639 }
1640 }
1641
1642 unsafe impl fidl::encoding::TypeMarker for ServerGetParameterRequest {
1643 type Owned = Self;
1644
1645 #[inline(always)]
1646 fn inline_align(_context: fidl::encoding::Context) -> usize {
1647 4
1648 }
1649
1650 #[inline(always)]
1651 fn inline_size(_context: fidl::encoding::Context) -> usize {
1652 4
1653 }
1654 }
1655
1656 unsafe impl<D: fidl::encoding::ResourceDialect>
1657 fidl::encoding::Encode<ServerGetParameterRequest, D> for &ServerGetParameterRequest
1658 {
1659 #[inline]
1660 unsafe fn encode(
1661 self,
1662 encoder: &mut fidl::encoding::Encoder<'_, D>,
1663 offset: usize,
1664 _depth: fidl::encoding::Depth,
1665 ) -> fidl::Result<()> {
1666 encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
1667 fidl::encoding::Encode::<ServerGetParameterRequest, D>::encode(
1669 (<ParameterName as fidl::encoding::ValueTypeMarker>::borrow(&self.name),),
1670 encoder,
1671 offset,
1672 _depth,
1673 )
1674 }
1675 }
1676 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ParameterName, D>>
1677 fidl::encoding::Encode<ServerGetParameterRequest, D> for (T0,)
1678 {
1679 #[inline]
1680 unsafe fn encode(
1681 self,
1682 encoder: &mut fidl::encoding::Encoder<'_, D>,
1683 offset: usize,
1684 depth: fidl::encoding::Depth,
1685 ) -> fidl::Result<()> {
1686 encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
1687 self.0.encode(encoder, offset + 0, depth)?;
1691 Ok(())
1692 }
1693 }
1694
1695 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1696 for ServerGetParameterRequest
1697 {
1698 #[inline(always)]
1699 fn new_empty() -> Self {
1700 Self { name: fidl::new_empty!(ParameterName, D) }
1701 }
1702
1703 #[inline]
1704 unsafe fn decode(
1705 &mut self,
1706 decoder: &mut fidl::encoding::Decoder<'_, D>,
1707 offset: usize,
1708 _depth: fidl::encoding::Depth,
1709 ) -> fidl::Result<()> {
1710 decoder.debug_check_bounds::<Self>(offset);
1711 fidl::decode!(ParameterName, D, &mut self.name, decoder, offset + 0, _depth)?;
1713 Ok(())
1714 }
1715 }
1716
1717 impl fidl::encoding::ValueTypeMarker for ServerIsServingResponse {
1718 type Borrowed<'a> = &'a Self;
1719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1720 value
1721 }
1722 }
1723
1724 unsafe impl fidl::encoding::TypeMarker for ServerIsServingResponse {
1725 type Owned = Self;
1726
1727 #[inline(always)]
1728 fn inline_align(_context: fidl::encoding::Context) -> usize {
1729 1
1730 }
1731
1732 #[inline(always)]
1733 fn inline_size(_context: fidl::encoding::Context) -> usize {
1734 1
1735 }
1736 }
1737
1738 unsafe impl<D: fidl::encoding::ResourceDialect>
1739 fidl::encoding::Encode<ServerIsServingResponse, D> for &ServerIsServingResponse
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::<ServerIsServingResponse>(offset);
1749 fidl::encoding::Encode::<ServerIsServingResponse, D>::encode(
1751 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
1752 encoder,
1753 offset,
1754 _depth,
1755 )
1756 }
1757 }
1758 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1759 fidl::encoding::Encode<ServerIsServingResponse, D> for (T0,)
1760 {
1761 #[inline]
1762 unsafe fn encode(
1763 self,
1764 encoder: &mut fidl::encoding::Encoder<'_, D>,
1765 offset: usize,
1766 depth: fidl::encoding::Depth,
1767 ) -> fidl::Result<()> {
1768 encoder.debug_check_bounds::<ServerIsServingResponse>(offset);
1769 self.0.encode(encoder, offset + 0, depth)?;
1773 Ok(())
1774 }
1775 }
1776
1777 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1778 for ServerIsServingResponse
1779 {
1780 #[inline(always)]
1781 fn new_empty() -> Self {
1782 Self { enabled: fidl::new_empty!(bool, D) }
1783 }
1784
1785 #[inline]
1786 unsafe fn decode(
1787 &mut self,
1788 decoder: &mut fidl::encoding::Decoder<'_, D>,
1789 offset: usize,
1790 _depth: fidl::encoding::Depth,
1791 ) -> fidl::Result<()> {
1792 decoder.debug_check_bounds::<Self>(offset);
1793 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
1795 Ok(())
1796 }
1797 }
1798
1799 impl fidl::encoding::ValueTypeMarker for ServerSetOptionRequest {
1800 type Borrowed<'a> = &'a Self;
1801 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1802 value
1803 }
1804 }
1805
1806 unsafe impl fidl::encoding::TypeMarker for ServerSetOptionRequest {
1807 type Owned = Self;
1808
1809 #[inline(always)]
1810 fn inline_align(_context: fidl::encoding::Context) -> usize {
1811 8
1812 }
1813
1814 #[inline(always)]
1815 fn inline_size(_context: fidl::encoding::Context) -> usize {
1816 16
1817 }
1818 }
1819
1820 unsafe impl<D: fidl::encoding::ResourceDialect>
1821 fidl::encoding::Encode<ServerSetOptionRequest, D> for &ServerSetOptionRequest
1822 {
1823 #[inline]
1824 unsafe fn encode(
1825 self,
1826 encoder: &mut fidl::encoding::Encoder<'_, D>,
1827 offset: usize,
1828 _depth: fidl::encoding::Depth,
1829 ) -> fidl::Result<()> {
1830 encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
1831 fidl::encoding::Encode::<ServerSetOptionRequest, D>::encode(
1833 (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1834 encoder,
1835 offset,
1836 _depth,
1837 )
1838 }
1839 }
1840 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
1841 fidl::encoding::Encode<ServerSetOptionRequest, D> for (T0,)
1842 {
1843 #[inline]
1844 unsafe fn encode(
1845 self,
1846 encoder: &mut fidl::encoding::Encoder<'_, D>,
1847 offset: usize,
1848 depth: fidl::encoding::Depth,
1849 ) -> fidl::Result<()> {
1850 encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
1851 self.0.encode(encoder, offset + 0, depth)?;
1855 Ok(())
1856 }
1857 }
1858
1859 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1860 for ServerSetOptionRequest
1861 {
1862 #[inline(always)]
1863 fn new_empty() -> Self {
1864 Self { value: fidl::new_empty!(Option_, D) }
1865 }
1866
1867 #[inline]
1868 unsafe fn decode(
1869 &mut self,
1870 decoder: &mut fidl::encoding::Decoder<'_, D>,
1871 offset: usize,
1872 _depth: fidl::encoding::Depth,
1873 ) -> fidl::Result<()> {
1874 decoder.debug_check_bounds::<Self>(offset);
1875 fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
1877 Ok(())
1878 }
1879 }
1880
1881 impl fidl::encoding::ValueTypeMarker for ServerSetParameterRequest {
1882 type Borrowed<'a> = &'a Self;
1883 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1884 value
1885 }
1886 }
1887
1888 unsafe impl fidl::encoding::TypeMarker for ServerSetParameterRequest {
1889 type Owned = Self;
1890
1891 #[inline(always)]
1892 fn inline_align(_context: fidl::encoding::Context) -> usize {
1893 8
1894 }
1895
1896 #[inline(always)]
1897 fn inline_size(_context: fidl::encoding::Context) -> usize {
1898 16
1899 }
1900 }
1901
1902 unsafe impl<D: fidl::encoding::ResourceDialect>
1903 fidl::encoding::Encode<ServerSetParameterRequest, D> for &ServerSetParameterRequest
1904 {
1905 #[inline]
1906 unsafe fn encode(
1907 self,
1908 encoder: &mut fidl::encoding::Encoder<'_, D>,
1909 offset: usize,
1910 _depth: fidl::encoding::Depth,
1911 ) -> fidl::Result<()> {
1912 encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
1913 fidl::encoding::Encode::<ServerSetParameterRequest, D>::encode(
1915 (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1916 encoder,
1917 offset,
1918 _depth,
1919 )
1920 }
1921 }
1922 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
1923 fidl::encoding::Encode<ServerSetParameterRequest, D> for (T0,)
1924 {
1925 #[inline]
1926 unsafe fn encode(
1927 self,
1928 encoder: &mut fidl::encoding::Encoder<'_, D>,
1929 offset: usize,
1930 depth: fidl::encoding::Depth,
1931 ) -> fidl::Result<()> {
1932 encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
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 ServerSetParameterRequest
1943 {
1944 #[inline(always)]
1945 fn new_empty() -> Self {
1946 Self { value: fidl::new_empty!(Parameter, D) }
1947 }
1948
1949 #[inline]
1950 unsafe fn decode(
1951 &mut self,
1952 decoder: &mut fidl::encoding::Decoder<'_, D>,
1953 offset: usize,
1954 _depth: fidl::encoding::Depth,
1955 ) -> fidl::Result<()> {
1956 decoder.debug_check_bounds::<Self>(offset);
1957 fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
1959 Ok(())
1960 }
1961 }
1962
1963 impl fidl::encoding::ValueTypeMarker for ServerGetOptionResponse {
1964 type Borrowed<'a> = &'a Self;
1965 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1966 value
1967 }
1968 }
1969
1970 unsafe impl fidl::encoding::TypeMarker for ServerGetOptionResponse {
1971 type Owned = Self;
1972
1973 #[inline(always)]
1974 fn inline_align(_context: fidl::encoding::Context) -> usize {
1975 8
1976 }
1977
1978 #[inline(always)]
1979 fn inline_size(_context: fidl::encoding::Context) -> usize {
1980 16
1981 }
1982 }
1983
1984 unsafe impl<D: fidl::encoding::ResourceDialect>
1985 fidl::encoding::Encode<ServerGetOptionResponse, D> for &ServerGetOptionResponse
1986 {
1987 #[inline]
1988 unsafe fn encode(
1989 self,
1990 encoder: &mut fidl::encoding::Encoder<'_, D>,
1991 offset: usize,
1992 _depth: fidl::encoding::Depth,
1993 ) -> fidl::Result<()> {
1994 encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
1995 fidl::encoding::Encode::<ServerGetOptionResponse, D>::encode(
1997 (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1998 encoder,
1999 offset,
2000 _depth,
2001 )
2002 }
2003 }
2004 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
2005 fidl::encoding::Encode<ServerGetOptionResponse, D> for (T0,)
2006 {
2007 #[inline]
2008 unsafe fn encode(
2009 self,
2010 encoder: &mut fidl::encoding::Encoder<'_, D>,
2011 offset: usize,
2012 depth: fidl::encoding::Depth,
2013 ) -> fidl::Result<()> {
2014 encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
2015 self.0.encode(encoder, offset + 0, depth)?;
2019 Ok(())
2020 }
2021 }
2022
2023 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2024 for ServerGetOptionResponse
2025 {
2026 #[inline(always)]
2027 fn new_empty() -> Self {
2028 Self { value: fidl::new_empty!(Option_, D) }
2029 }
2030
2031 #[inline]
2032 unsafe fn decode(
2033 &mut self,
2034 decoder: &mut fidl::encoding::Decoder<'_, D>,
2035 offset: usize,
2036 _depth: fidl::encoding::Depth,
2037 ) -> fidl::Result<()> {
2038 decoder.debug_check_bounds::<Self>(offset);
2039 fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
2041 Ok(())
2042 }
2043 }
2044
2045 impl fidl::encoding::ValueTypeMarker for ServerGetParameterResponse {
2046 type Borrowed<'a> = &'a Self;
2047 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2048 value
2049 }
2050 }
2051
2052 unsafe impl fidl::encoding::TypeMarker for ServerGetParameterResponse {
2053 type Owned = Self;
2054
2055 #[inline(always)]
2056 fn inline_align(_context: fidl::encoding::Context) -> usize {
2057 8
2058 }
2059
2060 #[inline(always)]
2061 fn inline_size(_context: fidl::encoding::Context) -> usize {
2062 16
2063 }
2064 }
2065
2066 unsafe impl<D: fidl::encoding::ResourceDialect>
2067 fidl::encoding::Encode<ServerGetParameterResponse, D> for &ServerGetParameterResponse
2068 {
2069 #[inline]
2070 unsafe fn encode(
2071 self,
2072 encoder: &mut fidl::encoding::Encoder<'_, D>,
2073 offset: usize,
2074 _depth: fidl::encoding::Depth,
2075 ) -> fidl::Result<()> {
2076 encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
2077 fidl::encoding::Encode::<ServerGetParameterResponse, D>::encode(
2079 (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
2080 encoder,
2081 offset,
2082 _depth,
2083 )
2084 }
2085 }
2086 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
2087 fidl::encoding::Encode<ServerGetParameterResponse, D> for (T0,)
2088 {
2089 #[inline]
2090 unsafe fn encode(
2091 self,
2092 encoder: &mut fidl::encoding::Encoder<'_, D>,
2093 offset: usize,
2094 depth: fidl::encoding::Depth,
2095 ) -> fidl::Result<()> {
2096 encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
2097 self.0.encode(encoder, offset + 0, depth)?;
2101 Ok(())
2102 }
2103 }
2104
2105 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2106 for ServerGetParameterResponse
2107 {
2108 #[inline(always)]
2109 fn new_empty() -> Self {
2110 Self { value: fidl::new_empty!(Parameter, D) }
2111 }
2112
2113 #[inline]
2114 unsafe fn decode(
2115 &mut self,
2116 decoder: &mut fidl::encoding::Decoder<'_, D>,
2117 offset: usize,
2118 _depth: fidl::encoding::Depth,
2119 ) -> fidl::Result<()> {
2120 decoder.debug_check_bounds::<Self>(offset);
2121 fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
2123 Ok(())
2124 }
2125 }
2126
2127 impl fidl::encoding::ValueTypeMarker for ServerListOptionsResponse {
2128 type Borrowed<'a> = &'a Self;
2129 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2130 value
2131 }
2132 }
2133
2134 unsafe impl fidl::encoding::TypeMarker for ServerListOptionsResponse {
2135 type Owned = Self;
2136
2137 #[inline(always)]
2138 fn inline_align(_context: fidl::encoding::Context) -> usize {
2139 8
2140 }
2141
2142 #[inline(always)]
2143 fn inline_size(_context: fidl::encoding::Context) -> usize {
2144 16
2145 }
2146 }
2147
2148 unsafe impl<D: fidl::encoding::ResourceDialect>
2149 fidl::encoding::Encode<ServerListOptionsResponse, D> for &ServerListOptionsResponse
2150 {
2151 #[inline]
2152 unsafe fn encode(
2153 self,
2154 encoder: &mut fidl::encoding::Encoder<'_, D>,
2155 offset: usize,
2156 _depth: fidl::encoding::Depth,
2157 ) -> fidl::Result<()> {
2158 encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
2159 fidl::encoding::Encode::<ServerListOptionsResponse, D>::encode(
2161 (
2162 <fidl::encoding::Vector<Option_, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2163 ),
2164 encoder, offset, _depth
2165 )
2166 }
2167 }
2168 unsafe impl<
2169 D: fidl::encoding::ResourceDialect,
2170 T0: fidl::encoding::Encode<fidl::encoding::Vector<Option_, 256>, D>,
2171 > fidl::encoding::Encode<ServerListOptionsResponse, D> for (T0,)
2172 {
2173 #[inline]
2174 unsafe fn encode(
2175 self,
2176 encoder: &mut fidl::encoding::Encoder<'_, D>,
2177 offset: usize,
2178 depth: fidl::encoding::Depth,
2179 ) -> fidl::Result<()> {
2180 encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
2181 self.0.encode(encoder, offset + 0, depth)?;
2185 Ok(())
2186 }
2187 }
2188
2189 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2190 for ServerListOptionsResponse
2191 {
2192 #[inline(always)]
2193 fn new_empty() -> Self {
2194 Self { options: fidl::new_empty!(fidl::encoding::Vector<Option_, 256>, D) }
2195 }
2196
2197 #[inline]
2198 unsafe fn decode(
2199 &mut self,
2200 decoder: &mut fidl::encoding::Decoder<'_, D>,
2201 offset: usize,
2202 _depth: fidl::encoding::Depth,
2203 ) -> fidl::Result<()> {
2204 decoder.debug_check_bounds::<Self>(offset);
2205 fidl::decode!(fidl::encoding::Vector<Option_, 256>, D, &mut self.options, decoder, offset + 0, _depth)?;
2207 Ok(())
2208 }
2209 }
2210
2211 impl fidl::encoding::ValueTypeMarker for ServerListParametersResponse {
2212 type Borrowed<'a> = &'a Self;
2213 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2214 value
2215 }
2216 }
2217
2218 unsafe impl fidl::encoding::TypeMarker for ServerListParametersResponse {
2219 type Owned = Self;
2220
2221 #[inline(always)]
2222 fn inline_align(_context: fidl::encoding::Context) -> usize {
2223 8
2224 }
2225
2226 #[inline(always)]
2227 fn inline_size(_context: fidl::encoding::Context) -> usize {
2228 16
2229 }
2230 }
2231
2232 unsafe impl<D: fidl::encoding::ResourceDialect>
2233 fidl::encoding::Encode<ServerListParametersResponse, D> for &ServerListParametersResponse
2234 {
2235 #[inline]
2236 unsafe fn encode(
2237 self,
2238 encoder: &mut fidl::encoding::Encoder<'_, D>,
2239 offset: usize,
2240 _depth: fidl::encoding::Depth,
2241 ) -> fidl::Result<()> {
2242 encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
2243 fidl::encoding::Encode::<ServerListParametersResponse, D>::encode(
2245 (
2246 <fidl::encoding::Vector<Parameter, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
2247 ),
2248 encoder, offset, _depth
2249 )
2250 }
2251 }
2252 unsafe impl<
2253 D: fidl::encoding::ResourceDialect,
2254 T0: fidl::encoding::Encode<fidl::encoding::Vector<Parameter, 256>, D>,
2255 > fidl::encoding::Encode<ServerListParametersResponse, D> for (T0,)
2256 {
2257 #[inline]
2258 unsafe fn encode(
2259 self,
2260 encoder: &mut fidl::encoding::Encoder<'_, D>,
2261 offset: usize,
2262 depth: fidl::encoding::Depth,
2263 ) -> fidl::Result<()> {
2264 encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
2265 self.0.encode(encoder, offset + 0, depth)?;
2269 Ok(())
2270 }
2271 }
2272
2273 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2274 for ServerListParametersResponse
2275 {
2276 #[inline(always)]
2277 fn new_empty() -> Self {
2278 Self { parameters: fidl::new_empty!(fidl::encoding::Vector<Parameter, 256>, D) }
2279 }
2280
2281 #[inline]
2282 unsafe fn decode(
2283 &mut self,
2284 decoder: &mut fidl::encoding::Decoder<'_, D>,
2285 offset: usize,
2286 _depth: fidl::encoding::Depth,
2287 ) -> fidl::Result<()> {
2288 decoder.debug_check_bounds::<Self>(offset);
2289 fidl::decode!(fidl::encoding::Vector<Parameter, 256>, D, &mut self.parameters, decoder, offset + 0, _depth)?;
2291 Ok(())
2292 }
2293 }
2294
2295 impl AddressPool {
2296 #[inline(always)]
2297 fn max_ordinal_present(&self) -> u64 {
2298 if let Some(_) = self.range_stop {
2299 return 3;
2300 }
2301 if let Some(_) = self.range_start {
2302 return 2;
2303 }
2304 if let Some(_) = self.prefix_length {
2305 return 1;
2306 }
2307 0
2308 }
2309 }
2310
2311 impl fidl::encoding::ValueTypeMarker for AddressPool {
2312 type Borrowed<'a> = &'a Self;
2313 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2314 value
2315 }
2316 }
2317
2318 unsafe impl fidl::encoding::TypeMarker for AddressPool {
2319 type Owned = Self;
2320
2321 #[inline(always)]
2322 fn inline_align(_context: fidl::encoding::Context) -> usize {
2323 8
2324 }
2325
2326 #[inline(always)]
2327 fn inline_size(_context: fidl::encoding::Context) -> usize {
2328 16
2329 }
2330 }
2331
2332 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressPool, D>
2333 for &AddressPool
2334 {
2335 unsafe fn encode(
2336 self,
2337 encoder: &mut fidl::encoding::Encoder<'_, D>,
2338 offset: usize,
2339 mut depth: fidl::encoding::Depth,
2340 ) -> fidl::Result<()> {
2341 encoder.debug_check_bounds::<AddressPool>(offset);
2342 let max_ordinal: u64 = self.max_ordinal_present();
2344 encoder.write_num(max_ordinal, offset);
2345 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2346 if max_ordinal == 0 {
2348 return Ok(());
2349 }
2350 depth.increment()?;
2351 let envelope_size = 8;
2352 let bytes_len = max_ordinal as usize * envelope_size;
2353 #[allow(unused_variables)]
2354 let offset = encoder.out_of_line_offset(bytes_len);
2355 let mut _prev_end_offset: usize = 0;
2356 if 1 > max_ordinal {
2357 return Ok(());
2358 }
2359
2360 let cur_offset: usize = (1 - 1) * envelope_size;
2363
2364 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2366
2367 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2372 self.prefix_length.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2373 encoder,
2374 offset + cur_offset,
2375 depth,
2376 )?;
2377
2378 _prev_end_offset = cur_offset + envelope_size;
2379 if 2 > max_ordinal {
2380 return Ok(());
2381 }
2382
2383 let cur_offset: usize = (2 - 1) * envelope_size;
2386
2387 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2389
2390 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
2395 self.range_start.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
2396 encoder, offset + cur_offset, depth
2397 )?;
2398
2399 _prev_end_offset = cur_offset + envelope_size;
2400 if 3 > max_ordinal {
2401 return Ok(());
2402 }
2403
2404 let cur_offset: usize = (3 - 1) * envelope_size;
2407
2408 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
2416 self.range_stop.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
2417 encoder, offset + cur_offset, depth
2418 )?;
2419
2420 _prev_end_offset = cur_offset + envelope_size;
2421
2422 Ok(())
2423 }
2424 }
2425
2426 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressPool {
2427 #[inline(always)]
2428 fn new_empty() -> Self {
2429 Self::default()
2430 }
2431
2432 unsafe fn decode(
2433 &mut self,
2434 decoder: &mut fidl::encoding::Decoder<'_, D>,
2435 offset: usize,
2436 mut depth: fidl::encoding::Depth,
2437 ) -> fidl::Result<()> {
2438 decoder.debug_check_bounds::<Self>(offset);
2439 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2440 None => return Err(fidl::Error::NotNullable),
2441 Some(len) => len,
2442 };
2443 if len == 0 {
2445 return Ok(());
2446 };
2447 depth.increment()?;
2448 let envelope_size = 8;
2449 let bytes_len = len * envelope_size;
2450 let offset = decoder.out_of_line_offset(bytes_len)?;
2451 let mut _next_ordinal_to_read = 0;
2453 let mut next_offset = offset;
2454 let end_offset = offset + bytes_len;
2455 _next_ordinal_to_read += 1;
2456 if next_offset >= end_offset {
2457 return Ok(());
2458 }
2459
2460 while _next_ordinal_to_read < 1 {
2462 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2463 _next_ordinal_to_read += 1;
2464 next_offset += envelope_size;
2465 }
2466
2467 let next_out_of_line = decoder.next_out_of_line();
2468 let handles_before = decoder.remaining_handles();
2469 if let Some((inlined, num_bytes, num_handles)) =
2470 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2471 {
2472 let member_inline_size =
2473 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2474 if inlined != (member_inline_size <= 4) {
2475 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2476 }
2477 let inner_offset;
2478 let mut inner_depth = depth.clone();
2479 if inlined {
2480 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2481 inner_offset = next_offset;
2482 } else {
2483 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2484 inner_depth.increment()?;
2485 }
2486 let val_ref = self.prefix_length.get_or_insert_with(|| fidl::new_empty!(u8, D));
2487 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2488 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2489 {
2490 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2491 }
2492 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2493 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2494 }
2495 }
2496
2497 next_offset += envelope_size;
2498 _next_ordinal_to_read += 1;
2499 if next_offset >= end_offset {
2500 return Ok(());
2501 }
2502
2503 while _next_ordinal_to_read < 2 {
2505 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2506 _next_ordinal_to_read += 1;
2507 next_offset += envelope_size;
2508 }
2509
2510 let next_out_of_line = decoder.next_out_of_line();
2511 let handles_before = decoder.remaining_handles();
2512 if let Some((inlined, num_bytes, num_handles)) =
2513 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2514 {
2515 let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2516 if inlined != (member_inline_size <= 4) {
2517 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2518 }
2519 let inner_offset;
2520 let mut inner_depth = depth.clone();
2521 if inlined {
2522 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2523 inner_offset = next_offset;
2524 } else {
2525 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2526 inner_depth.increment()?;
2527 }
2528 let val_ref = self.range_start.get_or_insert_with(|| {
2529 fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
2530 });
2531 fidl::decode!(
2532 fidl_fuchsia_net__common::Ipv4Address,
2533 D,
2534 val_ref,
2535 decoder,
2536 inner_offset,
2537 inner_depth
2538 )?;
2539 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2540 {
2541 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2542 }
2543 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2544 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2545 }
2546 }
2547
2548 next_offset += envelope_size;
2549 _next_ordinal_to_read += 1;
2550 if next_offset >= end_offset {
2551 return Ok(());
2552 }
2553
2554 while _next_ordinal_to_read < 3 {
2556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2557 _next_ordinal_to_read += 1;
2558 next_offset += envelope_size;
2559 }
2560
2561 let next_out_of_line = decoder.next_out_of_line();
2562 let handles_before = decoder.remaining_handles();
2563 if let Some((inlined, num_bytes, num_handles)) =
2564 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2565 {
2566 let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2567 if inlined != (member_inline_size <= 4) {
2568 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2569 }
2570 let inner_offset;
2571 let mut inner_depth = depth.clone();
2572 if inlined {
2573 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2574 inner_offset = next_offset;
2575 } else {
2576 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2577 inner_depth.increment()?;
2578 }
2579 let val_ref = self.range_stop.get_or_insert_with(|| {
2580 fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
2581 });
2582 fidl::decode!(
2583 fidl_fuchsia_net__common::Ipv4Address,
2584 D,
2585 val_ref,
2586 decoder,
2587 inner_offset,
2588 inner_depth
2589 )?;
2590 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2591 {
2592 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2593 }
2594 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2595 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2596 }
2597 }
2598
2599 next_offset += envelope_size;
2600
2601 while next_offset < end_offset {
2603 _next_ordinal_to_read += 1;
2604 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2605 next_offset += envelope_size;
2606 }
2607
2608 Ok(())
2609 }
2610 }
2611
2612 impl ConfigurationToRequest {
2613 #[inline(always)]
2614 fn max_ordinal_present(&self) -> u64 {
2615 if let Some(_) = self.dns_servers {
2616 return 2;
2617 }
2618 if let Some(_) = self.routers {
2619 return 1;
2620 }
2621 0
2622 }
2623 }
2624
2625 impl fidl::encoding::ValueTypeMarker for ConfigurationToRequest {
2626 type Borrowed<'a> = &'a Self;
2627 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2628 value
2629 }
2630 }
2631
2632 unsafe impl fidl::encoding::TypeMarker for ConfigurationToRequest {
2633 type Owned = Self;
2634
2635 #[inline(always)]
2636 fn inline_align(_context: fidl::encoding::Context) -> usize {
2637 8
2638 }
2639
2640 #[inline(always)]
2641 fn inline_size(_context: fidl::encoding::Context) -> usize {
2642 16
2643 }
2644 }
2645
2646 unsafe impl<D: fidl::encoding::ResourceDialect>
2647 fidl::encoding::Encode<ConfigurationToRequest, D> for &ConfigurationToRequest
2648 {
2649 unsafe fn encode(
2650 self,
2651 encoder: &mut fidl::encoding::Encoder<'_, D>,
2652 offset: usize,
2653 mut depth: fidl::encoding::Depth,
2654 ) -> fidl::Result<()> {
2655 encoder.debug_check_bounds::<ConfigurationToRequest>(offset);
2656 let max_ordinal: u64 = self.max_ordinal_present();
2658 encoder.write_num(max_ordinal, offset);
2659 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2660 if max_ordinal == 0 {
2662 return Ok(());
2663 }
2664 depth.increment()?;
2665 let envelope_size = 8;
2666 let bytes_len = max_ordinal as usize * envelope_size;
2667 #[allow(unused_variables)]
2668 let offset = encoder.out_of_line_offset(bytes_len);
2669 let mut _prev_end_offset: usize = 0;
2670 if 1 > max_ordinal {
2671 return Ok(());
2672 }
2673
2674 let cur_offset: usize = (1 - 1) * envelope_size;
2677
2678 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2680
2681 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2686 self.routers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2687 encoder,
2688 offset + cur_offset,
2689 depth,
2690 )?;
2691
2692 _prev_end_offset = cur_offset + envelope_size;
2693 if 2 > max_ordinal {
2694 return Ok(());
2695 }
2696
2697 let cur_offset: usize = (2 - 1) * envelope_size;
2700
2701 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2703
2704 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2709 self.dns_servers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2710 encoder,
2711 offset + cur_offset,
2712 depth,
2713 )?;
2714
2715 _prev_end_offset = cur_offset + envelope_size;
2716
2717 Ok(())
2718 }
2719 }
2720
2721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2722 for ConfigurationToRequest
2723 {
2724 #[inline(always)]
2725 fn new_empty() -> Self {
2726 Self::default()
2727 }
2728
2729 unsafe fn decode(
2730 &mut self,
2731 decoder: &mut fidl::encoding::Decoder<'_, D>,
2732 offset: usize,
2733 mut depth: fidl::encoding::Depth,
2734 ) -> fidl::Result<()> {
2735 decoder.debug_check_bounds::<Self>(offset);
2736 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2737 None => return Err(fidl::Error::NotNullable),
2738 Some(len) => len,
2739 };
2740 if len == 0 {
2742 return Ok(());
2743 };
2744 depth.increment()?;
2745 let envelope_size = 8;
2746 let bytes_len = len * envelope_size;
2747 let offset = decoder.out_of_line_offset(bytes_len)?;
2748 let mut _next_ordinal_to_read = 0;
2750 let mut next_offset = offset;
2751 let end_offset = offset + bytes_len;
2752 _next_ordinal_to_read += 1;
2753 if next_offset >= end_offset {
2754 return Ok(());
2755 }
2756
2757 while _next_ordinal_to_read < 1 {
2759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2760 _next_ordinal_to_read += 1;
2761 next_offset += envelope_size;
2762 }
2763
2764 let next_out_of_line = decoder.next_out_of_line();
2765 let handles_before = decoder.remaining_handles();
2766 if let Some((inlined, num_bytes, num_handles)) =
2767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2768 {
2769 let member_inline_size =
2770 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2771 if inlined != (member_inline_size <= 4) {
2772 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2773 }
2774 let inner_offset;
2775 let mut inner_depth = depth.clone();
2776 if inlined {
2777 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2778 inner_offset = next_offset;
2779 } else {
2780 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2781 inner_depth.increment()?;
2782 }
2783 let val_ref = self.routers.get_or_insert_with(|| fidl::new_empty!(bool, D));
2784 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2785 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2786 {
2787 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2788 }
2789 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2790 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2791 }
2792 }
2793
2794 next_offset += envelope_size;
2795 _next_ordinal_to_read += 1;
2796 if next_offset >= end_offset {
2797 return Ok(());
2798 }
2799
2800 while _next_ordinal_to_read < 2 {
2802 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2803 _next_ordinal_to_read += 1;
2804 next_offset += envelope_size;
2805 }
2806
2807 let next_out_of_line = decoder.next_out_of_line();
2808 let handles_before = decoder.remaining_handles();
2809 if let Some((inlined, num_bytes, num_handles)) =
2810 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2811 {
2812 let member_inline_size =
2813 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2814 if inlined != (member_inline_size <= 4) {
2815 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2816 }
2817 let inner_offset;
2818 let mut inner_depth = depth.clone();
2819 if inlined {
2820 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2821 inner_offset = next_offset;
2822 } else {
2823 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2824 inner_depth.increment()?;
2825 }
2826 let val_ref = self.dns_servers.get_or_insert_with(|| fidl::new_empty!(bool, D));
2827 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2828 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2829 {
2830 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2831 }
2832 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2833 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2834 }
2835 }
2836
2837 next_offset += envelope_size;
2838
2839 while next_offset < end_offset {
2841 _next_ordinal_to_read += 1;
2842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2843 next_offset += envelope_size;
2844 }
2845
2846 Ok(())
2847 }
2848 }
2849
2850 impl LeaseLength {
2851 #[inline(always)]
2852 fn max_ordinal_present(&self) -> u64 {
2853 if let Some(_) = self.max {
2854 return 2;
2855 }
2856 if let Some(_) = self.default {
2857 return 1;
2858 }
2859 0
2860 }
2861 }
2862
2863 impl fidl::encoding::ValueTypeMarker for LeaseLength {
2864 type Borrowed<'a> = &'a Self;
2865 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2866 value
2867 }
2868 }
2869
2870 unsafe impl fidl::encoding::TypeMarker for LeaseLength {
2871 type Owned = Self;
2872
2873 #[inline(always)]
2874 fn inline_align(_context: fidl::encoding::Context) -> usize {
2875 8
2876 }
2877
2878 #[inline(always)]
2879 fn inline_size(_context: fidl::encoding::Context) -> usize {
2880 16
2881 }
2882 }
2883
2884 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaseLength, D>
2885 for &LeaseLength
2886 {
2887 unsafe fn encode(
2888 self,
2889 encoder: &mut fidl::encoding::Encoder<'_, D>,
2890 offset: usize,
2891 mut depth: fidl::encoding::Depth,
2892 ) -> fidl::Result<()> {
2893 encoder.debug_check_bounds::<LeaseLength>(offset);
2894 let max_ordinal: u64 = self.max_ordinal_present();
2896 encoder.write_num(max_ordinal, offset);
2897 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2898 if max_ordinal == 0 {
2900 return Ok(());
2901 }
2902 depth.increment()?;
2903 let envelope_size = 8;
2904 let bytes_len = max_ordinal as usize * envelope_size;
2905 #[allow(unused_variables)]
2906 let offset = encoder.out_of_line_offset(bytes_len);
2907 let mut _prev_end_offset: usize = 0;
2908 if 1 > max_ordinal {
2909 return Ok(());
2910 }
2911
2912 let cur_offset: usize = (1 - 1) * envelope_size;
2915
2916 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2918
2919 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2924 self.default.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2925 encoder,
2926 offset + cur_offset,
2927 depth,
2928 )?;
2929
2930 _prev_end_offset = cur_offset + envelope_size;
2931 if 2 > max_ordinal {
2932 return Ok(());
2933 }
2934
2935 let cur_offset: usize = (2 - 1) * envelope_size;
2938
2939 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2941
2942 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2947 self.max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2948 encoder,
2949 offset + cur_offset,
2950 depth,
2951 )?;
2952
2953 _prev_end_offset = cur_offset + envelope_size;
2954
2955 Ok(())
2956 }
2957 }
2958
2959 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaseLength {
2960 #[inline(always)]
2961 fn new_empty() -> Self {
2962 Self::default()
2963 }
2964
2965 unsafe fn decode(
2966 &mut self,
2967 decoder: &mut fidl::encoding::Decoder<'_, D>,
2968 offset: usize,
2969 mut depth: fidl::encoding::Depth,
2970 ) -> fidl::Result<()> {
2971 decoder.debug_check_bounds::<Self>(offset);
2972 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2973 None => return Err(fidl::Error::NotNullable),
2974 Some(len) => len,
2975 };
2976 if len == 0 {
2978 return Ok(());
2979 };
2980 depth.increment()?;
2981 let envelope_size = 8;
2982 let bytes_len = len * envelope_size;
2983 let offset = decoder.out_of_line_offset(bytes_len)?;
2984 let mut _next_ordinal_to_read = 0;
2986 let mut next_offset = offset;
2987 let end_offset = offset + bytes_len;
2988 _next_ordinal_to_read += 1;
2989 if next_offset >= end_offset {
2990 return Ok(());
2991 }
2992
2993 while _next_ordinal_to_read < 1 {
2995 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2996 _next_ordinal_to_read += 1;
2997 next_offset += envelope_size;
2998 }
2999
3000 let next_out_of_line = decoder.next_out_of_line();
3001 let handles_before = decoder.remaining_handles();
3002 if let Some((inlined, num_bytes, num_handles)) =
3003 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3004 {
3005 let member_inline_size =
3006 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3007 if inlined != (member_inline_size <= 4) {
3008 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3009 }
3010 let inner_offset;
3011 let mut inner_depth = depth.clone();
3012 if inlined {
3013 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3014 inner_offset = next_offset;
3015 } else {
3016 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3017 inner_depth.increment()?;
3018 }
3019 let val_ref = self.default.get_or_insert_with(|| fidl::new_empty!(u32, D));
3020 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3021 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3022 {
3023 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3024 }
3025 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3026 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3027 }
3028 }
3029
3030 next_offset += envelope_size;
3031 _next_ordinal_to_read += 1;
3032 if next_offset >= end_offset {
3033 return Ok(());
3034 }
3035
3036 while _next_ordinal_to_read < 2 {
3038 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3039 _next_ordinal_to_read += 1;
3040 next_offset += envelope_size;
3041 }
3042
3043 let next_out_of_line = decoder.next_out_of_line();
3044 let handles_before = decoder.remaining_handles();
3045 if let Some((inlined, num_bytes, num_handles)) =
3046 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3047 {
3048 let member_inline_size =
3049 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3050 if inlined != (member_inline_size <= 4) {
3051 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3052 }
3053 let inner_offset;
3054 let mut inner_depth = depth.clone();
3055 if inlined {
3056 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3057 inner_offset = next_offset;
3058 } else {
3059 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3060 inner_depth.increment()?;
3061 }
3062 let val_ref = self.max.get_or_insert_with(|| fidl::new_empty!(u32, D));
3063 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3064 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3065 {
3066 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3067 }
3068 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3069 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3070 }
3071 }
3072
3073 next_offset += envelope_size;
3074
3075 while next_offset < end_offset {
3077 _next_ordinal_to_read += 1;
3078 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3079 next_offset += envelope_size;
3080 }
3081
3082 Ok(())
3083 }
3084 }
3085
3086 impl NewClientParams {
3087 #[inline(always)]
3088 fn max_ordinal_present(&self) -> u64 {
3089 if let Some(_) = self.request_ip_address {
3090 return 2;
3091 }
3092 if let Some(_) = self.configuration_to_request {
3093 return 1;
3094 }
3095 0
3096 }
3097 }
3098
3099 impl fidl::encoding::ValueTypeMarker for NewClientParams {
3100 type Borrowed<'a> = &'a Self;
3101 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3102 value
3103 }
3104 }
3105
3106 unsafe impl fidl::encoding::TypeMarker for NewClientParams {
3107 type Owned = Self;
3108
3109 #[inline(always)]
3110 fn inline_align(_context: fidl::encoding::Context) -> usize {
3111 8
3112 }
3113
3114 #[inline(always)]
3115 fn inline_size(_context: fidl::encoding::Context) -> usize {
3116 16
3117 }
3118 }
3119
3120 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NewClientParams, D>
3121 for &NewClientParams
3122 {
3123 unsafe fn encode(
3124 self,
3125 encoder: &mut fidl::encoding::Encoder<'_, D>,
3126 offset: usize,
3127 mut depth: fidl::encoding::Depth,
3128 ) -> fidl::Result<()> {
3129 encoder.debug_check_bounds::<NewClientParams>(offset);
3130 let max_ordinal: u64 = self.max_ordinal_present();
3132 encoder.write_num(max_ordinal, offset);
3133 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3134 if max_ordinal == 0 {
3136 return Ok(());
3137 }
3138 depth.increment()?;
3139 let envelope_size = 8;
3140 let bytes_len = max_ordinal as usize * envelope_size;
3141 #[allow(unused_variables)]
3142 let offset = encoder.out_of_line_offset(bytes_len);
3143 let mut _prev_end_offset: usize = 0;
3144 if 1 > max_ordinal {
3145 return Ok(());
3146 }
3147
3148 let cur_offset: usize = (1 - 1) * envelope_size;
3151
3152 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3154
3155 fidl::encoding::encode_in_envelope_optional::<ConfigurationToRequest, D>(
3160 self.configuration_to_request
3161 .as_ref()
3162 .map(<ConfigurationToRequest as fidl::encoding::ValueTypeMarker>::borrow),
3163 encoder,
3164 offset + cur_offset,
3165 depth,
3166 )?;
3167
3168 _prev_end_offset = cur_offset + envelope_size;
3169 if 2 > max_ordinal {
3170 return Ok(());
3171 }
3172
3173 let cur_offset: usize = (2 - 1) * envelope_size;
3176
3177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3179
3180 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3185 self.request_ip_address
3186 .as_ref()
3187 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3188 encoder,
3189 offset + cur_offset,
3190 depth,
3191 )?;
3192
3193 _prev_end_offset = cur_offset + envelope_size;
3194
3195 Ok(())
3196 }
3197 }
3198
3199 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NewClientParams {
3200 #[inline(always)]
3201 fn new_empty() -> Self {
3202 Self::default()
3203 }
3204
3205 unsafe fn decode(
3206 &mut self,
3207 decoder: &mut fidl::encoding::Decoder<'_, D>,
3208 offset: usize,
3209 mut depth: fidl::encoding::Depth,
3210 ) -> fidl::Result<()> {
3211 decoder.debug_check_bounds::<Self>(offset);
3212 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3213 None => return Err(fidl::Error::NotNullable),
3214 Some(len) => len,
3215 };
3216 if len == 0 {
3218 return Ok(());
3219 };
3220 depth.increment()?;
3221 let envelope_size = 8;
3222 let bytes_len = len * envelope_size;
3223 let offset = decoder.out_of_line_offset(bytes_len)?;
3224 let mut _next_ordinal_to_read = 0;
3226 let mut next_offset = offset;
3227 let end_offset = offset + bytes_len;
3228 _next_ordinal_to_read += 1;
3229 if next_offset >= end_offset {
3230 return Ok(());
3231 }
3232
3233 while _next_ordinal_to_read < 1 {
3235 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3236 _next_ordinal_to_read += 1;
3237 next_offset += envelope_size;
3238 }
3239
3240 let next_out_of_line = decoder.next_out_of_line();
3241 let handles_before = decoder.remaining_handles();
3242 if let Some((inlined, num_bytes, num_handles)) =
3243 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3244 {
3245 let member_inline_size =
3246 <ConfigurationToRequest as fidl::encoding::TypeMarker>::inline_size(
3247 decoder.context,
3248 );
3249 if inlined != (member_inline_size <= 4) {
3250 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3251 }
3252 let inner_offset;
3253 let mut inner_depth = depth.clone();
3254 if inlined {
3255 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3256 inner_offset = next_offset;
3257 } else {
3258 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3259 inner_depth.increment()?;
3260 }
3261 let val_ref = self
3262 .configuration_to_request
3263 .get_or_insert_with(|| fidl::new_empty!(ConfigurationToRequest, D));
3264 fidl::decode!(
3265 ConfigurationToRequest,
3266 D,
3267 val_ref,
3268 decoder,
3269 inner_offset,
3270 inner_depth
3271 )?;
3272 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3273 {
3274 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3275 }
3276 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3277 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3278 }
3279 }
3280
3281 next_offset += envelope_size;
3282 _next_ordinal_to_read += 1;
3283 if next_offset >= end_offset {
3284 return Ok(());
3285 }
3286
3287 while _next_ordinal_to_read < 2 {
3289 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3290 _next_ordinal_to_read += 1;
3291 next_offset += envelope_size;
3292 }
3293
3294 let next_out_of_line = decoder.next_out_of_line();
3295 let handles_before = decoder.remaining_handles();
3296 if let Some((inlined, num_bytes, num_handles)) =
3297 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3298 {
3299 let member_inline_size =
3300 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3301 if inlined != (member_inline_size <= 4) {
3302 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3303 }
3304 let inner_offset;
3305 let mut inner_depth = depth.clone();
3306 if inlined {
3307 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3308 inner_offset = next_offset;
3309 } else {
3310 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3311 inner_depth.increment()?;
3312 }
3313 let val_ref =
3314 self.request_ip_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
3315 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3316 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3317 {
3318 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3319 }
3320 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3321 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3322 }
3323 }
3324
3325 next_offset += envelope_size;
3326
3327 while next_offset < end_offset {
3329 _next_ordinal_to_read += 1;
3330 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3331 next_offset += envelope_size;
3332 }
3333
3334 Ok(())
3335 }
3336 }
3337
3338 impl StaticAssignment {
3339 #[inline(always)]
3340 fn max_ordinal_present(&self) -> u64 {
3341 if let Some(_) = self.assigned_addr {
3342 return 2;
3343 }
3344 if let Some(_) = self.host {
3345 return 1;
3346 }
3347 0
3348 }
3349 }
3350
3351 impl fidl::encoding::ValueTypeMarker for StaticAssignment {
3352 type Borrowed<'a> = &'a Self;
3353 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3354 value
3355 }
3356 }
3357
3358 unsafe impl fidl::encoding::TypeMarker for StaticAssignment {
3359 type Owned = Self;
3360
3361 #[inline(always)]
3362 fn inline_align(_context: fidl::encoding::Context) -> usize {
3363 8
3364 }
3365
3366 #[inline(always)]
3367 fn inline_size(_context: fidl::encoding::Context) -> usize {
3368 16
3369 }
3370 }
3371
3372 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StaticAssignment, D>
3373 for &StaticAssignment
3374 {
3375 unsafe fn encode(
3376 self,
3377 encoder: &mut fidl::encoding::Encoder<'_, D>,
3378 offset: usize,
3379 mut depth: fidl::encoding::Depth,
3380 ) -> fidl::Result<()> {
3381 encoder.debug_check_bounds::<StaticAssignment>(offset);
3382 let max_ordinal: u64 = self.max_ordinal_present();
3384 encoder.write_num(max_ordinal, offset);
3385 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3386 if max_ordinal == 0 {
3388 return Ok(());
3389 }
3390 depth.increment()?;
3391 let envelope_size = 8;
3392 let bytes_len = max_ordinal as usize * envelope_size;
3393 #[allow(unused_variables)]
3394 let offset = encoder.out_of_line_offset(bytes_len);
3395 let mut _prev_end_offset: usize = 0;
3396 if 1 > max_ordinal {
3397 return Ok(());
3398 }
3399
3400 let cur_offset: usize = (1 - 1) * envelope_size;
3403
3404 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3406
3407 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
3412 self.host.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
3413 encoder, offset + cur_offset, depth
3414 )?;
3415
3416 _prev_end_offset = cur_offset + envelope_size;
3417 if 2 > max_ordinal {
3418 return Ok(());
3419 }
3420
3421 let cur_offset: usize = (2 - 1) * envelope_size;
3424
3425 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3427
3428 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
3433 self.assigned_addr.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
3434 encoder, offset + cur_offset, depth
3435 )?;
3436
3437 _prev_end_offset = cur_offset + envelope_size;
3438
3439 Ok(())
3440 }
3441 }
3442
3443 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaticAssignment {
3444 #[inline(always)]
3445 fn new_empty() -> Self {
3446 Self::default()
3447 }
3448
3449 unsafe fn decode(
3450 &mut self,
3451 decoder: &mut fidl::encoding::Decoder<'_, D>,
3452 offset: usize,
3453 mut depth: fidl::encoding::Depth,
3454 ) -> fidl::Result<()> {
3455 decoder.debug_check_bounds::<Self>(offset);
3456 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3457 None => return Err(fidl::Error::NotNullable),
3458 Some(len) => len,
3459 };
3460 if len == 0 {
3462 return Ok(());
3463 };
3464 depth.increment()?;
3465 let envelope_size = 8;
3466 let bytes_len = len * envelope_size;
3467 let offset = decoder.out_of_line_offset(bytes_len)?;
3468 let mut _next_ordinal_to_read = 0;
3470 let mut next_offset = offset;
3471 let end_offset = offset + bytes_len;
3472 _next_ordinal_to_read += 1;
3473 if next_offset >= end_offset {
3474 return Ok(());
3475 }
3476
3477 while _next_ordinal_to_read < 1 {
3479 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3480 _next_ordinal_to_read += 1;
3481 next_offset += envelope_size;
3482 }
3483
3484 let next_out_of_line = decoder.next_out_of_line();
3485 let handles_before = decoder.remaining_handles();
3486 if let Some((inlined, num_bytes, num_handles)) =
3487 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3488 {
3489 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3490 if inlined != (member_inline_size <= 4) {
3491 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3492 }
3493 let inner_offset;
3494 let mut inner_depth = depth.clone();
3495 if inlined {
3496 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3497 inner_offset = next_offset;
3498 } else {
3499 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3500 inner_depth.increment()?;
3501 }
3502 let val_ref = self.host.get_or_insert_with(|| {
3503 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
3504 });
3505 fidl::decode!(
3506 fidl_fuchsia_net__common::MacAddress,
3507 D,
3508 val_ref,
3509 decoder,
3510 inner_offset,
3511 inner_depth
3512 )?;
3513 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3514 {
3515 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3516 }
3517 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3518 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3519 }
3520 }
3521
3522 next_offset += envelope_size;
3523 _next_ordinal_to_read += 1;
3524 if next_offset >= end_offset {
3525 return Ok(());
3526 }
3527
3528 while _next_ordinal_to_read < 2 {
3530 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3531 _next_ordinal_to_read += 1;
3532 next_offset += envelope_size;
3533 }
3534
3535 let next_out_of_line = decoder.next_out_of_line();
3536 let handles_before = decoder.remaining_handles();
3537 if let Some((inlined, num_bytes, num_handles)) =
3538 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3539 {
3540 let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3541 if inlined != (member_inline_size <= 4) {
3542 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3543 }
3544 let inner_offset;
3545 let mut inner_depth = depth.clone();
3546 if inlined {
3547 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3548 inner_offset = next_offset;
3549 } else {
3550 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3551 inner_depth.increment()?;
3552 }
3553 let val_ref = self.assigned_addr.get_or_insert_with(|| {
3554 fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
3555 });
3556 fidl::decode!(
3557 fidl_fuchsia_net__common::Ipv4Address,
3558 D,
3559 val_ref,
3560 decoder,
3561 inner_offset,
3562 inner_depth
3563 )?;
3564 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3565 {
3566 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3567 }
3568 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3569 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3570 }
3571 }
3572
3573 next_offset += envelope_size;
3574
3575 while next_offset < end_offset {
3577 _next_ordinal_to_read += 1;
3578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3579 next_offset += envelope_size;
3580 }
3581
3582 Ok(())
3583 }
3584 }
3585
3586 impl fidl::encoding::ValueTypeMarker for Option_ {
3587 type Borrowed<'a> = &'a Self;
3588 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3589 value
3590 }
3591 }
3592
3593 unsafe impl fidl::encoding::TypeMarker for Option_ {
3594 type Owned = Self;
3595
3596 #[inline(always)]
3597 fn inline_align(_context: fidl::encoding::Context) -> usize {
3598 8
3599 }
3600
3601 #[inline(always)]
3602 fn inline_size(_context: fidl::encoding::Context) -> usize {
3603 16
3604 }
3605 }
3606
3607 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Option_, D> for &Option_ {
3608 #[inline]
3609 unsafe fn encode(
3610 self,
3611 encoder: &mut fidl::encoding::Encoder<'_, D>,
3612 offset: usize,
3613 _depth: fidl::encoding::Depth,
3614 ) -> fidl::Result<()> {
3615 encoder.debug_check_bounds::<Option_>(offset);
3616 encoder.write_num::<u64>(self.ordinal(), offset);
3617 match self {
3618 Option_::SubnetMask(ref val) => {
3619 fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3620 <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3621 encoder, offset + 8, _depth
3622 )
3623 }
3624 Option_::TimeOffset(ref val) => {
3625 fidl::encoding::encode_in_envelope::<i32, D>(
3626 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3627 encoder, offset + 8, _depth
3628 )
3629 }
3630 Option_::Router(ref val) => {
3631 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3632 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3633 encoder, offset + 8, _depth
3634 )
3635 }
3636 Option_::TimeServer(ref val) => {
3637 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3638 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3639 encoder, offset + 8, _depth
3640 )
3641 }
3642 Option_::NameServer(ref val) => {
3643 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3644 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3645 encoder, offset + 8, _depth
3646 )
3647 }
3648 Option_::DomainNameServer(ref val) => {
3649 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3650 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3651 encoder, offset + 8, _depth
3652 )
3653 }
3654 Option_::LogServer(ref val) => {
3655 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3656 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3657 encoder, offset + 8, _depth
3658 )
3659 }
3660 Option_::CookieServer(ref val) => {
3661 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3662 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3663 encoder, offset + 8, _depth
3664 )
3665 }
3666 Option_::LprServer(ref val) => {
3667 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3668 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3669 encoder, offset + 8, _depth
3670 )
3671 }
3672 Option_::ImpressServer(ref val) => {
3673 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3674 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3675 encoder, offset + 8, _depth
3676 )
3677 }
3678 Option_::ResourceLocationServer(ref val) => {
3679 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3680 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3681 encoder, offset + 8, _depth
3682 )
3683 }
3684 Option_::HostName(ref val) => {
3685 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3686 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3687 encoder, offset + 8, _depth
3688 )
3689 }
3690 Option_::BootFileSize(ref val) => {
3691 fidl::encoding::encode_in_envelope::<u16, D>(
3692 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3693 encoder, offset + 8, _depth
3694 )
3695 }
3696 Option_::MeritDumpFile(ref val) => {
3697 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3698 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3699 encoder, offset + 8, _depth
3700 )
3701 }
3702 Option_::DomainName(ref val) => {
3703 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3704 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3705 encoder, offset + 8, _depth
3706 )
3707 }
3708 Option_::SwapServer(ref val) => {
3709 fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3710 <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3711 encoder, offset + 8, _depth
3712 )
3713 }
3714 Option_::RootPath(ref val) => {
3715 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3716 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3717 encoder, offset + 8, _depth
3718 )
3719 }
3720 Option_::ExtensionsPath(ref val) => {
3721 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3722 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3723 encoder, offset + 8, _depth
3724 )
3725 }
3726 Option_::IpForwarding(ref val) => {
3727 fidl::encoding::encode_in_envelope::<bool, D>(
3728 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3729 encoder, offset + 8, _depth
3730 )
3731 }
3732 Option_::NonLocalSourceRouting(ref val) => {
3733 fidl::encoding::encode_in_envelope::<bool, D>(
3734 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3735 encoder, offset + 8, _depth
3736 )
3737 }
3738 Option_::PolicyFilter(ref val) => {
3739 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3740 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3741 encoder, offset + 8, _depth
3742 )
3743 }
3744 Option_::MaxDatagramReassemblySize(ref val) => {
3745 fidl::encoding::encode_in_envelope::<u16, D>(
3746 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3747 encoder, offset + 8, _depth
3748 )
3749 }
3750 Option_::DefaultIpTtl(ref val) => {
3751 fidl::encoding::encode_in_envelope::<u8, D>(
3752 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
3753 encoder, offset + 8, _depth
3754 )
3755 }
3756 Option_::PathMtuAgingTimeout(ref val) => {
3757 fidl::encoding::encode_in_envelope::<u32, D>(
3758 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3759 encoder, offset + 8, _depth
3760 )
3761 }
3762 Option_::PathMtuPlateauTable(ref val) => {
3763 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u16, 127>, D>(
3764 <fidl::encoding::Vector<u16, 127> as fidl::encoding::ValueTypeMarker>::borrow(val),
3765 encoder, offset + 8, _depth
3766 )
3767 }
3768 Option_::InterfaceMtu(ref val) => {
3769 fidl::encoding::encode_in_envelope::<u16, D>(
3770 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3771 encoder, offset + 8, _depth
3772 )
3773 }
3774 Option_::AllSubnetsLocal(ref val) => {
3775 fidl::encoding::encode_in_envelope::<bool, D>(
3776 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3777 encoder, offset + 8, _depth
3778 )
3779 }
3780 Option_::BroadcastAddress(ref val) => {
3781 fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3782 <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3783 encoder, offset + 8, _depth
3784 )
3785 }
3786 Option_::PerformMaskDiscovery(ref val) => {
3787 fidl::encoding::encode_in_envelope::<bool, D>(
3788 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3789 encoder, offset + 8, _depth
3790 )
3791 }
3792 Option_::MaskSupplier(ref val) => {
3793 fidl::encoding::encode_in_envelope::<bool, D>(
3794 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3795 encoder, offset + 8, _depth
3796 )
3797 }
3798 Option_::PerformRouterDiscovery(ref val) => {
3799 fidl::encoding::encode_in_envelope::<bool, D>(
3800 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3801 encoder, offset + 8, _depth
3802 )
3803 }
3804 Option_::RouterSolicitationAddress(ref val) => {
3805 fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3806 <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3807 encoder, offset + 8, _depth
3808 )
3809 }
3810 Option_::StaticRoute(ref val) => {
3811 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3812 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3813 encoder, offset + 8, _depth
3814 )
3815 }
3816 Option_::TrailerEncapsulation(ref val) => {
3817 fidl::encoding::encode_in_envelope::<bool, D>(
3818 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3819 encoder, offset + 8, _depth
3820 )
3821 }
3822 Option_::ArpCacheTimeout(ref val) => {
3823 fidl::encoding::encode_in_envelope::<u32, D>(
3824 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3825 encoder, offset + 8, _depth
3826 )
3827 }
3828 Option_::EthernetEncapsulation(ref val) => {
3829 fidl::encoding::encode_in_envelope::<bool, D>(
3830 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3831 encoder, offset + 8, _depth
3832 )
3833 }
3834 Option_::TcpDefaultTtl(ref val) => {
3835 fidl::encoding::encode_in_envelope::<u8, D>(
3836 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
3837 encoder, offset + 8, _depth
3838 )
3839 }
3840 Option_::TcpKeepaliveInterval(ref val) => {
3841 fidl::encoding::encode_in_envelope::<u32, D>(
3842 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3843 encoder, offset + 8, _depth
3844 )
3845 }
3846 Option_::TcpKeepaliveGarbage(ref val) => {
3847 fidl::encoding::encode_in_envelope::<bool, D>(
3848 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3849 encoder, offset + 8, _depth
3850 )
3851 }
3852 Option_::NetworkInformationServiceDomain(ref val) => {
3853 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3854 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3855 encoder, offset + 8, _depth
3856 )
3857 }
3858 Option_::NetworkInformationServers(ref val) => {
3859 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3860 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3861 encoder, offset + 8, _depth
3862 )
3863 }
3864 Option_::NetworkTimeProtocolServers(ref val) => {
3865 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3866 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3867 encoder, offset + 8, _depth
3868 )
3869 }
3870 Option_::VendorSpecificInformation(ref val) => {
3871 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 255>, D>(
3872 <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3873 encoder, offset + 8, _depth
3874 )
3875 }
3876 Option_::NetbiosOverTcpipNameServer(ref val) => {
3877 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3878 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3879 encoder, offset + 8, _depth
3880 )
3881 }
3882 Option_::NetbiosOverTcpipDatagramDistributionServer(ref val) => {
3883 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3884 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3885 encoder, offset + 8, _depth
3886 )
3887 }
3888 Option_::NetbiosOverTcpipNodeType(ref val) => {
3889 fidl::encoding::encode_in_envelope::<NodeTypes, D>(
3890 <NodeTypes as fidl::encoding::ValueTypeMarker>::borrow(val),
3891 encoder, offset + 8, _depth
3892 )
3893 }
3894 Option_::NetbiosOverTcpipScope(ref val) => {
3895 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3896 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3897 encoder, offset + 8, _depth
3898 )
3899 }
3900 Option_::XWindowSystemFontServer(ref val) => {
3901 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3902 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3903 encoder, offset + 8, _depth
3904 )
3905 }
3906 Option_::XWindowSystemDisplayManager(ref val) => {
3907 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3908 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3909 encoder, offset + 8, _depth
3910 )
3911 }
3912 Option_::NetworkInformationServicePlusDomain(ref val) => {
3913 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3914 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3915 encoder, offset + 8, _depth
3916 )
3917 }
3918 Option_::NetworkInformationServicePlusServers(ref val) => {
3919 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3920 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3921 encoder, offset + 8, _depth
3922 )
3923 }
3924 Option_::MobileIpHomeAgent(ref val) => {
3925 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3926 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3927 encoder, offset + 8, _depth
3928 )
3929 }
3930 Option_::SmtpServer(ref val) => {
3931 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3932 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3933 encoder, offset + 8, _depth
3934 )
3935 }
3936 Option_::Pop3Server(ref val) => {
3937 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3938 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3939 encoder, offset + 8, _depth
3940 )
3941 }
3942 Option_::NntpServer(ref val) => {
3943 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3944 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3945 encoder, offset + 8, _depth
3946 )
3947 }
3948 Option_::DefaultWwwServer(ref val) => {
3949 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3950 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3951 encoder, offset + 8, _depth
3952 )
3953 }
3954 Option_::DefaultFingerServer(ref val) => {
3955 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3956 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3957 encoder, offset + 8, _depth
3958 )
3959 }
3960 Option_::DefaultIrcServer(ref val) => {
3961 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3962 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3963 encoder, offset + 8, _depth
3964 )
3965 }
3966 Option_::StreettalkServer(ref val) => {
3967 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3968 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3969 encoder, offset + 8, _depth
3970 )
3971 }
3972 Option_::StreettalkDirectoryAssistanceServer(ref val) => {
3973 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3974 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3975 encoder, offset + 8, _depth
3976 )
3977 }
3978 Option_::OptionOverload(ref val) => {
3979 fidl::encoding::encode_in_envelope::<OptionOverloadValue, D>(
3980 <OptionOverloadValue as fidl::encoding::ValueTypeMarker>::borrow(val),
3981 encoder, offset + 8, _depth
3982 )
3983 }
3984 Option_::TftpServerName(ref val) => {
3985 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3986 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3987 encoder, offset + 8, _depth
3988 )
3989 }
3990 Option_::BootfileName(ref val) => {
3991 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3992 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3993 encoder, offset + 8, _depth
3994 )
3995 }
3996 Option_::MaxDhcpMessageSize(ref val) => {
3997 fidl::encoding::encode_in_envelope::<u16, D>(
3998 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3999 encoder, offset + 8, _depth
4000 )
4001 }
4002 Option_::RenewalTimeValue(ref val) => {
4003 fidl::encoding::encode_in_envelope::<u32, D>(
4004 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
4005 encoder, offset + 8, _depth
4006 )
4007 }
4008 Option_::RebindingTimeValue(ref val) => {
4009 fidl::encoding::encode_in_envelope::<u32, D>(
4010 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
4011 encoder, offset + 8, _depth
4012 )
4013 }
4014 Option_::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4015 }
4016 }
4017 }
4018
4019 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Option_ {
4020 #[inline(always)]
4021 fn new_empty() -> Self {
4022 Self::__SourceBreaking { unknown_ordinal: 0 }
4023 }
4024
4025 #[inline]
4026 unsafe fn decode(
4027 &mut self,
4028 decoder: &mut fidl::encoding::Decoder<'_, D>,
4029 offset: usize,
4030 mut depth: fidl::encoding::Depth,
4031 ) -> fidl::Result<()> {
4032 decoder.debug_check_bounds::<Self>(offset);
4033 #[allow(unused_variables)]
4034 let next_out_of_line = decoder.next_out_of_line();
4035 let handles_before = decoder.remaining_handles();
4036 let (ordinal, inlined, num_bytes, num_handles) =
4037 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4038
4039 let member_inline_size = match ordinal {
4040 1 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4041 2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4042 3 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4043 4 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4044 5 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4045 6 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4046 7 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4047 8 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4048 9 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4049 10 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4050 11 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4051 12 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4052 13 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4053 14 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4054 15 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4055 16 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4056 17 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4057 18 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4058 19 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4059 20 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4060 21 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4061 22 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4062 23 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4063 24 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4064 25 => <fidl::encoding::Vector<u16, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4065 26 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4066 27 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4067 28 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4068 29 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4069 30 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4070 31 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4071 32 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4072 33 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4073 34 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4074 35 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4075 36 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4076 37 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4077 38 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4078 39 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4079 40 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4080 41 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4081 42 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4082 43 => <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4083 44 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4084 45 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4085 46 => <NodeTypes as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4086 47 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4087 48 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4088 49 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4089 50 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4090 51 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4091 52 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4092 53 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4093 54 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4094 55 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4095 56 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4096 57 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4097 58 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4098 59 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4099 60 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4100 61 => <OptionOverloadValue as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4101 62 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4102 63 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4103 64 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4104 65 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4105 66 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4106 0 => return Err(fidl::Error::UnknownUnionTag),
4107 _ => num_bytes as usize,
4108 };
4109
4110 if inlined != (member_inline_size <= 4) {
4111 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4112 }
4113 let _inner_offset;
4114 if inlined {
4115 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4116 _inner_offset = offset + 8;
4117 } else {
4118 depth.increment()?;
4119 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4120 }
4121 match ordinal {
4122 1 => {
4123 #[allow(irrefutable_let_patterns)]
4124 if let Option_::SubnetMask(_) = self {
4125 } else {
4127 *self = Option_::SubnetMask(fidl::new_empty!(
4129 fidl_fuchsia_net__common::Ipv4Address,
4130 D
4131 ));
4132 }
4133 #[allow(irrefutable_let_patterns)]
4134 if let Option_::SubnetMask(ref mut val) = self {
4135 fidl::decode!(
4136 fidl_fuchsia_net__common::Ipv4Address,
4137 D,
4138 val,
4139 decoder,
4140 _inner_offset,
4141 depth
4142 )?;
4143 } else {
4144 unreachable!()
4145 }
4146 }
4147 2 => {
4148 #[allow(irrefutable_let_patterns)]
4149 if let Option_::TimeOffset(_) = self {
4150 } else {
4152 *self = Option_::TimeOffset(fidl::new_empty!(i32, D));
4154 }
4155 #[allow(irrefutable_let_patterns)]
4156 if let Option_::TimeOffset(ref mut val) = self {
4157 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
4158 } else {
4159 unreachable!()
4160 }
4161 }
4162 3 => {
4163 #[allow(irrefutable_let_patterns)]
4164 if let Option_::Router(_) = self {
4165 } else {
4167 *self = Option_::Router(
4169 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4170 );
4171 }
4172 #[allow(irrefutable_let_patterns)]
4173 if let Option_::Router(ref mut val) = self {
4174 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4175 } else {
4176 unreachable!()
4177 }
4178 }
4179 4 => {
4180 #[allow(irrefutable_let_patterns)]
4181 if let Option_::TimeServer(_) = self {
4182 } else {
4184 *self = Option_::TimeServer(
4186 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4187 );
4188 }
4189 #[allow(irrefutable_let_patterns)]
4190 if let Option_::TimeServer(ref mut val) = self {
4191 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4192 } else {
4193 unreachable!()
4194 }
4195 }
4196 5 => {
4197 #[allow(irrefutable_let_patterns)]
4198 if let Option_::NameServer(_) = self {
4199 } else {
4201 *self = Option_::NameServer(
4203 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4204 );
4205 }
4206 #[allow(irrefutable_let_patterns)]
4207 if let Option_::NameServer(ref mut val) = self {
4208 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4209 } else {
4210 unreachable!()
4211 }
4212 }
4213 6 => {
4214 #[allow(irrefutable_let_patterns)]
4215 if let Option_::DomainNameServer(_) = self {
4216 } else {
4218 *self = Option_::DomainNameServer(
4220 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4221 );
4222 }
4223 #[allow(irrefutable_let_patterns)]
4224 if let Option_::DomainNameServer(ref mut val) = self {
4225 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4226 } else {
4227 unreachable!()
4228 }
4229 }
4230 7 => {
4231 #[allow(irrefutable_let_patterns)]
4232 if let Option_::LogServer(_) = self {
4233 } else {
4235 *self = Option_::LogServer(
4237 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4238 );
4239 }
4240 #[allow(irrefutable_let_patterns)]
4241 if let Option_::LogServer(ref mut val) = self {
4242 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4243 } else {
4244 unreachable!()
4245 }
4246 }
4247 8 => {
4248 #[allow(irrefutable_let_patterns)]
4249 if let Option_::CookieServer(_) = self {
4250 } else {
4252 *self = Option_::CookieServer(
4254 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4255 );
4256 }
4257 #[allow(irrefutable_let_patterns)]
4258 if let Option_::CookieServer(ref mut val) = self {
4259 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4260 } else {
4261 unreachable!()
4262 }
4263 }
4264 9 => {
4265 #[allow(irrefutable_let_patterns)]
4266 if let Option_::LprServer(_) = self {
4267 } else {
4269 *self = Option_::LprServer(
4271 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4272 );
4273 }
4274 #[allow(irrefutable_let_patterns)]
4275 if let Option_::LprServer(ref mut val) = self {
4276 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4277 } else {
4278 unreachable!()
4279 }
4280 }
4281 10 => {
4282 #[allow(irrefutable_let_patterns)]
4283 if let Option_::ImpressServer(_) = self {
4284 } else {
4286 *self = Option_::ImpressServer(
4288 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4289 );
4290 }
4291 #[allow(irrefutable_let_patterns)]
4292 if let Option_::ImpressServer(ref mut val) = self {
4293 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4294 } else {
4295 unreachable!()
4296 }
4297 }
4298 11 => {
4299 #[allow(irrefutable_let_patterns)]
4300 if let Option_::ResourceLocationServer(_) = self {
4301 } else {
4303 *self = Option_::ResourceLocationServer(
4305 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4306 );
4307 }
4308 #[allow(irrefutable_let_patterns)]
4309 if let Option_::ResourceLocationServer(ref mut val) = self {
4310 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4311 } else {
4312 unreachable!()
4313 }
4314 }
4315 12 => {
4316 #[allow(irrefutable_let_patterns)]
4317 if let Option_::HostName(_) = self {
4318 } else {
4320 *self = Option_::HostName(fidl::new_empty!(
4322 fidl::encoding::BoundedString<255>,
4323 D
4324 ));
4325 }
4326 #[allow(irrefutable_let_patterns)]
4327 if let Option_::HostName(ref mut val) = self {
4328 fidl::decode!(
4329 fidl::encoding::BoundedString<255>,
4330 D,
4331 val,
4332 decoder,
4333 _inner_offset,
4334 depth
4335 )?;
4336 } else {
4337 unreachable!()
4338 }
4339 }
4340 13 => {
4341 #[allow(irrefutable_let_patterns)]
4342 if let Option_::BootFileSize(_) = self {
4343 } else {
4345 *self = Option_::BootFileSize(fidl::new_empty!(u16, D));
4347 }
4348 #[allow(irrefutable_let_patterns)]
4349 if let Option_::BootFileSize(ref mut val) = self {
4350 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4351 } else {
4352 unreachable!()
4353 }
4354 }
4355 14 => {
4356 #[allow(irrefutable_let_patterns)]
4357 if let Option_::MeritDumpFile(_) = self {
4358 } else {
4360 *self = Option_::MeritDumpFile(fidl::new_empty!(
4362 fidl::encoding::BoundedString<255>,
4363 D
4364 ));
4365 }
4366 #[allow(irrefutable_let_patterns)]
4367 if let Option_::MeritDumpFile(ref mut val) = self {
4368 fidl::decode!(
4369 fidl::encoding::BoundedString<255>,
4370 D,
4371 val,
4372 decoder,
4373 _inner_offset,
4374 depth
4375 )?;
4376 } else {
4377 unreachable!()
4378 }
4379 }
4380 15 => {
4381 #[allow(irrefutable_let_patterns)]
4382 if let Option_::DomainName(_) = self {
4383 } else {
4385 *self = Option_::DomainName(fidl::new_empty!(
4387 fidl::encoding::BoundedString<255>,
4388 D
4389 ));
4390 }
4391 #[allow(irrefutable_let_patterns)]
4392 if let Option_::DomainName(ref mut val) = self {
4393 fidl::decode!(
4394 fidl::encoding::BoundedString<255>,
4395 D,
4396 val,
4397 decoder,
4398 _inner_offset,
4399 depth
4400 )?;
4401 } else {
4402 unreachable!()
4403 }
4404 }
4405 16 => {
4406 #[allow(irrefutable_let_patterns)]
4407 if let Option_::SwapServer(_) = self {
4408 } else {
4410 *self = Option_::SwapServer(fidl::new_empty!(
4412 fidl_fuchsia_net__common::Ipv4Address,
4413 D
4414 ));
4415 }
4416 #[allow(irrefutable_let_patterns)]
4417 if let Option_::SwapServer(ref mut val) = self {
4418 fidl::decode!(
4419 fidl_fuchsia_net__common::Ipv4Address,
4420 D,
4421 val,
4422 decoder,
4423 _inner_offset,
4424 depth
4425 )?;
4426 } else {
4427 unreachable!()
4428 }
4429 }
4430 17 => {
4431 #[allow(irrefutable_let_patterns)]
4432 if let Option_::RootPath(_) = self {
4433 } else {
4435 *self = Option_::RootPath(fidl::new_empty!(
4437 fidl::encoding::BoundedString<255>,
4438 D
4439 ));
4440 }
4441 #[allow(irrefutable_let_patterns)]
4442 if let Option_::RootPath(ref mut val) = self {
4443 fidl::decode!(
4444 fidl::encoding::BoundedString<255>,
4445 D,
4446 val,
4447 decoder,
4448 _inner_offset,
4449 depth
4450 )?;
4451 } else {
4452 unreachable!()
4453 }
4454 }
4455 18 => {
4456 #[allow(irrefutable_let_patterns)]
4457 if let Option_::ExtensionsPath(_) = self {
4458 } else {
4460 *self = Option_::ExtensionsPath(fidl::new_empty!(
4462 fidl::encoding::BoundedString<255>,
4463 D
4464 ));
4465 }
4466 #[allow(irrefutable_let_patterns)]
4467 if let Option_::ExtensionsPath(ref mut val) = self {
4468 fidl::decode!(
4469 fidl::encoding::BoundedString<255>,
4470 D,
4471 val,
4472 decoder,
4473 _inner_offset,
4474 depth
4475 )?;
4476 } else {
4477 unreachable!()
4478 }
4479 }
4480 19 => {
4481 #[allow(irrefutable_let_patterns)]
4482 if let Option_::IpForwarding(_) = self {
4483 } else {
4485 *self = Option_::IpForwarding(fidl::new_empty!(bool, D));
4487 }
4488 #[allow(irrefutable_let_patterns)]
4489 if let Option_::IpForwarding(ref mut val) = self {
4490 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4491 } else {
4492 unreachable!()
4493 }
4494 }
4495 20 => {
4496 #[allow(irrefutable_let_patterns)]
4497 if let Option_::NonLocalSourceRouting(_) = self {
4498 } else {
4500 *self = Option_::NonLocalSourceRouting(fidl::new_empty!(bool, D));
4502 }
4503 #[allow(irrefutable_let_patterns)]
4504 if let Option_::NonLocalSourceRouting(ref mut val) = self {
4505 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4506 } else {
4507 unreachable!()
4508 }
4509 }
4510 21 => {
4511 #[allow(irrefutable_let_patterns)]
4512 if let Option_::PolicyFilter(_) = self {
4513 } else {
4515 *self = Option_::PolicyFilter(
4517 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4518 );
4519 }
4520 #[allow(irrefutable_let_patterns)]
4521 if let Option_::PolicyFilter(ref mut val) = self {
4522 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4523 } else {
4524 unreachable!()
4525 }
4526 }
4527 22 => {
4528 #[allow(irrefutable_let_patterns)]
4529 if let Option_::MaxDatagramReassemblySize(_) = self {
4530 } else {
4532 *self = Option_::MaxDatagramReassemblySize(fidl::new_empty!(u16, D));
4534 }
4535 #[allow(irrefutable_let_patterns)]
4536 if let Option_::MaxDatagramReassemblySize(ref mut val) = self {
4537 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4538 } else {
4539 unreachable!()
4540 }
4541 }
4542 23 => {
4543 #[allow(irrefutable_let_patterns)]
4544 if let Option_::DefaultIpTtl(_) = self {
4545 } else {
4547 *self = Option_::DefaultIpTtl(fidl::new_empty!(u8, D));
4549 }
4550 #[allow(irrefutable_let_patterns)]
4551 if let Option_::DefaultIpTtl(ref mut val) = self {
4552 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
4553 } else {
4554 unreachable!()
4555 }
4556 }
4557 24 => {
4558 #[allow(irrefutable_let_patterns)]
4559 if let Option_::PathMtuAgingTimeout(_) = self {
4560 } else {
4562 *self = Option_::PathMtuAgingTimeout(fidl::new_empty!(u32, D));
4564 }
4565 #[allow(irrefutable_let_patterns)]
4566 if let Option_::PathMtuAgingTimeout(ref mut val) = self {
4567 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4568 } else {
4569 unreachable!()
4570 }
4571 }
4572 25 => {
4573 #[allow(irrefutable_let_patterns)]
4574 if let Option_::PathMtuPlateauTable(_) = self {
4575 } else {
4577 *self = Option_::PathMtuPlateauTable(
4579 fidl::new_empty!(fidl::encoding::Vector<u16, 127>, D),
4580 );
4581 }
4582 #[allow(irrefutable_let_patterns)]
4583 if let Option_::PathMtuPlateauTable(ref mut val) = self {
4584 fidl::decode!(fidl::encoding::Vector<u16, 127>, D, val, decoder, _inner_offset, depth)?;
4585 } else {
4586 unreachable!()
4587 }
4588 }
4589 26 => {
4590 #[allow(irrefutable_let_patterns)]
4591 if let Option_::InterfaceMtu(_) = self {
4592 } else {
4594 *self = Option_::InterfaceMtu(fidl::new_empty!(u16, D));
4596 }
4597 #[allow(irrefutable_let_patterns)]
4598 if let Option_::InterfaceMtu(ref mut val) = self {
4599 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4600 } else {
4601 unreachable!()
4602 }
4603 }
4604 27 => {
4605 #[allow(irrefutable_let_patterns)]
4606 if let Option_::AllSubnetsLocal(_) = self {
4607 } else {
4609 *self = Option_::AllSubnetsLocal(fidl::new_empty!(bool, D));
4611 }
4612 #[allow(irrefutable_let_patterns)]
4613 if let Option_::AllSubnetsLocal(ref mut val) = self {
4614 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4615 } else {
4616 unreachable!()
4617 }
4618 }
4619 28 => {
4620 #[allow(irrefutable_let_patterns)]
4621 if let Option_::BroadcastAddress(_) = self {
4622 } else {
4624 *self = Option_::BroadcastAddress(fidl::new_empty!(
4626 fidl_fuchsia_net__common::Ipv4Address,
4627 D
4628 ));
4629 }
4630 #[allow(irrefutable_let_patterns)]
4631 if let Option_::BroadcastAddress(ref mut val) = self {
4632 fidl::decode!(
4633 fidl_fuchsia_net__common::Ipv4Address,
4634 D,
4635 val,
4636 decoder,
4637 _inner_offset,
4638 depth
4639 )?;
4640 } else {
4641 unreachable!()
4642 }
4643 }
4644 29 => {
4645 #[allow(irrefutable_let_patterns)]
4646 if let Option_::PerformMaskDiscovery(_) = self {
4647 } else {
4649 *self = Option_::PerformMaskDiscovery(fidl::new_empty!(bool, D));
4651 }
4652 #[allow(irrefutable_let_patterns)]
4653 if let Option_::PerformMaskDiscovery(ref mut val) = self {
4654 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4655 } else {
4656 unreachable!()
4657 }
4658 }
4659 30 => {
4660 #[allow(irrefutable_let_patterns)]
4661 if let Option_::MaskSupplier(_) = self {
4662 } else {
4664 *self = Option_::MaskSupplier(fidl::new_empty!(bool, D));
4666 }
4667 #[allow(irrefutable_let_patterns)]
4668 if let Option_::MaskSupplier(ref mut val) = self {
4669 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4670 } else {
4671 unreachable!()
4672 }
4673 }
4674 31 => {
4675 #[allow(irrefutable_let_patterns)]
4676 if let Option_::PerformRouterDiscovery(_) = self {
4677 } else {
4679 *self = Option_::PerformRouterDiscovery(fidl::new_empty!(bool, D));
4681 }
4682 #[allow(irrefutable_let_patterns)]
4683 if let Option_::PerformRouterDiscovery(ref mut val) = self {
4684 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4685 } else {
4686 unreachable!()
4687 }
4688 }
4689 32 => {
4690 #[allow(irrefutable_let_patterns)]
4691 if let Option_::RouterSolicitationAddress(_) = self {
4692 } else {
4694 *self = Option_::RouterSolicitationAddress(fidl::new_empty!(
4696 fidl_fuchsia_net__common::Ipv4Address,
4697 D
4698 ));
4699 }
4700 #[allow(irrefutable_let_patterns)]
4701 if let Option_::RouterSolicitationAddress(ref mut val) = self {
4702 fidl::decode!(
4703 fidl_fuchsia_net__common::Ipv4Address,
4704 D,
4705 val,
4706 decoder,
4707 _inner_offset,
4708 depth
4709 )?;
4710 } else {
4711 unreachable!()
4712 }
4713 }
4714 33 => {
4715 #[allow(irrefutable_let_patterns)]
4716 if let Option_::StaticRoute(_) = self {
4717 } else {
4719 *self = Option_::StaticRoute(
4721 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4722 );
4723 }
4724 #[allow(irrefutable_let_patterns)]
4725 if let Option_::StaticRoute(ref mut val) = self {
4726 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4727 } else {
4728 unreachable!()
4729 }
4730 }
4731 34 => {
4732 #[allow(irrefutable_let_patterns)]
4733 if let Option_::TrailerEncapsulation(_) = self {
4734 } else {
4736 *self = Option_::TrailerEncapsulation(fidl::new_empty!(bool, D));
4738 }
4739 #[allow(irrefutable_let_patterns)]
4740 if let Option_::TrailerEncapsulation(ref mut val) = self {
4741 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4742 } else {
4743 unreachable!()
4744 }
4745 }
4746 35 => {
4747 #[allow(irrefutable_let_patterns)]
4748 if let Option_::ArpCacheTimeout(_) = self {
4749 } else {
4751 *self = Option_::ArpCacheTimeout(fidl::new_empty!(u32, D));
4753 }
4754 #[allow(irrefutable_let_patterns)]
4755 if let Option_::ArpCacheTimeout(ref mut val) = self {
4756 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4757 } else {
4758 unreachable!()
4759 }
4760 }
4761 36 => {
4762 #[allow(irrefutable_let_patterns)]
4763 if let Option_::EthernetEncapsulation(_) = self {
4764 } else {
4766 *self = Option_::EthernetEncapsulation(fidl::new_empty!(bool, D));
4768 }
4769 #[allow(irrefutable_let_patterns)]
4770 if let Option_::EthernetEncapsulation(ref mut val) = self {
4771 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4772 } else {
4773 unreachable!()
4774 }
4775 }
4776 37 => {
4777 #[allow(irrefutable_let_patterns)]
4778 if let Option_::TcpDefaultTtl(_) = self {
4779 } else {
4781 *self = Option_::TcpDefaultTtl(fidl::new_empty!(u8, D));
4783 }
4784 #[allow(irrefutable_let_patterns)]
4785 if let Option_::TcpDefaultTtl(ref mut val) = self {
4786 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
4787 } else {
4788 unreachable!()
4789 }
4790 }
4791 38 => {
4792 #[allow(irrefutable_let_patterns)]
4793 if let Option_::TcpKeepaliveInterval(_) = self {
4794 } else {
4796 *self = Option_::TcpKeepaliveInterval(fidl::new_empty!(u32, D));
4798 }
4799 #[allow(irrefutable_let_patterns)]
4800 if let Option_::TcpKeepaliveInterval(ref mut val) = self {
4801 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4802 } else {
4803 unreachable!()
4804 }
4805 }
4806 39 => {
4807 #[allow(irrefutable_let_patterns)]
4808 if let Option_::TcpKeepaliveGarbage(_) = self {
4809 } else {
4811 *self = Option_::TcpKeepaliveGarbage(fidl::new_empty!(bool, D));
4813 }
4814 #[allow(irrefutable_let_patterns)]
4815 if let Option_::TcpKeepaliveGarbage(ref mut val) = self {
4816 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4817 } else {
4818 unreachable!()
4819 }
4820 }
4821 40 => {
4822 #[allow(irrefutable_let_patterns)]
4823 if let Option_::NetworkInformationServiceDomain(_) = self {
4824 } else {
4826 *self = Option_::NetworkInformationServiceDomain(fidl::new_empty!(
4828 fidl::encoding::BoundedString<255>,
4829 D
4830 ));
4831 }
4832 #[allow(irrefutable_let_patterns)]
4833 if let Option_::NetworkInformationServiceDomain(ref mut val) = self {
4834 fidl::decode!(
4835 fidl::encoding::BoundedString<255>,
4836 D,
4837 val,
4838 decoder,
4839 _inner_offset,
4840 depth
4841 )?;
4842 } else {
4843 unreachable!()
4844 }
4845 }
4846 41 => {
4847 #[allow(irrefutable_let_patterns)]
4848 if let Option_::NetworkInformationServers(_) = self {
4849 } else {
4851 *self = Option_::NetworkInformationServers(
4853 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4854 );
4855 }
4856 #[allow(irrefutable_let_patterns)]
4857 if let Option_::NetworkInformationServers(ref mut val) = self {
4858 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4859 } else {
4860 unreachable!()
4861 }
4862 }
4863 42 => {
4864 #[allow(irrefutable_let_patterns)]
4865 if let Option_::NetworkTimeProtocolServers(_) = self {
4866 } else {
4868 *self = Option_::NetworkTimeProtocolServers(
4870 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4871 );
4872 }
4873 #[allow(irrefutable_let_patterns)]
4874 if let Option_::NetworkTimeProtocolServers(ref mut val) = self {
4875 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4876 } else {
4877 unreachable!()
4878 }
4879 }
4880 43 => {
4881 #[allow(irrefutable_let_patterns)]
4882 if let Option_::VendorSpecificInformation(_) = self {
4883 } else {
4885 *self = Option_::VendorSpecificInformation(
4887 fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D),
4888 );
4889 }
4890 #[allow(irrefutable_let_patterns)]
4891 if let Option_::VendorSpecificInformation(ref mut val) = self {
4892 fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val, decoder, _inner_offset, depth)?;
4893 } else {
4894 unreachable!()
4895 }
4896 }
4897 44 => {
4898 #[allow(irrefutable_let_patterns)]
4899 if let Option_::NetbiosOverTcpipNameServer(_) = self {
4900 } else {
4902 *self = Option_::NetbiosOverTcpipNameServer(
4904 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4905 );
4906 }
4907 #[allow(irrefutable_let_patterns)]
4908 if let Option_::NetbiosOverTcpipNameServer(ref mut val) = self {
4909 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4910 } else {
4911 unreachable!()
4912 }
4913 }
4914 45 => {
4915 #[allow(irrefutable_let_patterns)]
4916 if let Option_::NetbiosOverTcpipDatagramDistributionServer(_) = self {
4917 } else {
4919 *self = Option_::NetbiosOverTcpipDatagramDistributionServer(
4921 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4922 );
4923 }
4924 #[allow(irrefutable_let_patterns)]
4925 if let Option_::NetbiosOverTcpipDatagramDistributionServer(ref mut val) = self {
4926 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4927 } else {
4928 unreachable!()
4929 }
4930 }
4931 46 => {
4932 #[allow(irrefutable_let_patterns)]
4933 if let Option_::NetbiosOverTcpipNodeType(_) = self {
4934 } else {
4936 *self = Option_::NetbiosOverTcpipNodeType(fidl::new_empty!(NodeTypes, D));
4938 }
4939 #[allow(irrefutable_let_patterns)]
4940 if let Option_::NetbiosOverTcpipNodeType(ref mut val) = self {
4941 fidl::decode!(NodeTypes, D, val, decoder, _inner_offset, depth)?;
4942 } else {
4943 unreachable!()
4944 }
4945 }
4946 47 => {
4947 #[allow(irrefutable_let_patterns)]
4948 if let Option_::NetbiosOverTcpipScope(_) = self {
4949 } else {
4951 *self = Option_::NetbiosOverTcpipScope(fidl::new_empty!(
4953 fidl::encoding::BoundedString<255>,
4954 D
4955 ));
4956 }
4957 #[allow(irrefutable_let_patterns)]
4958 if let Option_::NetbiosOverTcpipScope(ref mut val) = self {
4959 fidl::decode!(
4960 fidl::encoding::BoundedString<255>,
4961 D,
4962 val,
4963 decoder,
4964 _inner_offset,
4965 depth
4966 )?;
4967 } else {
4968 unreachable!()
4969 }
4970 }
4971 48 => {
4972 #[allow(irrefutable_let_patterns)]
4973 if let Option_::XWindowSystemFontServer(_) = self {
4974 } else {
4976 *self = Option_::XWindowSystemFontServer(
4978 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4979 );
4980 }
4981 #[allow(irrefutable_let_patterns)]
4982 if let Option_::XWindowSystemFontServer(ref mut val) = self {
4983 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4984 } else {
4985 unreachable!()
4986 }
4987 }
4988 49 => {
4989 #[allow(irrefutable_let_patterns)]
4990 if let Option_::XWindowSystemDisplayManager(_) = self {
4991 } else {
4993 *self = Option_::XWindowSystemDisplayManager(
4995 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4996 );
4997 }
4998 #[allow(irrefutable_let_patterns)]
4999 if let Option_::XWindowSystemDisplayManager(ref mut val) = self {
5000 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5001 } else {
5002 unreachable!()
5003 }
5004 }
5005 50 => {
5006 #[allow(irrefutable_let_patterns)]
5007 if let Option_::NetworkInformationServicePlusDomain(_) = self {
5008 } else {
5010 *self = Option_::NetworkInformationServicePlusDomain(fidl::new_empty!(
5012 fidl::encoding::BoundedString<255>,
5013 D
5014 ));
5015 }
5016 #[allow(irrefutable_let_patterns)]
5017 if let Option_::NetworkInformationServicePlusDomain(ref mut val) = self {
5018 fidl::decode!(
5019 fidl::encoding::BoundedString<255>,
5020 D,
5021 val,
5022 decoder,
5023 _inner_offset,
5024 depth
5025 )?;
5026 } else {
5027 unreachable!()
5028 }
5029 }
5030 51 => {
5031 #[allow(irrefutable_let_patterns)]
5032 if let Option_::NetworkInformationServicePlusServers(_) = self {
5033 } else {
5035 *self = Option_::NetworkInformationServicePlusServers(
5037 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5038 );
5039 }
5040 #[allow(irrefutable_let_patterns)]
5041 if let Option_::NetworkInformationServicePlusServers(ref mut val) = self {
5042 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5043 } else {
5044 unreachable!()
5045 }
5046 }
5047 52 => {
5048 #[allow(irrefutable_let_patterns)]
5049 if let Option_::MobileIpHomeAgent(_) = self {
5050 } else {
5052 *self = Option_::MobileIpHomeAgent(
5054 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5055 );
5056 }
5057 #[allow(irrefutable_let_patterns)]
5058 if let Option_::MobileIpHomeAgent(ref mut val) = self {
5059 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5060 } else {
5061 unreachable!()
5062 }
5063 }
5064 53 => {
5065 #[allow(irrefutable_let_patterns)]
5066 if let Option_::SmtpServer(_) = self {
5067 } else {
5069 *self = Option_::SmtpServer(
5071 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5072 );
5073 }
5074 #[allow(irrefutable_let_patterns)]
5075 if let Option_::SmtpServer(ref mut val) = self {
5076 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5077 } else {
5078 unreachable!()
5079 }
5080 }
5081 54 => {
5082 #[allow(irrefutable_let_patterns)]
5083 if let Option_::Pop3Server(_) = self {
5084 } else {
5086 *self = Option_::Pop3Server(
5088 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5089 );
5090 }
5091 #[allow(irrefutable_let_patterns)]
5092 if let Option_::Pop3Server(ref mut val) = self {
5093 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5094 } else {
5095 unreachable!()
5096 }
5097 }
5098 55 => {
5099 #[allow(irrefutable_let_patterns)]
5100 if let Option_::NntpServer(_) = self {
5101 } else {
5103 *self = Option_::NntpServer(
5105 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5106 );
5107 }
5108 #[allow(irrefutable_let_patterns)]
5109 if let Option_::NntpServer(ref mut val) = self {
5110 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5111 } else {
5112 unreachable!()
5113 }
5114 }
5115 56 => {
5116 #[allow(irrefutable_let_patterns)]
5117 if let Option_::DefaultWwwServer(_) = self {
5118 } else {
5120 *self = Option_::DefaultWwwServer(
5122 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5123 );
5124 }
5125 #[allow(irrefutable_let_patterns)]
5126 if let Option_::DefaultWwwServer(ref mut val) = self {
5127 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5128 } else {
5129 unreachable!()
5130 }
5131 }
5132 57 => {
5133 #[allow(irrefutable_let_patterns)]
5134 if let Option_::DefaultFingerServer(_) = self {
5135 } else {
5137 *self = Option_::DefaultFingerServer(
5139 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5140 );
5141 }
5142 #[allow(irrefutable_let_patterns)]
5143 if let Option_::DefaultFingerServer(ref mut val) = self {
5144 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5145 } else {
5146 unreachable!()
5147 }
5148 }
5149 58 => {
5150 #[allow(irrefutable_let_patterns)]
5151 if let Option_::DefaultIrcServer(_) = self {
5152 } else {
5154 *self = Option_::DefaultIrcServer(
5156 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5157 );
5158 }
5159 #[allow(irrefutable_let_patterns)]
5160 if let Option_::DefaultIrcServer(ref mut val) = self {
5161 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5162 } else {
5163 unreachable!()
5164 }
5165 }
5166 59 => {
5167 #[allow(irrefutable_let_patterns)]
5168 if let Option_::StreettalkServer(_) = self {
5169 } else {
5171 *self = Option_::StreettalkServer(
5173 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5174 );
5175 }
5176 #[allow(irrefutable_let_patterns)]
5177 if let Option_::StreettalkServer(ref mut val) = self {
5178 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5179 } else {
5180 unreachable!()
5181 }
5182 }
5183 60 => {
5184 #[allow(irrefutable_let_patterns)]
5185 if let Option_::StreettalkDirectoryAssistanceServer(_) = self {
5186 } else {
5188 *self = Option_::StreettalkDirectoryAssistanceServer(
5190 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5191 );
5192 }
5193 #[allow(irrefutable_let_patterns)]
5194 if let Option_::StreettalkDirectoryAssistanceServer(ref mut val) = self {
5195 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5196 } else {
5197 unreachable!()
5198 }
5199 }
5200 61 => {
5201 #[allow(irrefutable_let_patterns)]
5202 if let Option_::OptionOverload(_) = self {
5203 } else {
5205 *self = Option_::OptionOverload(fidl::new_empty!(OptionOverloadValue, D));
5207 }
5208 #[allow(irrefutable_let_patterns)]
5209 if let Option_::OptionOverload(ref mut val) = self {
5210 fidl::decode!(OptionOverloadValue, D, val, decoder, _inner_offset, depth)?;
5211 } else {
5212 unreachable!()
5213 }
5214 }
5215 62 => {
5216 #[allow(irrefutable_let_patterns)]
5217 if let Option_::TftpServerName(_) = self {
5218 } else {
5220 *self = Option_::TftpServerName(fidl::new_empty!(
5222 fidl::encoding::BoundedString<255>,
5223 D
5224 ));
5225 }
5226 #[allow(irrefutable_let_patterns)]
5227 if let Option_::TftpServerName(ref mut val) = self {
5228 fidl::decode!(
5229 fidl::encoding::BoundedString<255>,
5230 D,
5231 val,
5232 decoder,
5233 _inner_offset,
5234 depth
5235 )?;
5236 } else {
5237 unreachable!()
5238 }
5239 }
5240 63 => {
5241 #[allow(irrefutable_let_patterns)]
5242 if let Option_::BootfileName(_) = self {
5243 } else {
5245 *self = Option_::BootfileName(fidl::new_empty!(
5247 fidl::encoding::BoundedString<255>,
5248 D
5249 ));
5250 }
5251 #[allow(irrefutable_let_patterns)]
5252 if let Option_::BootfileName(ref mut val) = self {
5253 fidl::decode!(
5254 fidl::encoding::BoundedString<255>,
5255 D,
5256 val,
5257 decoder,
5258 _inner_offset,
5259 depth
5260 )?;
5261 } else {
5262 unreachable!()
5263 }
5264 }
5265 64 => {
5266 #[allow(irrefutable_let_patterns)]
5267 if let Option_::MaxDhcpMessageSize(_) = self {
5268 } else {
5270 *self = Option_::MaxDhcpMessageSize(fidl::new_empty!(u16, D));
5272 }
5273 #[allow(irrefutable_let_patterns)]
5274 if let Option_::MaxDhcpMessageSize(ref mut val) = self {
5275 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
5276 } else {
5277 unreachable!()
5278 }
5279 }
5280 65 => {
5281 #[allow(irrefutable_let_patterns)]
5282 if let Option_::RenewalTimeValue(_) = self {
5283 } else {
5285 *self = Option_::RenewalTimeValue(fidl::new_empty!(u32, D));
5287 }
5288 #[allow(irrefutable_let_patterns)]
5289 if let Option_::RenewalTimeValue(ref mut val) = self {
5290 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5291 } else {
5292 unreachable!()
5293 }
5294 }
5295 66 => {
5296 #[allow(irrefutable_let_patterns)]
5297 if let Option_::RebindingTimeValue(_) = self {
5298 } else {
5300 *self = Option_::RebindingTimeValue(fidl::new_empty!(u32, D));
5302 }
5303 #[allow(irrefutable_let_patterns)]
5304 if let Option_::RebindingTimeValue(ref mut val) = self {
5305 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5306 } else {
5307 unreachable!()
5308 }
5309 }
5310 #[allow(deprecated)]
5311 ordinal => {
5312 for _ in 0..num_handles {
5313 decoder.drop_next_handle()?;
5314 }
5315 *self = Option_::__SourceBreaking { unknown_ordinal: ordinal };
5316 }
5317 }
5318 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5319 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5320 }
5321 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5322 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5323 }
5324 Ok(())
5325 }
5326 }
5327
5328 impl fidl::encoding::ValueTypeMarker for Parameter {
5329 type Borrowed<'a> = &'a Self;
5330 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5331 value
5332 }
5333 }
5334
5335 unsafe impl fidl::encoding::TypeMarker for Parameter {
5336 type Owned = Self;
5337
5338 #[inline(always)]
5339 fn inline_align(_context: fidl::encoding::Context) -> usize {
5340 8
5341 }
5342
5343 #[inline(always)]
5344 fn inline_size(_context: fidl::encoding::Context) -> usize {
5345 16
5346 }
5347 }
5348
5349 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
5350 for &Parameter
5351 {
5352 #[inline]
5353 unsafe fn encode(
5354 self,
5355 encoder: &mut fidl::encoding::Encoder<'_, D>,
5356 offset: usize,
5357 _depth: fidl::encoding::Depth,
5358 ) -> fidl::Result<()> {
5359 encoder.debug_check_bounds::<Parameter>(offset);
5360 encoder.write_num::<u64>(self.ordinal(), offset);
5361 match self {
5362 Parameter::IpAddrs(ref val) => {
5363 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D>(
5364 <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5365 encoder, offset + 8, _depth
5366 )
5367 }
5368 Parameter::AddressPool(ref val) => {
5369 fidl::encoding::encode_in_envelope::<AddressPool, D>(
5370 <AddressPool as fidl::encoding::ValueTypeMarker>::borrow(val),
5371 encoder, offset + 8, _depth
5372 )
5373 }
5374 Parameter::Lease(ref val) => {
5375 fidl::encoding::encode_in_envelope::<LeaseLength, D>(
5376 <LeaseLength as fidl::encoding::ValueTypeMarker>::borrow(val),
5377 encoder, offset + 8, _depth
5378 )
5379 }
5380 Parameter::PermittedMacs(ref val) => {
5381 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D>(
5382 <fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5383 encoder, offset + 8, _depth
5384 )
5385 }
5386 Parameter::StaticallyAssignedAddrs(ref val) => {
5387 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<StaticAssignment, 256>, D>(
5388 <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5389 encoder, offset + 8, _depth
5390 )
5391 }
5392 Parameter::ArpProbe(ref val) => {
5393 fidl::encoding::encode_in_envelope::<bool, D>(
5394 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
5395 encoder, offset + 8, _depth
5396 )
5397 }
5398 Parameter::BoundDeviceNames(ref val) => {
5399 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>, D>(
5400 <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5401 encoder, offset + 8, _depth
5402 )
5403 }
5404 Parameter::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5405 }
5406 }
5407 }
5408
5409 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
5410 #[inline(always)]
5411 fn new_empty() -> Self {
5412 Self::__SourceBreaking { unknown_ordinal: 0 }
5413 }
5414
5415 #[inline]
5416 unsafe fn decode(
5417 &mut self,
5418 decoder: &mut fidl::encoding::Decoder<'_, D>,
5419 offset: usize,
5420 mut depth: fidl::encoding::Depth,
5421 ) -> fidl::Result<()> {
5422 decoder.debug_check_bounds::<Self>(offset);
5423 #[allow(unused_variables)]
5424 let next_out_of_line = decoder.next_out_of_line();
5425 let handles_before = decoder.remaining_handles();
5426 let (ordinal, inlined, num_bytes, num_handles) =
5427 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5428
5429 let member_inline_size = match ordinal {
5430 1 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5431 2 => <AddressPool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5432 3 => <LeaseLength as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5433 4 => <fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5434 5 => <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5435 6 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5436 7 => <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5437 0 => return Err(fidl::Error::UnknownUnionTag),
5438 _ => num_bytes as usize,
5439 };
5440
5441 if inlined != (member_inline_size <= 4) {
5442 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5443 }
5444 let _inner_offset;
5445 if inlined {
5446 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5447 _inner_offset = offset + 8;
5448 } else {
5449 depth.increment()?;
5450 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5451 }
5452 match ordinal {
5453 1 => {
5454 #[allow(irrefutable_let_patterns)]
5455 if let Parameter::IpAddrs(_) = self {
5456 } else {
5458 *self = Parameter::IpAddrs(
5460 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D),
5461 );
5462 }
5463 #[allow(irrefutable_let_patterns)]
5464 if let Parameter::IpAddrs(ref mut val) = self {
5465 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D, val, decoder, _inner_offset, depth)?;
5466 } else {
5467 unreachable!()
5468 }
5469 }
5470 2 => {
5471 #[allow(irrefutable_let_patterns)]
5472 if let Parameter::AddressPool(_) = self {
5473 } else {
5475 *self = Parameter::AddressPool(fidl::new_empty!(AddressPool, D));
5477 }
5478 #[allow(irrefutable_let_patterns)]
5479 if let Parameter::AddressPool(ref mut val) = self {
5480 fidl::decode!(AddressPool, D, val, decoder, _inner_offset, depth)?;
5481 } else {
5482 unreachable!()
5483 }
5484 }
5485 3 => {
5486 #[allow(irrefutable_let_patterns)]
5487 if let Parameter::Lease(_) = self {
5488 } else {
5490 *self = Parameter::Lease(fidl::new_empty!(LeaseLength, D));
5492 }
5493 #[allow(irrefutable_let_patterns)]
5494 if let Parameter::Lease(ref mut val) = self {
5495 fidl::decode!(LeaseLength, D, val, decoder, _inner_offset, depth)?;
5496 } else {
5497 unreachable!()
5498 }
5499 }
5500 4 => {
5501 #[allow(irrefutable_let_patterns)]
5502 if let Parameter::PermittedMacs(_) = self {
5503 } else {
5505 *self = Parameter::PermittedMacs(
5507 fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D),
5508 );
5509 }
5510 #[allow(irrefutable_let_patterns)]
5511 if let Parameter::PermittedMacs(ref mut val) = self {
5512 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D, val, decoder, _inner_offset, depth)?;
5513 } else {
5514 unreachable!()
5515 }
5516 }
5517 5 => {
5518 #[allow(irrefutable_let_patterns)]
5519 if let Parameter::StaticallyAssignedAddrs(_) = self {
5520 } else {
5522 *self = Parameter::StaticallyAssignedAddrs(
5524 fidl::new_empty!(fidl::encoding::Vector<StaticAssignment, 256>, D),
5525 );
5526 }
5527 #[allow(irrefutable_let_patterns)]
5528 if let Parameter::StaticallyAssignedAddrs(ref mut val) = self {
5529 fidl::decode!(fidl::encoding::Vector<StaticAssignment, 256>, D, val, decoder, _inner_offset, depth)?;
5530 } else {
5531 unreachable!()
5532 }
5533 }
5534 6 => {
5535 #[allow(irrefutable_let_patterns)]
5536 if let Parameter::ArpProbe(_) = self {
5537 } else {
5539 *self = Parameter::ArpProbe(fidl::new_empty!(bool, D));
5541 }
5542 #[allow(irrefutable_let_patterns)]
5543 if let Parameter::ArpProbe(ref mut val) = self {
5544 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
5545 } else {
5546 unreachable!()
5547 }
5548 }
5549 7 => {
5550 #[allow(irrefutable_let_patterns)]
5551 if let Parameter::BoundDeviceNames(_) = self {
5552 } else {
5554 *self = Parameter::BoundDeviceNames(fidl::new_empty!(
5556 fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
5557 D
5558 ));
5559 }
5560 #[allow(irrefutable_let_patterns)]
5561 if let Parameter::BoundDeviceNames(ref mut val) = self {
5562 fidl::decode!(
5563 fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
5564 D,
5565 val,
5566 decoder,
5567 _inner_offset,
5568 depth
5569 )?;
5570 } else {
5571 unreachable!()
5572 }
5573 }
5574 #[allow(deprecated)]
5575 ordinal => {
5576 for _ in 0..num_handles {
5577 decoder.drop_next_handle()?;
5578 }
5579 *self = Parameter::__SourceBreaking { unknown_ordinal: ordinal };
5580 }
5581 }
5582 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5583 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5584 }
5585 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5586 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5587 }
5588 Ok(())
5589 }
5590 }
5591}