1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13pub const MAX_ADDRESSES: u16 = 1024;
15
16#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18#[repr(u32)]
19pub enum LookupError {
20 NotFound = 1,
22 Transient = 2,
25 InvalidArgs = 3,
28 InternalError = 4,
30}
31
32impl LookupError {
33 #[inline]
34 pub fn from_primitive(prim: u32) -> Option<Self> {
35 match prim {
36 1 => Some(Self::NotFound),
37 2 => Some(Self::Transient),
38 3 => Some(Self::InvalidArgs),
39 4 => Some(Self::InternalError),
40 _ => None,
41 }
42 }
43
44 #[inline]
45 pub const fn into_primitive(self) -> u32 {
46 self as u32
47 }
48
49 #[deprecated = "Strict enums should not use `is_unknown`"]
50 #[inline]
51 pub fn is_unknown(&self) -> bool {
52 false
53 }
54}
55
56#[derive(Clone, Debug, PartialEq)]
57pub struct DnsServerWatcherWatchServersResponse {
58 pub servers: Vec<DnsServer_>,
59}
60
61impl fidl::Persistable for DnsServerWatcherWatchServersResponse {}
62
63#[derive(Clone, Debug, PartialEq)]
64pub struct LookupAdminGetDnsServersResponse {
65 pub servers: Vec<fidl_fuchsia_net::SocketAddress>,
66}
67
68impl fidl::Persistable for LookupAdminGetDnsServersResponse {}
69
70#[derive(Clone, Debug, PartialEq)]
71pub struct LookupAdminSetDnsServersRequest {
72 pub servers: Vec<fidl_fuchsia_net::SocketAddress>,
73}
74
75impl fidl::Persistable for LookupAdminSetDnsServersRequest {}
76
77#[derive(Clone, Debug, PartialEq)]
78pub struct LookupLookupHostnameRequest {
79 pub addr: fidl_fuchsia_net::IpAddress,
80}
81
82impl fidl::Persistable for LookupLookupHostnameRequest {}
83
84#[derive(Clone, Debug, PartialEq)]
85pub struct LookupLookupIpRequest {
86 pub hostname: String,
94 pub options: LookupIpOptions,
95}
96
97impl fidl::Persistable for LookupLookupIpRequest {}
98
99#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
100pub struct LookupLookupHostnameResponse {
101 pub hostname: String,
102}
103
104impl fidl::Persistable for LookupLookupHostnameResponse {}
105
106#[derive(Clone, Debug, PartialEq)]
107pub struct LookupLookupIpResponse {
108 pub result: LookupResult,
109}
110
111impl fidl::Persistable for LookupLookupIpResponse {}
112
113#[derive(Clone, Debug, Default, PartialEq)]
114pub struct DhcpDnsServerSource {
115 pub source_interface: Option<u64>,
117 #[doc(hidden)]
118 pub __source_breaking: fidl::marker::SourceBreaking,
119}
120
121impl fidl::Persistable for DhcpDnsServerSource {}
122
123#[derive(Clone, Debug, Default, PartialEq)]
124pub struct Dhcpv6DnsServerSource {
125 pub source_interface: Option<u64>,
127 #[doc(hidden)]
128 pub __source_breaking: fidl::marker::SourceBreaking,
129}
130
131impl fidl::Persistable for Dhcpv6DnsServerSource {}
132
133#[derive(Clone, Debug, Default, PartialEq)]
135pub struct DnsServer_ {
136 pub address: Option<fidl_fuchsia_net::SocketAddress>,
138 pub source: Option<DnsServerSource>,
141 #[doc(hidden)]
142 pub __source_breaking: fidl::marker::SourceBreaking,
143}
144
145impl fidl::Persistable for DnsServer_ {}
146
147#[derive(Clone, Debug, Default, PartialEq)]
148pub struct LookupIpOptions {
149 pub ipv4_lookup: Option<bool>,
153 pub ipv6_lookup: Option<bool>,
157 pub sort_addresses: Option<bool>,
165 pub canonical_name_lookup: Option<bool>,
169 #[doc(hidden)]
170 pub __source_breaking: fidl::marker::SourceBreaking,
171}
172
173impl fidl::Persistable for LookupIpOptions {}
174
175#[derive(Clone, Debug, Default, PartialEq)]
176pub struct LookupResult {
177 pub addresses: Option<Vec<fidl_fuchsia_net::IpAddress>>,
182 pub canonical_name: Option<String>,
186 #[doc(hidden)]
187 pub __source_breaking: fidl::marker::SourceBreaking,
188}
189
190impl fidl::Persistable for LookupResult {}
191
192#[derive(Clone, Debug, Default, PartialEq)]
193pub struct NdpDnsServerSource {
194 pub source_interface: Option<u64>,
196 #[doc(hidden)]
197 pub __source_breaking: fidl::marker::SourceBreaking,
198}
199
200impl fidl::Persistable for NdpDnsServerSource {}
201
202#[derive(Clone, Debug, Default, PartialEq)]
203pub struct StaticDnsServerSource {
204 #[doc(hidden)]
205 pub __source_breaking: fidl::marker::SourceBreaking,
206}
207
208impl fidl::Persistable for StaticDnsServerSource {}
209
210#[derive(Clone, Debug, PartialEq)]
211pub enum DnsServerSource {
212 StaticSource(StaticDnsServerSource),
215 Dhcp(DhcpDnsServerSource),
217 Ndp(NdpDnsServerSource),
219 Dhcpv6(Dhcpv6DnsServerSource),
221}
222
223impl DnsServerSource {
224 #[inline]
225 pub fn ordinal(&self) -> u64 {
226 match *self {
227 Self::StaticSource(_) => 1,
228 Self::Dhcp(_) => 2,
229 Self::Ndp(_) => 3,
230 Self::Dhcpv6(_) => 4,
231 }
232 }
233
234 #[deprecated = "Strict unions should not use `is_unknown`"]
235 #[inline]
236 pub fn is_unknown(&self) -> bool {
237 false
238 }
239}
240
241impl fidl::Persistable for DnsServerSource {}
242
243#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
244pub struct DnsServerWatcherMarker;
245
246impl fidl::endpoints::ProtocolMarker for DnsServerWatcherMarker {
247 type Proxy = DnsServerWatcherProxy;
248 type RequestStream = DnsServerWatcherRequestStream;
249 #[cfg(target_os = "fuchsia")]
250 type SynchronousProxy = DnsServerWatcherSynchronousProxy;
251
252 const DEBUG_NAME: &'static str = "fuchsia.net.name.DnsServerWatcher";
253}
254impl fidl::endpoints::DiscoverableProtocolMarker for DnsServerWatcherMarker {}
255
256pub trait DnsServerWatcherProxyInterface: Send + Sync {
257 type WatchServersResponseFut: std::future::Future<Output = Result<Vec<DnsServer_>, fidl::Error>>
258 + Send;
259 fn r#watch_servers(&self) -> Self::WatchServersResponseFut;
260}
261#[derive(Debug)]
262#[cfg(target_os = "fuchsia")]
263pub struct DnsServerWatcherSynchronousProxy {
264 client: fidl::client::sync::Client,
265}
266
267#[cfg(target_os = "fuchsia")]
268impl fidl::endpoints::SynchronousProxy for DnsServerWatcherSynchronousProxy {
269 type Proxy = DnsServerWatcherProxy;
270 type Protocol = DnsServerWatcherMarker;
271
272 fn from_channel(inner: fidl::Channel) -> Self {
273 Self::new(inner)
274 }
275
276 fn into_channel(self) -> fidl::Channel {
277 self.client.into_channel()
278 }
279
280 fn as_channel(&self) -> &fidl::Channel {
281 self.client.as_channel()
282 }
283}
284
285#[cfg(target_os = "fuchsia")]
286impl DnsServerWatcherSynchronousProxy {
287 pub fn new(channel: fidl::Channel) -> Self {
288 let protocol_name = <DnsServerWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
289 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
290 }
291
292 pub fn into_channel(self) -> fidl::Channel {
293 self.client.into_channel()
294 }
295
296 pub fn wait_for_event(
299 &self,
300 deadline: zx::MonotonicInstant,
301 ) -> Result<DnsServerWatcherEvent, fidl::Error> {
302 DnsServerWatcherEvent::decode(self.client.wait_for_event(deadline)?)
303 }
304
305 pub fn r#watch_servers(
319 &self,
320 ___deadline: zx::MonotonicInstant,
321 ) -> Result<Vec<DnsServer_>, fidl::Error> {
322 let _response = self
323 .client
324 .send_query::<fidl::encoding::EmptyPayload, DnsServerWatcherWatchServersResponse>(
325 (),
326 0x5748907e7f11b632,
327 fidl::encoding::DynamicFlags::empty(),
328 ___deadline,
329 )?;
330 Ok(_response.servers)
331 }
332}
333
334#[derive(Debug, Clone)]
335pub struct DnsServerWatcherProxy {
336 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
337}
338
339impl fidl::endpoints::Proxy for DnsServerWatcherProxy {
340 type Protocol = DnsServerWatcherMarker;
341
342 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
343 Self::new(inner)
344 }
345
346 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
347 self.client.into_channel().map_err(|client| Self { client })
348 }
349
350 fn as_channel(&self) -> &::fidl::AsyncChannel {
351 self.client.as_channel()
352 }
353}
354
355impl DnsServerWatcherProxy {
356 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
358 let protocol_name = <DnsServerWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
359 Self { client: fidl::client::Client::new(channel, protocol_name) }
360 }
361
362 pub fn take_event_stream(&self) -> DnsServerWatcherEventStream {
368 DnsServerWatcherEventStream { event_receiver: self.client.take_event_receiver() }
369 }
370
371 pub fn r#watch_servers(
385 &self,
386 ) -> fidl::client::QueryResponseFut<
387 Vec<DnsServer_>,
388 fidl::encoding::DefaultFuchsiaResourceDialect,
389 > {
390 DnsServerWatcherProxyInterface::r#watch_servers(self)
391 }
392}
393
394impl DnsServerWatcherProxyInterface for DnsServerWatcherProxy {
395 type WatchServersResponseFut = fidl::client::QueryResponseFut<
396 Vec<DnsServer_>,
397 fidl::encoding::DefaultFuchsiaResourceDialect,
398 >;
399 fn r#watch_servers(&self) -> Self::WatchServersResponseFut {
400 fn _decode(
401 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
402 ) -> Result<Vec<DnsServer_>, fidl::Error> {
403 let _response = fidl::client::decode_transaction_body::<
404 DnsServerWatcherWatchServersResponse,
405 fidl::encoding::DefaultFuchsiaResourceDialect,
406 0x5748907e7f11b632,
407 >(_buf?)?;
408 Ok(_response.servers)
409 }
410 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<DnsServer_>>(
411 (),
412 0x5748907e7f11b632,
413 fidl::encoding::DynamicFlags::empty(),
414 _decode,
415 )
416 }
417}
418
419pub struct DnsServerWatcherEventStream {
420 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
421}
422
423impl std::marker::Unpin for DnsServerWatcherEventStream {}
424
425impl futures::stream::FusedStream for DnsServerWatcherEventStream {
426 fn is_terminated(&self) -> bool {
427 self.event_receiver.is_terminated()
428 }
429}
430
431impl futures::Stream for DnsServerWatcherEventStream {
432 type Item = Result<DnsServerWatcherEvent, fidl::Error>;
433
434 fn poll_next(
435 mut self: std::pin::Pin<&mut Self>,
436 cx: &mut std::task::Context<'_>,
437 ) -> std::task::Poll<Option<Self::Item>> {
438 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
439 &mut self.event_receiver,
440 cx
441 )?) {
442 Some(buf) => std::task::Poll::Ready(Some(DnsServerWatcherEvent::decode(buf))),
443 None => std::task::Poll::Ready(None),
444 }
445 }
446}
447
448#[derive(Debug)]
449pub enum DnsServerWatcherEvent {}
450
451impl DnsServerWatcherEvent {
452 fn decode(
454 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
455 ) -> Result<DnsServerWatcherEvent, fidl::Error> {
456 let (bytes, _handles) = buf.split_mut();
457 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
458 debug_assert_eq!(tx_header.tx_id, 0);
459 match tx_header.ordinal {
460 _ => Err(fidl::Error::UnknownOrdinal {
461 ordinal: tx_header.ordinal,
462 protocol_name:
463 <DnsServerWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
464 }),
465 }
466 }
467}
468
469pub struct DnsServerWatcherRequestStream {
471 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
472 is_terminated: bool,
473}
474
475impl std::marker::Unpin for DnsServerWatcherRequestStream {}
476
477impl futures::stream::FusedStream for DnsServerWatcherRequestStream {
478 fn is_terminated(&self) -> bool {
479 self.is_terminated
480 }
481}
482
483impl fidl::endpoints::RequestStream for DnsServerWatcherRequestStream {
484 type Protocol = DnsServerWatcherMarker;
485 type ControlHandle = DnsServerWatcherControlHandle;
486
487 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
488 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
489 }
490
491 fn control_handle(&self) -> Self::ControlHandle {
492 DnsServerWatcherControlHandle { inner: self.inner.clone() }
493 }
494
495 fn into_inner(
496 self,
497 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
498 {
499 (self.inner, self.is_terminated)
500 }
501
502 fn from_inner(
503 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
504 is_terminated: bool,
505 ) -> Self {
506 Self { inner, is_terminated }
507 }
508}
509
510impl futures::Stream for DnsServerWatcherRequestStream {
511 type Item = Result<DnsServerWatcherRequest, fidl::Error>;
512
513 fn poll_next(
514 mut self: std::pin::Pin<&mut Self>,
515 cx: &mut std::task::Context<'_>,
516 ) -> std::task::Poll<Option<Self::Item>> {
517 let this = &mut *self;
518 if this.inner.check_shutdown(cx) {
519 this.is_terminated = true;
520 return std::task::Poll::Ready(None);
521 }
522 if this.is_terminated {
523 panic!("polled DnsServerWatcherRequestStream after completion");
524 }
525 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
526 |bytes, handles| {
527 match this.inner.channel().read_etc(cx, bytes, handles) {
528 std::task::Poll::Ready(Ok(())) => {}
529 std::task::Poll::Pending => return std::task::Poll::Pending,
530 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
531 this.is_terminated = true;
532 return std::task::Poll::Ready(None);
533 }
534 std::task::Poll::Ready(Err(e)) => {
535 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
536 e.into(),
537 ))))
538 }
539 }
540
541 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
543
544 std::task::Poll::Ready(Some(match header.ordinal {
545 0x5748907e7f11b632 => {
546 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
547 let mut req = fidl::new_empty!(
548 fidl::encoding::EmptyPayload,
549 fidl::encoding::DefaultFuchsiaResourceDialect
550 );
551 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
552 let control_handle =
553 DnsServerWatcherControlHandle { inner: this.inner.clone() };
554 Ok(DnsServerWatcherRequest::WatchServers {
555 responder: DnsServerWatcherWatchServersResponder {
556 control_handle: std::mem::ManuallyDrop::new(control_handle),
557 tx_id: header.tx_id,
558 },
559 })
560 }
561 _ => Err(fidl::Error::UnknownOrdinal {
562 ordinal: header.ordinal,
563 protocol_name:
564 <DnsServerWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
565 }),
566 }))
567 },
568 )
569 }
570}
571
572#[derive(Debug)]
574pub enum DnsServerWatcherRequest {
575 WatchServers { responder: DnsServerWatcherWatchServersResponder },
589}
590
591impl DnsServerWatcherRequest {
592 #[allow(irrefutable_let_patterns)]
593 pub fn into_watch_servers(self) -> Option<(DnsServerWatcherWatchServersResponder)> {
594 if let DnsServerWatcherRequest::WatchServers { responder } = self {
595 Some((responder))
596 } else {
597 None
598 }
599 }
600
601 pub fn method_name(&self) -> &'static str {
603 match *self {
604 DnsServerWatcherRequest::WatchServers { .. } => "watch_servers",
605 }
606 }
607}
608
609#[derive(Debug, Clone)]
610pub struct DnsServerWatcherControlHandle {
611 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
612}
613
614impl fidl::endpoints::ControlHandle for DnsServerWatcherControlHandle {
615 fn shutdown(&self) {
616 self.inner.shutdown()
617 }
618 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
619 self.inner.shutdown_with_epitaph(status)
620 }
621
622 fn is_closed(&self) -> bool {
623 self.inner.channel().is_closed()
624 }
625 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
626 self.inner.channel().on_closed()
627 }
628
629 #[cfg(target_os = "fuchsia")]
630 fn signal_peer(
631 &self,
632 clear_mask: zx::Signals,
633 set_mask: zx::Signals,
634 ) -> Result<(), zx_status::Status> {
635 use fidl::Peered;
636 self.inner.channel().signal_peer(clear_mask, set_mask)
637 }
638}
639
640impl DnsServerWatcherControlHandle {}
641
642#[must_use = "FIDL methods require a response to be sent"]
643#[derive(Debug)]
644pub struct DnsServerWatcherWatchServersResponder {
645 control_handle: std::mem::ManuallyDrop<DnsServerWatcherControlHandle>,
646 tx_id: u32,
647}
648
649impl std::ops::Drop for DnsServerWatcherWatchServersResponder {
653 fn drop(&mut self) {
654 self.control_handle.shutdown();
655 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
657 }
658}
659
660impl fidl::endpoints::Responder for DnsServerWatcherWatchServersResponder {
661 type ControlHandle = DnsServerWatcherControlHandle;
662
663 fn control_handle(&self) -> &DnsServerWatcherControlHandle {
664 &self.control_handle
665 }
666
667 fn drop_without_shutdown(mut self) {
668 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
670 std::mem::forget(self);
672 }
673}
674
675impl DnsServerWatcherWatchServersResponder {
676 pub fn send(self, mut servers: &[DnsServer_]) -> Result<(), fidl::Error> {
680 let _result = self.send_raw(servers);
681 if _result.is_err() {
682 self.control_handle.shutdown();
683 }
684 self.drop_without_shutdown();
685 _result
686 }
687
688 pub fn send_no_shutdown_on_err(self, mut servers: &[DnsServer_]) -> Result<(), fidl::Error> {
690 let _result = self.send_raw(servers);
691 self.drop_without_shutdown();
692 _result
693 }
694
695 fn send_raw(&self, mut servers: &[DnsServer_]) -> Result<(), fidl::Error> {
696 self.control_handle.inner.send::<DnsServerWatcherWatchServersResponse>(
697 (servers,),
698 self.tx_id,
699 0x5748907e7f11b632,
700 fidl::encoding::DynamicFlags::empty(),
701 )
702 }
703}
704
705#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
706pub struct LookupMarker;
707
708impl fidl::endpoints::ProtocolMarker for LookupMarker {
709 type Proxy = LookupProxy;
710 type RequestStream = LookupRequestStream;
711 #[cfg(target_os = "fuchsia")]
712 type SynchronousProxy = LookupSynchronousProxy;
713
714 const DEBUG_NAME: &'static str = "fuchsia.net.name.Lookup";
715}
716impl fidl::endpoints::DiscoverableProtocolMarker for LookupMarker {}
717pub type LookupLookupIpResult = Result<LookupResult, LookupError>;
718pub type LookupLookupHostnameResult = Result<String, LookupError>;
719
720pub trait LookupProxyInterface: Send + Sync {
721 type LookupIpResponseFut: std::future::Future<Output = Result<LookupLookupIpResult, fidl::Error>>
722 + Send;
723 fn r#lookup_ip(&self, hostname: &str, options: &LookupIpOptions) -> Self::LookupIpResponseFut;
724 type LookupHostnameResponseFut: std::future::Future<Output = Result<LookupLookupHostnameResult, fidl::Error>>
725 + Send;
726 fn r#lookup_hostname(
727 &self,
728 addr: &fidl_fuchsia_net::IpAddress,
729 ) -> Self::LookupHostnameResponseFut;
730}
731#[derive(Debug)]
732#[cfg(target_os = "fuchsia")]
733pub struct LookupSynchronousProxy {
734 client: fidl::client::sync::Client,
735}
736
737#[cfg(target_os = "fuchsia")]
738impl fidl::endpoints::SynchronousProxy for LookupSynchronousProxy {
739 type Proxy = LookupProxy;
740 type Protocol = LookupMarker;
741
742 fn from_channel(inner: fidl::Channel) -> Self {
743 Self::new(inner)
744 }
745
746 fn into_channel(self) -> fidl::Channel {
747 self.client.into_channel()
748 }
749
750 fn as_channel(&self) -> &fidl::Channel {
751 self.client.as_channel()
752 }
753}
754
755#[cfg(target_os = "fuchsia")]
756impl LookupSynchronousProxy {
757 pub fn new(channel: fidl::Channel) -> Self {
758 let protocol_name = <LookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
759 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
760 }
761
762 pub fn into_channel(self) -> fidl::Channel {
763 self.client.into_channel()
764 }
765
766 pub fn wait_for_event(
769 &self,
770 deadline: zx::MonotonicInstant,
771 ) -> Result<LookupEvent, fidl::Error> {
772 LookupEvent::decode(self.client.wait_for_event(deadline)?)
773 }
774
775 pub fn r#lookup_ip(
777 &self,
778 mut hostname: &str,
779 mut options: &LookupIpOptions,
780 ___deadline: zx::MonotonicInstant,
781 ) -> Result<LookupLookupIpResult, fidl::Error> {
782 let _response = self.client.send_query::<
783 LookupLookupIpRequest,
784 fidl::encoding::ResultType<LookupLookupIpResponse, LookupError>,
785 >(
786 (hostname, options,),
787 0x59247caf7560c1d0,
788 fidl::encoding::DynamicFlags::empty(),
789 ___deadline,
790 )?;
791 Ok(_response.map(|x| x.result))
792 }
793
794 pub fn r#lookup_hostname(
796 &self,
797 mut addr: &fidl_fuchsia_net::IpAddress,
798 ___deadline: zx::MonotonicInstant,
799 ) -> Result<LookupLookupHostnameResult, fidl::Error> {
800 let _response = self.client.send_query::<
801 LookupLookupHostnameRequest,
802 fidl::encoding::ResultType<LookupLookupHostnameResponse, LookupError>,
803 >(
804 (addr,),
805 0x1b456b0e84888324,
806 fidl::encoding::DynamicFlags::empty(),
807 ___deadline,
808 )?;
809 Ok(_response.map(|x| x.hostname))
810 }
811}
812
813#[derive(Debug, Clone)]
814pub struct LookupProxy {
815 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
816}
817
818impl fidl::endpoints::Proxy for LookupProxy {
819 type Protocol = LookupMarker;
820
821 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
822 Self::new(inner)
823 }
824
825 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
826 self.client.into_channel().map_err(|client| Self { client })
827 }
828
829 fn as_channel(&self) -> &::fidl::AsyncChannel {
830 self.client.as_channel()
831 }
832}
833
834impl LookupProxy {
835 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
837 let protocol_name = <LookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
838 Self { client: fidl::client::Client::new(channel, protocol_name) }
839 }
840
841 pub fn take_event_stream(&self) -> LookupEventStream {
847 LookupEventStream { event_receiver: self.client.take_event_receiver() }
848 }
849
850 pub fn r#lookup_ip(
852 &self,
853 mut hostname: &str,
854 mut options: &LookupIpOptions,
855 ) -> fidl::client::QueryResponseFut<
856 LookupLookupIpResult,
857 fidl::encoding::DefaultFuchsiaResourceDialect,
858 > {
859 LookupProxyInterface::r#lookup_ip(self, hostname, options)
860 }
861
862 pub fn r#lookup_hostname(
864 &self,
865 mut addr: &fidl_fuchsia_net::IpAddress,
866 ) -> fidl::client::QueryResponseFut<
867 LookupLookupHostnameResult,
868 fidl::encoding::DefaultFuchsiaResourceDialect,
869 > {
870 LookupProxyInterface::r#lookup_hostname(self, addr)
871 }
872}
873
874impl LookupProxyInterface for LookupProxy {
875 type LookupIpResponseFut = fidl::client::QueryResponseFut<
876 LookupLookupIpResult,
877 fidl::encoding::DefaultFuchsiaResourceDialect,
878 >;
879 fn r#lookup_ip(
880 &self,
881 mut hostname: &str,
882 mut options: &LookupIpOptions,
883 ) -> Self::LookupIpResponseFut {
884 fn _decode(
885 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
886 ) -> Result<LookupLookupIpResult, fidl::Error> {
887 let _response = fidl::client::decode_transaction_body::<
888 fidl::encoding::ResultType<LookupLookupIpResponse, LookupError>,
889 fidl::encoding::DefaultFuchsiaResourceDialect,
890 0x59247caf7560c1d0,
891 >(_buf?)?;
892 Ok(_response.map(|x| x.result))
893 }
894 self.client.send_query_and_decode::<LookupLookupIpRequest, LookupLookupIpResult>(
895 (hostname, options),
896 0x59247caf7560c1d0,
897 fidl::encoding::DynamicFlags::empty(),
898 _decode,
899 )
900 }
901
902 type LookupHostnameResponseFut = fidl::client::QueryResponseFut<
903 LookupLookupHostnameResult,
904 fidl::encoding::DefaultFuchsiaResourceDialect,
905 >;
906 fn r#lookup_hostname(
907 &self,
908 mut addr: &fidl_fuchsia_net::IpAddress,
909 ) -> Self::LookupHostnameResponseFut {
910 fn _decode(
911 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
912 ) -> Result<LookupLookupHostnameResult, fidl::Error> {
913 let _response = fidl::client::decode_transaction_body::<
914 fidl::encoding::ResultType<LookupLookupHostnameResponse, LookupError>,
915 fidl::encoding::DefaultFuchsiaResourceDialect,
916 0x1b456b0e84888324,
917 >(_buf?)?;
918 Ok(_response.map(|x| x.hostname))
919 }
920 self.client
921 .send_query_and_decode::<LookupLookupHostnameRequest, LookupLookupHostnameResult>(
922 (addr,),
923 0x1b456b0e84888324,
924 fidl::encoding::DynamicFlags::empty(),
925 _decode,
926 )
927 }
928}
929
930pub struct LookupEventStream {
931 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
932}
933
934impl std::marker::Unpin for LookupEventStream {}
935
936impl futures::stream::FusedStream for LookupEventStream {
937 fn is_terminated(&self) -> bool {
938 self.event_receiver.is_terminated()
939 }
940}
941
942impl futures::Stream for LookupEventStream {
943 type Item = Result<LookupEvent, fidl::Error>;
944
945 fn poll_next(
946 mut self: std::pin::Pin<&mut Self>,
947 cx: &mut std::task::Context<'_>,
948 ) -> std::task::Poll<Option<Self::Item>> {
949 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
950 &mut self.event_receiver,
951 cx
952 )?) {
953 Some(buf) => std::task::Poll::Ready(Some(LookupEvent::decode(buf))),
954 None => std::task::Poll::Ready(None),
955 }
956 }
957}
958
959#[derive(Debug)]
960pub enum LookupEvent {}
961
962impl LookupEvent {
963 fn decode(
965 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
966 ) -> Result<LookupEvent, fidl::Error> {
967 let (bytes, _handles) = buf.split_mut();
968 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
969 debug_assert_eq!(tx_header.tx_id, 0);
970 match tx_header.ordinal {
971 _ => Err(fidl::Error::UnknownOrdinal {
972 ordinal: tx_header.ordinal,
973 protocol_name: <LookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
974 }),
975 }
976 }
977}
978
979pub struct LookupRequestStream {
981 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
982 is_terminated: bool,
983}
984
985impl std::marker::Unpin for LookupRequestStream {}
986
987impl futures::stream::FusedStream for LookupRequestStream {
988 fn is_terminated(&self) -> bool {
989 self.is_terminated
990 }
991}
992
993impl fidl::endpoints::RequestStream for LookupRequestStream {
994 type Protocol = LookupMarker;
995 type ControlHandle = LookupControlHandle;
996
997 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
998 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
999 }
1000
1001 fn control_handle(&self) -> Self::ControlHandle {
1002 LookupControlHandle { inner: self.inner.clone() }
1003 }
1004
1005 fn into_inner(
1006 self,
1007 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1008 {
1009 (self.inner, self.is_terminated)
1010 }
1011
1012 fn from_inner(
1013 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1014 is_terminated: bool,
1015 ) -> Self {
1016 Self { inner, is_terminated }
1017 }
1018}
1019
1020impl futures::Stream for LookupRequestStream {
1021 type Item = Result<LookupRequest, fidl::Error>;
1022
1023 fn poll_next(
1024 mut self: std::pin::Pin<&mut Self>,
1025 cx: &mut std::task::Context<'_>,
1026 ) -> std::task::Poll<Option<Self::Item>> {
1027 let this = &mut *self;
1028 if this.inner.check_shutdown(cx) {
1029 this.is_terminated = true;
1030 return std::task::Poll::Ready(None);
1031 }
1032 if this.is_terminated {
1033 panic!("polled LookupRequestStream after completion");
1034 }
1035 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1036 |bytes, handles| {
1037 match this.inner.channel().read_etc(cx, bytes, handles) {
1038 std::task::Poll::Ready(Ok(())) => {}
1039 std::task::Poll::Pending => return std::task::Poll::Pending,
1040 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1041 this.is_terminated = true;
1042 return std::task::Poll::Ready(None);
1043 }
1044 std::task::Poll::Ready(Err(e)) => {
1045 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1046 e.into(),
1047 ))))
1048 }
1049 }
1050
1051 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1053
1054 std::task::Poll::Ready(Some(match header.ordinal {
1055 0x59247caf7560c1d0 => {
1056 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1057 let mut req = fidl::new_empty!(
1058 LookupLookupIpRequest,
1059 fidl::encoding::DefaultFuchsiaResourceDialect
1060 );
1061 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LookupLookupIpRequest>(&header, _body_bytes, handles, &mut req)?;
1062 let control_handle = LookupControlHandle { inner: this.inner.clone() };
1063 Ok(LookupRequest::LookupIp {
1064 hostname: req.hostname,
1065 options: req.options,
1066
1067 responder: LookupLookupIpResponder {
1068 control_handle: std::mem::ManuallyDrop::new(control_handle),
1069 tx_id: header.tx_id,
1070 },
1071 })
1072 }
1073 0x1b456b0e84888324 => {
1074 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1075 let mut req = fidl::new_empty!(
1076 LookupLookupHostnameRequest,
1077 fidl::encoding::DefaultFuchsiaResourceDialect
1078 );
1079 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LookupLookupHostnameRequest>(&header, _body_bytes, handles, &mut req)?;
1080 let control_handle = LookupControlHandle { inner: this.inner.clone() };
1081 Ok(LookupRequest::LookupHostname {
1082 addr: req.addr,
1083
1084 responder: LookupLookupHostnameResponder {
1085 control_handle: std::mem::ManuallyDrop::new(control_handle),
1086 tx_id: header.tx_id,
1087 },
1088 })
1089 }
1090 _ => Err(fidl::Error::UnknownOrdinal {
1091 ordinal: header.ordinal,
1092 protocol_name:
1093 <LookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1094 }),
1095 }))
1096 },
1097 )
1098 }
1099}
1100
1101#[derive(Debug)]
1103pub enum LookupRequest {
1104 LookupIp { hostname: String, options: LookupIpOptions, responder: LookupLookupIpResponder },
1106 LookupHostname { addr: fidl_fuchsia_net::IpAddress, responder: LookupLookupHostnameResponder },
1108}
1109
1110impl LookupRequest {
1111 #[allow(irrefutable_let_patterns)]
1112 pub fn into_lookup_ip(self) -> Option<(String, LookupIpOptions, LookupLookupIpResponder)> {
1113 if let LookupRequest::LookupIp { hostname, options, responder } = self {
1114 Some((hostname, options, responder))
1115 } else {
1116 None
1117 }
1118 }
1119
1120 #[allow(irrefutable_let_patterns)]
1121 pub fn into_lookup_hostname(
1122 self,
1123 ) -> Option<(fidl_fuchsia_net::IpAddress, LookupLookupHostnameResponder)> {
1124 if let LookupRequest::LookupHostname { addr, responder } = self {
1125 Some((addr, responder))
1126 } else {
1127 None
1128 }
1129 }
1130
1131 pub fn method_name(&self) -> &'static str {
1133 match *self {
1134 LookupRequest::LookupIp { .. } => "lookup_ip",
1135 LookupRequest::LookupHostname { .. } => "lookup_hostname",
1136 }
1137 }
1138}
1139
1140#[derive(Debug, Clone)]
1141pub struct LookupControlHandle {
1142 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1143}
1144
1145impl fidl::endpoints::ControlHandle for LookupControlHandle {
1146 fn shutdown(&self) {
1147 self.inner.shutdown()
1148 }
1149 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1150 self.inner.shutdown_with_epitaph(status)
1151 }
1152
1153 fn is_closed(&self) -> bool {
1154 self.inner.channel().is_closed()
1155 }
1156 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1157 self.inner.channel().on_closed()
1158 }
1159
1160 #[cfg(target_os = "fuchsia")]
1161 fn signal_peer(
1162 &self,
1163 clear_mask: zx::Signals,
1164 set_mask: zx::Signals,
1165 ) -> Result<(), zx_status::Status> {
1166 use fidl::Peered;
1167 self.inner.channel().signal_peer(clear_mask, set_mask)
1168 }
1169}
1170
1171impl LookupControlHandle {}
1172
1173#[must_use = "FIDL methods require a response to be sent"]
1174#[derive(Debug)]
1175pub struct LookupLookupIpResponder {
1176 control_handle: std::mem::ManuallyDrop<LookupControlHandle>,
1177 tx_id: u32,
1178}
1179
1180impl std::ops::Drop for LookupLookupIpResponder {
1184 fn drop(&mut self) {
1185 self.control_handle.shutdown();
1186 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1188 }
1189}
1190
1191impl fidl::endpoints::Responder for LookupLookupIpResponder {
1192 type ControlHandle = LookupControlHandle;
1193
1194 fn control_handle(&self) -> &LookupControlHandle {
1195 &self.control_handle
1196 }
1197
1198 fn drop_without_shutdown(mut self) {
1199 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1201 std::mem::forget(self);
1203 }
1204}
1205
1206impl LookupLookupIpResponder {
1207 pub fn send(self, mut result: Result<&LookupResult, LookupError>) -> Result<(), fidl::Error> {
1211 let _result = self.send_raw(result);
1212 if _result.is_err() {
1213 self.control_handle.shutdown();
1214 }
1215 self.drop_without_shutdown();
1216 _result
1217 }
1218
1219 pub fn send_no_shutdown_on_err(
1221 self,
1222 mut result: Result<&LookupResult, LookupError>,
1223 ) -> Result<(), fidl::Error> {
1224 let _result = self.send_raw(result);
1225 self.drop_without_shutdown();
1226 _result
1227 }
1228
1229 fn send_raw(&self, mut result: Result<&LookupResult, LookupError>) -> Result<(), fidl::Error> {
1230 self.control_handle
1231 .inner
1232 .send::<fidl::encoding::ResultType<LookupLookupIpResponse, LookupError>>(
1233 result.map(|result| (result,)),
1234 self.tx_id,
1235 0x59247caf7560c1d0,
1236 fidl::encoding::DynamicFlags::empty(),
1237 )
1238 }
1239}
1240
1241#[must_use = "FIDL methods require a response to be sent"]
1242#[derive(Debug)]
1243pub struct LookupLookupHostnameResponder {
1244 control_handle: std::mem::ManuallyDrop<LookupControlHandle>,
1245 tx_id: u32,
1246}
1247
1248impl std::ops::Drop for LookupLookupHostnameResponder {
1252 fn drop(&mut self) {
1253 self.control_handle.shutdown();
1254 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1256 }
1257}
1258
1259impl fidl::endpoints::Responder for LookupLookupHostnameResponder {
1260 type ControlHandle = LookupControlHandle;
1261
1262 fn control_handle(&self) -> &LookupControlHandle {
1263 &self.control_handle
1264 }
1265
1266 fn drop_without_shutdown(mut self) {
1267 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1269 std::mem::forget(self);
1271 }
1272}
1273
1274impl LookupLookupHostnameResponder {
1275 pub fn send(self, mut result: Result<&str, LookupError>) -> Result<(), fidl::Error> {
1279 let _result = self.send_raw(result);
1280 if _result.is_err() {
1281 self.control_handle.shutdown();
1282 }
1283 self.drop_without_shutdown();
1284 _result
1285 }
1286
1287 pub fn send_no_shutdown_on_err(
1289 self,
1290 mut result: Result<&str, LookupError>,
1291 ) -> Result<(), fidl::Error> {
1292 let _result = self.send_raw(result);
1293 self.drop_without_shutdown();
1294 _result
1295 }
1296
1297 fn send_raw(&self, mut result: Result<&str, LookupError>) -> Result<(), fidl::Error> {
1298 self.control_handle.inner.send::<fidl::encoding::ResultType<
1299 LookupLookupHostnameResponse,
1300 LookupError,
1301 >>(
1302 result.map(|hostname| (hostname,)),
1303 self.tx_id,
1304 0x1b456b0e84888324,
1305 fidl::encoding::DynamicFlags::empty(),
1306 )
1307 }
1308}
1309
1310#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1311pub struct LookupAdminMarker;
1312
1313impl fidl::endpoints::ProtocolMarker for LookupAdminMarker {
1314 type Proxy = LookupAdminProxy;
1315 type RequestStream = LookupAdminRequestStream;
1316 #[cfg(target_os = "fuchsia")]
1317 type SynchronousProxy = LookupAdminSynchronousProxy;
1318
1319 const DEBUG_NAME: &'static str = "fuchsia.net.name.LookupAdmin";
1320}
1321impl fidl::endpoints::DiscoverableProtocolMarker for LookupAdminMarker {}
1322pub type LookupAdminSetDnsServersResult = Result<(), i32>;
1323
1324pub trait LookupAdminProxyInterface: Send + Sync {
1325 type SetDnsServersResponseFut: std::future::Future<Output = Result<LookupAdminSetDnsServersResult, fidl::Error>>
1326 + Send;
1327 fn r#set_dns_servers(
1328 &self,
1329 servers: &[fidl_fuchsia_net::SocketAddress],
1330 ) -> Self::SetDnsServersResponseFut;
1331 type GetDnsServersResponseFut: std::future::Future<Output = Result<Vec<fidl_fuchsia_net::SocketAddress>, fidl::Error>>
1332 + Send;
1333 fn r#get_dns_servers(&self) -> Self::GetDnsServersResponseFut;
1334}
1335#[derive(Debug)]
1336#[cfg(target_os = "fuchsia")]
1337pub struct LookupAdminSynchronousProxy {
1338 client: fidl::client::sync::Client,
1339}
1340
1341#[cfg(target_os = "fuchsia")]
1342impl fidl::endpoints::SynchronousProxy for LookupAdminSynchronousProxy {
1343 type Proxy = LookupAdminProxy;
1344 type Protocol = LookupAdminMarker;
1345
1346 fn from_channel(inner: fidl::Channel) -> Self {
1347 Self::new(inner)
1348 }
1349
1350 fn into_channel(self) -> fidl::Channel {
1351 self.client.into_channel()
1352 }
1353
1354 fn as_channel(&self) -> &fidl::Channel {
1355 self.client.as_channel()
1356 }
1357}
1358
1359#[cfg(target_os = "fuchsia")]
1360impl LookupAdminSynchronousProxy {
1361 pub fn new(channel: fidl::Channel) -> Self {
1362 let protocol_name = <LookupAdminMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1363 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1364 }
1365
1366 pub fn into_channel(self) -> fidl::Channel {
1367 self.client.into_channel()
1368 }
1369
1370 pub fn wait_for_event(
1373 &self,
1374 deadline: zx::MonotonicInstant,
1375 ) -> Result<LookupAdminEvent, fidl::Error> {
1376 LookupAdminEvent::decode(self.client.wait_for_event(deadline)?)
1377 }
1378
1379 pub fn r#set_dns_servers(
1388 &self,
1389 mut servers: &[fidl_fuchsia_net::SocketAddress],
1390 ___deadline: zx::MonotonicInstant,
1391 ) -> Result<LookupAdminSetDnsServersResult, fidl::Error> {
1392 let _response = self.client.send_query::<
1393 LookupAdminSetDnsServersRequest,
1394 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
1395 >(
1396 (servers,),
1397 0x55e2b9fcc777be96,
1398 fidl::encoding::DynamicFlags::empty(),
1399 ___deadline,
1400 )?;
1401 Ok(_response.map(|x| x))
1402 }
1403
1404 pub fn r#get_dns_servers(
1407 &self,
1408 ___deadline: zx::MonotonicInstant,
1409 ) -> Result<Vec<fidl_fuchsia_net::SocketAddress>, fidl::Error> {
1410 let _response = self
1411 .client
1412 .send_query::<fidl::encoding::EmptyPayload, LookupAdminGetDnsServersResponse>(
1413 (),
1414 0x614303bf6e72f80f,
1415 fidl::encoding::DynamicFlags::empty(),
1416 ___deadline,
1417 )?;
1418 Ok(_response.servers)
1419 }
1420}
1421
1422#[derive(Debug, Clone)]
1423pub struct LookupAdminProxy {
1424 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1425}
1426
1427impl fidl::endpoints::Proxy for LookupAdminProxy {
1428 type Protocol = LookupAdminMarker;
1429
1430 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1431 Self::new(inner)
1432 }
1433
1434 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1435 self.client.into_channel().map_err(|client| Self { client })
1436 }
1437
1438 fn as_channel(&self) -> &::fidl::AsyncChannel {
1439 self.client.as_channel()
1440 }
1441}
1442
1443impl LookupAdminProxy {
1444 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1446 let protocol_name = <LookupAdminMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1447 Self { client: fidl::client::Client::new(channel, protocol_name) }
1448 }
1449
1450 pub fn take_event_stream(&self) -> LookupAdminEventStream {
1456 LookupAdminEventStream { event_receiver: self.client.take_event_receiver() }
1457 }
1458
1459 pub fn r#set_dns_servers(
1468 &self,
1469 mut servers: &[fidl_fuchsia_net::SocketAddress],
1470 ) -> fidl::client::QueryResponseFut<
1471 LookupAdminSetDnsServersResult,
1472 fidl::encoding::DefaultFuchsiaResourceDialect,
1473 > {
1474 LookupAdminProxyInterface::r#set_dns_servers(self, servers)
1475 }
1476
1477 pub fn r#get_dns_servers(
1480 &self,
1481 ) -> fidl::client::QueryResponseFut<
1482 Vec<fidl_fuchsia_net::SocketAddress>,
1483 fidl::encoding::DefaultFuchsiaResourceDialect,
1484 > {
1485 LookupAdminProxyInterface::r#get_dns_servers(self)
1486 }
1487}
1488
1489impl LookupAdminProxyInterface for LookupAdminProxy {
1490 type SetDnsServersResponseFut = fidl::client::QueryResponseFut<
1491 LookupAdminSetDnsServersResult,
1492 fidl::encoding::DefaultFuchsiaResourceDialect,
1493 >;
1494 fn r#set_dns_servers(
1495 &self,
1496 mut servers: &[fidl_fuchsia_net::SocketAddress],
1497 ) -> Self::SetDnsServersResponseFut {
1498 fn _decode(
1499 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1500 ) -> Result<LookupAdminSetDnsServersResult, fidl::Error> {
1501 let _response = fidl::client::decode_transaction_body::<
1502 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
1503 fidl::encoding::DefaultFuchsiaResourceDialect,
1504 0x55e2b9fcc777be96,
1505 >(_buf?)?;
1506 Ok(_response.map(|x| x))
1507 }
1508 self.client.send_query_and_decode::<
1509 LookupAdminSetDnsServersRequest,
1510 LookupAdminSetDnsServersResult,
1511 >(
1512 (servers,),
1513 0x55e2b9fcc777be96,
1514 fidl::encoding::DynamicFlags::empty(),
1515 _decode,
1516 )
1517 }
1518
1519 type GetDnsServersResponseFut = fidl::client::QueryResponseFut<
1520 Vec<fidl_fuchsia_net::SocketAddress>,
1521 fidl::encoding::DefaultFuchsiaResourceDialect,
1522 >;
1523 fn r#get_dns_servers(&self) -> Self::GetDnsServersResponseFut {
1524 fn _decode(
1525 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1526 ) -> Result<Vec<fidl_fuchsia_net::SocketAddress>, fidl::Error> {
1527 let _response = fidl::client::decode_transaction_body::<
1528 LookupAdminGetDnsServersResponse,
1529 fidl::encoding::DefaultFuchsiaResourceDialect,
1530 0x614303bf6e72f80f,
1531 >(_buf?)?;
1532 Ok(_response.servers)
1533 }
1534 self.client.send_query_and_decode::<
1535 fidl::encoding::EmptyPayload,
1536 Vec<fidl_fuchsia_net::SocketAddress>,
1537 >(
1538 (),
1539 0x614303bf6e72f80f,
1540 fidl::encoding::DynamicFlags::empty(),
1541 _decode,
1542 )
1543 }
1544}
1545
1546pub struct LookupAdminEventStream {
1547 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1548}
1549
1550impl std::marker::Unpin for LookupAdminEventStream {}
1551
1552impl futures::stream::FusedStream for LookupAdminEventStream {
1553 fn is_terminated(&self) -> bool {
1554 self.event_receiver.is_terminated()
1555 }
1556}
1557
1558impl futures::Stream for LookupAdminEventStream {
1559 type Item = Result<LookupAdminEvent, fidl::Error>;
1560
1561 fn poll_next(
1562 mut self: std::pin::Pin<&mut Self>,
1563 cx: &mut std::task::Context<'_>,
1564 ) -> std::task::Poll<Option<Self::Item>> {
1565 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1566 &mut self.event_receiver,
1567 cx
1568 )?) {
1569 Some(buf) => std::task::Poll::Ready(Some(LookupAdminEvent::decode(buf))),
1570 None => std::task::Poll::Ready(None),
1571 }
1572 }
1573}
1574
1575#[derive(Debug)]
1576pub enum LookupAdminEvent {}
1577
1578impl LookupAdminEvent {
1579 fn decode(
1581 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1582 ) -> Result<LookupAdminEvent, fidl::Error> {
1583 let (bytes, _handles) = buf.split_mut();
1584 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1585 debug_assert_eq!(tx_header.tx_id, 0);
1586 match tx_header.ordinal {
1587 _ => Err(fidl::Error::UnknownOrdinal {
1588 ordinal: tx_header.ordinal,
1589 protocol_name: <LookupAdminMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1590 }),
1591 }
1592 }
1593}
1594
1595pub struct LookupAdminRequestStream {
1597 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1598 is_terminated: bool,
1599}
1600
1601impl std::marker::Unpin for LookupAdminRequestStream {}
1602
1603impl futures::stream::FusedStream for LookupAdminRequestStream {
1604 fn is_terminated(&self) -> bool {
1605 self.is_terminated
1606 }
1607}
1608
1609impl fidl::endpoints::RequestStream for LookupAdminRequestStream {
1610 type Protocol = LookupAdminMarker;
1611 type ControlHandle = LookupAdminControlHandle;
1612
1613 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1614 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1615 }
1616
1617 fn control_handle(&self) -> Self::ControlHandle {
1618 LookupAdminControlHandle { inner: self.inner.clone() }
1619 }
1620
1621 fn into_inner(
1622 self,
1623 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1624 {
1625 (self.inner, self.is_terminated)
1626 }
1627
1628 fn from_inner(
1629 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1630 is_terminated: bool,
1631 ) -> Self {
1632 Self { inner, is_terminated }
1633 }
1634}
1635
1636impl futures::Stream for LookupAdminRequestStream {
1637 type Item = Result<LookupAdminRequest, fidl::Error>;
1638
1639 fn poll_next(
1640 mut self: std::pin::Pin<&mut Self>,
1641 cx: &mut std::task::Context<'_>,
1642 ) -> std::task::Poll<Option<Self::Item>> {
1643 let this = &mut *self;
1644 if this.inner.check_shutdown(cx) {
1645 this.is_terminated = true;
1646 return std::task::Poll::Ready(None);
1647 }
1648 if this.is_terminated {
1649 panic!("polled LookupAdminRequestStream after completion");
1650 }
1651 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1652 |bytes, handles| {
1653 match this.inner.channel().read_etc(cx, bytes, handles) {
1654 std::task::Poll::Ready(Ok(())) => {}
1655 std::task::Poll::Pending => return std::task::Poll::Pending,
1656 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1657 this.is_terminated = true;
1658 return std::task::Poll::Ready(None);
1659 }
1660 std::task::Poll::Ready(Err(e)) => {
1661 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1662 e.into(),
1663 ))))
1664 }
1665 }
1666
1667 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1669
1670 std::task::Poll::Ready(Some(match header.ordinal {
1671 0x55e2b9fcc777be96 => {
1672 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1673 let mut req = fidl::new_empty!(
1674 LookupAdminSetDnsServersRequest,
1675 fidl::encoding::DefaultFuchsiaResourceDialect
1676 );
1677 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LookupAdminSetDnsServersRequest>(&header, _body_bytes, handles, &mut req)?;
1678 let control_handle = LookupAdminControlHandle { inner: this.inner.clone() };
1679 Ok(LookupAdminRequest::SetDnsServers {
1680 servers: req.servers,
1681
1682 responder: LookupAdminSetDnsServersResponder {
1683 control_handle: std::mem::ManuallyDrop::new(control_handle),
1684 tx_id: header.tx_id,
1685 },
1686 })
1687 }
1688 0x614303bf6e72f80f => {
1689 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1690 let mut req = fidl::new_empty!(
1691 fidl::encoding::EmptyPayload,
1692 fidl::encoding::DefaultFuchsiaResourceDialect
1693 );
1694 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1695 let control_handle = LookupAdminControlHandle { inner: this.inner.clone() };
1696 Ok(LookupAdminRequest::GetDnsServers {
1697 responder: LookupAdminGetDnsServersResponder {
1698 control_handle: std::mem::ManuallyDrop::new(control_handle),
1699 tx_id: header.tx_id,
1700 },
1701 })
1702 }
1703 _ => Err(fidl::Error::UnknownOrdinal {
1704 ordinal: header.ordinal,
1705 protocol_name:
1706 <LookupAdminMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1707 }),
1708 }))
1709 },
1710 )
1711 }
1712}
1713
1714#[derive(Debug)]
1716pub enum LookupAdminRequest {
1717 SetDnsServers {
1726 servers: Vec<fidl_fuchsia_net::SocketAddress>,
1727 responder: LookupAdminSetDnsServersResponder,
1728 },
1729 GetDnsServers { responder: LookupAdminGetDnsServersResponder },
1732}
1733
1734impl LookupAdminRequest {
1735 #[allow(irrefutable_let_patterns)]
1736 pub fn into_set_dns_servers(
1737 self,
1738 ) -> Option<(Vec<fidl_fuchsia_net::SocketAddress>, LookupAdminSetDnsServersResponder)> {
1739 if let LookupAdminRequest::SetDnsServers { servers, responder } = self {
1740 Some((servers, responder))
1741 } else {
1742 None
1743 }
1744 }
1745
1746 #[allow(irrefutable_let_patterns)]
1747 pub fn into_get_dns_servers(self) -> Option<(LookupAdminGetDnsServersResponder)> {
1748 if let LookupAdminRequest::GetDnsServers { responder } = self {
1749 Some((responder))
1750 } else {
1751 None
1752 }
1753 }
1754
1755 pub fn method_name(&self) -> &'static str {
1757 match *self {
1758 LookupAdminRequest::SetDnsServers { .. } => "set_dns_servers",
1759 LookupAdminRequest::GetDnsServers { .. } => "get_dns_servers",
1760 }
1761 }
1762}
1763
1764#[derive(Debug, Clone)]
1765pub struct LookupAdminControlHandle {
1766 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1767}
1768
1769impl fidl::endpoints::ControlHandle for LookupAdminControlHandle {
1770 fn shutdown(&self) {
1771 self.inner.shutdown()
1772 }
1773 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1774 self.inner.shutdown_with_epitaph(status)
1775 }
1776
1777 fn is_closed(&self) -> bool {
1778 self.inner.channel().is_closed()
1779 }
1780 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1781 self.inner.channel().on_closed()
1782 }
1783
1784 #[cfg(target_os = "fuchsia")]
1785 fn signal_peer(
1786 &self,
1787 clear_mask: zx::Signals,
1788 set_mask: zx::Signals,
1789 ) -> Result<(), zx_status::Status> {
1790 use fidl::Peered;
1791 self.inner.channel().signal_peer(clear_mask, set_mask)
1792 }
1793}
1794
1795impl LookupAdminControlHandle {}
1796
1797#[must_use = "FIDL methods require a response to be sent"]
1798#[derive(Debug)]
1799pub struct LookupAdminSetDnsServersResponder {
1800 control_handle: std::mem::ManuallyDrop<LookupAdminControlHandle>,
1801 tx_id: u32,
1802}
1803
1804impl std::ops::Drop for LookupAdminSetDnsServersResponder {
1808 fn drop(&mut self) {
1809 self.control_handle.shutdown();
1810 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1812 }
1813}
1814
1815impl fidl::endpoints::Responder for LookupAdminSetDnsServersResponder {
1816 type ControlHandle = LookupAdminControlHandle;
1817
1818 fn control_handle(&self) -> &LookupAdminControlHandle {
1819 &self.control_handle
1820 }
1821
1822 fn drop_without_shutdown(mut self) {
1823 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1825 std::mem::forget(self);
1827 }
1828}
1829
1830impl LookupAdminSetDnsServersResponder {
1831 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
1835 let _result = self.send_raw(result);
1836 if _result.is_err() {
1837 self.control_handle.shutdown();
1838 }
1839 self.drop_without_shutdown();
1840 _result
1841 }
1842
1843 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
1845 let _result = self.send_raw(result);
1846 self.drop_without_shutdown();
1847 _result
1848 }
1849
1850 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
1851 self.control_handle
1852 .inner
1853 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
1854 result,
1855 self.tx_id,
1856 0x55e2b9fcc777be96,
1857 fidl::encoding::DynamicFlags::empty(),
1858 )
1859 }
1860}
1861
1862#[must_use = "FIDL methods require a response to be sent"]
1863#[derive(Debug)]
1864pub struct LookupAdminGetDnsServersResponder {
1865 control_handle: std::mem::ManuallyDrop<LookupAdminControlHandle>,
1866 tx_id: u32,
1867}
1868
1869impl std::ops::Drop for LookupAdminGetDnsServersResponder {
1873 fn drop(&mut self) {
1874 self.control_handle.shutdown();
1875 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1877 }
1878}
1879
1880impl fidl::endpoints::Responder for LookupAdminGetDnsServersResponder {
1881 type ControlHandle = LookupAdminControlHandle;
1882
1883 fn control_handle(&self) -> &LookupAdminControlHandle {
1884 &self.control_handle
1885 }
1886
1887 fn drop_without_shutdown(mut self) {
1888 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1890 std::mem::forget(self);
1892 }
1893}
1894
1895impl LookupAdminGetDnsServersResponder {
1896 pub fn send(self, mut servers: &[fidl_fuchsia_net::SocketAddress]) -> Result<(), fidl::Error> {
1900 let _result = self.send_raw(servers);
1901 if _result.is_err() {
1902 self.control_handle.shutdown();
1903 }
1904 self.drop_without_shutdown();
1905 _result
1906 }
1907
1908 pub fn send_no_shutdown_on_err(
1910 self,
1911 mut servers: &[fidl_fuchsia_net::SocketAddress],
1912 ) -> Result<(), fidl::Error> {
1913 let _result = self.send_raw(servers);
1914 self.drop_without_shutdown();
1915 _result
1916 }
1917
1918 fn send_raw(&self, mut servers: &[fidl_fuchsia_net::SocketAddress]) -> Result<(), fidl::Error> {
1919 self.control_handle.inner.send::<LookupAdminGetDnsServersResponse>(
1920 (servers,),
1921 self.tx_id,
1922 0x614303bf6e72f80f,
1923 fidl::encoding::DynamicFlags::empty(),
1924 )
1925 }
1926}
1927
1928mod internal {
1929 use super::*;
1930 unsafe impl fidl::encoding::TypeMarker for LookupError {
1931 type Owned = Self;
1932
1933 #[inline(always)]
1934 fn inline_align(_context: fidl::encoding::Context) -> usize {
1935 std::mem::align_of::<u32>()
1936 }
1937
1938 #[inline(always)]
1939 fn inline_size(_context: fidl::encoding::Context) -> usize {
1940 std::mem::size_of::<u32>()
1941 }
1942
1943 #[inline(always)]
1944 fn encode_is_copy() -> bool {
1945 true
1946 }
1947
1948 #[inline(always)]
1949 fn decode_is_copy() -> bool {
1950 false
1951 }
1952 }
1953
1954 impl fidl::encoding::ValueTypeMarker for LookupError {
1955 type Borrowed<'a> = Self;
1956 #[inline(always)]
1957 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1958 *value
1959 }
1960 }
1961
1962 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LookupError {
1963 #[inline]
1964 unsafe fn encode(
1965 self,
1966 encoder: &mut fidl::encoding::Encoder<'_, D>,
1967 offset: usize,
1968 _depth: fidl::encoding::Depth,
1969 ) -> fidl::Result<()> {
1970 encoder.debug_check_bounds::<Self>(offset);
1971 encoder.write_num(self.into_primitive(), offset);
1972 Ok(())
1973 }
1974 }
1975
1976 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LookupError {
1977 #[inline(always)]
1978 fn new_empty() -> Self {
1979 Self::NotFound
1980 }
1981
1982 #[inline]
1983 unsafe fn decode(
1984 &mut self,
1985 decoder: &mut fidl::encoding::Decoder<'_, D>,
1986 offset: usize,
1987 _depth: fidl::encoding::Depth,
1988 ) -> fidl::Result<()> {
1989 decoder.debug_check_bounds::<Self>(offset);
1990 let prim = decoder.read_num::<u32>(offset);
1991
1992 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1993 Ok(())
1994 }
1995 }
1996
1997 impl fidl::encoding::ValueTypeMarker for DnsServerWatcherWatchServersResponse {
1998 type Borrowed<'a> = &'a Self;
1999 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2000 value
2001 }
2002 }
2003
2004 unsafe impl fidl::encoding::TypeMarker for DnsServerWatcherWatchServersResponse {
2005 type Owned = Self;
2006
2007 #[inline(always)]
2008 fn inline_align(_context: fidl::encoding::Context) -> usize {
2009 8
2010 }
2011
2012 #[inline(always)]
2013 fn inline_size(_context: fidl::encoding::Context) -> usize {
2014 16
2015 }
2016 }
2017
2018 unsafe impl<D: fidl::encoding::ResourceDialect>
2019 fidl::encoding::Encode<DnsServerWatcherWatchServersResponse, D>
2020 for &DnsServerWatcherWatchServersResponse
2021 {
2022 #[inline]
2023 unsafe fn encode(
2024 self,
2025 encoder: &mut fidl::encoding::Encoder<'_, D>,
2026 offset: usize,
2027 _depth: fidl::encoding::Depth,
2028 ) -> fidl::Result<()> {
2029 encoder.debug_check_bounds::<DnsServerWatcherWatchServersResponse>(offset);
2030 fidl::encoding::Encode::<DnsServerWatcherWatchServersResponse, D>::encode(
2032 (
2033 <fidl::encoding::UnboundedVector<DnsServer_> as fidl::encoding::ValueTypeMarker>::borrow(&self.servers),
2034 ),
2035 encoder, offset, _depth
2036 )
2037 }
2038 }
2039 unsafe impl<
2040 D: fidl::encoding::ResourceDialect,
2041 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DnsServer_>, D>,
2042 > fidl::encoding::Encode<DnsServerWatcherWatchServersResponse, D> for (T0,)
2043 {
2044 #[inline]
2045 unsafe fn encode(
2046 self,
2047 encoder: &mut fidl::encoding::Encoder<'_, D>,
2048 offset: usize,
2049 depth: fidl::encoding::Depth,
2050 ) -> fidl::Result<()> {
2051 encoder.debug_check_bounds::<DnsServerWatcherWatchServersResponse>(offset);
2052 self.0.encode(encoder, offset + 0, depth)?;
2056 Ok(())
2057 }
2058 }
2059
2060 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2061 for DnsServerWatcherWatchServersResponse
2062 {
2063 #[inline(always)]
2064 fn new_empty() -> Self {
2065 Self { servers: fidl::new_empty!(fidl::encoding::UnboundedVector<DnsServer_>, D) }
2066 }
2067
2068 #[inline]
2069 unsafe fn decode(
2070 &mut self,
2071 decoder: &mut fidl::encoding::Decoder<'_, D>,
2072 offset: usize,
2073 _depth: fidl::encoding::Depth,
2074 ) -> fidl::Result<()> {
2075 decoder.debug_check_bounds::<Self>(offset);
2076 fidl::decode!(
2078 fidl::encoding::UnboundedVector<DnsServer_>,
2079 D,
2080 &mut self.servers,
2081 decoder,
2082 offset + 0,
2083 _depth
2084 )?;
2085 Ok(())
2086 }
2087 }
2088
2089 impl fidl::encoding::ValueTypeMarker for LookupAdminGetDnsServersResponse {
2090 type Borrowed<'a> = &'a Self;
2091 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2092 value
2093 }
2094 }
2095
2096 unsafe impl fidl::encoding::TypeMarker for LookupAdminGetDnsServersResponse {
2097 type Owned = Self;
2098
2099 #[inline(always)]
2100 fn inline_align(_context: fidl::encoding::Context) -> usize {
2101 8
2102 }
2103
2104 #[inline(always)]
2105 fn inline_size(_context: fidl::encoding::Context) -> usize {
2106 16
2107 }
2108 }
2109
2110 unsafe impl<D: fidl::encoding::ResourceDialect>
2111 fidl::encoding::Encode<LookupAdminGetDnsServersResponse, D>
2112 for &LookupAdminGetDnsServersResponse
2113 {
2114 #[inline]
2115 unsafe fn encode(
2116 self,
2117 encoder: &mut fidl::encoding::Encoder<'_, D>,
2118 offset: usize,
2119 _depth: fidl::encoding::Depth,
2120 ) -> fidl::Result<()> {
2121 encoder.debug_check_bounds::<LookupAdminGetDnsServersResponse>(offset);
2122 fidl::encoding::Encode::<LookupAdminGetDnsServersResponse, D>::encode(
2124 (
2125 <fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.servers),
2126 ),
2127 encoder, offset, _depth
2128 )
2129 }
2130 }
2131 unsafe impl<
2132 D: fidl::encoding::ResourceDialect,
2133 T0: fidl::encoding::Encode<
2134 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2135 D,
2136 >,
2137 > fidl::encoding::Encode<LookupAdminGetDnsServersResponse, D> for (T0,)
2138 {
2139 #[inline]
2140 unsafe fn encode(
2141 self,
2142 encoder: &mut fidl::encoding::Encoder<'_, D>,
2143 offset: usize,
2144 depth: fidl::encoding::Depth,
2145 ) -> fidl::Result<()> {
2146 encoder.debug_check_bounds::<LookupAdminGetDnsServersResponse>(offset);
2147 self.0.encode(encoder, offset + 0, depth)?;
2151 Ok(())
2152 }
2153 }
2154
2155 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2156 for LookupAdminGetDnsServersResponse
2157 {
2158 #[inline(always)]
2159 fn new_empty() -> Self {
2160 Self {
2161 servers: fidl::new_empty!(
2162 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2163 D
2164 ),
2165 }
2166 }
2167
2168 #[inline]
2169 unsafe fn decode(
2170 &mut self,
2171 decoder: &mut fidl::encoding::Decoder<'_, D>,
2172 offset: usize,
2173 _depth: fidl::encoding::Depth,
2174 ) -> fidl::Result<()> {
2175 decoder.debug_check_bounds::<Self>(offset);
2176 fidl::decode!(
2178 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2179 D,
2180 &mut self.servers,
2181 decoder,
2182 offset + 0,
2183 _depth
2184 )?;
2185 Ok(())
2186 }
2187 }
2188
2189 impl fidl::encoding::ValueTypeMarker for LookupAdminSetDnsServersRequest {
2190 type Borrowed<'a> = &'a Self;
2191 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2192 value
2193 }
2194 }
2195
2196 unsafe impl fidl::encoding::TypeMarker for LookupAdminSetDnsServersRequest {
2197 type Owned = Self;
2198
2199 #[inline(always)]
2200 fn inline_align(_context: fidl::encoding::Context) -> usize {
2201 8
2202 }
2203
2204 #[inline(always)]
2205 fn inline_size(_context: fidl::encoding::Context) -> usize {
2206 16
2207 }
2208 }
2209
2210 unsafe impl<D: fidl::encoding::ResourceDialect>
2211 fidl::encoding::Encode<LookupAdminSetDnsServersRequest, D>
2212 for &LookupAdminSetDnsServersRequest
2213 {
2214 #[inline]
2215 unsafe fn encode(
2216 self,
2217 encoder: &mut fidl::encoding::Encoder<'_, D>,
2218 offset: usize,
2219 _depth: fidl::encoding::Depth,
2220 ) -> fidl::Result<()> {
2221 encoder.debug_check_bounds::<LookupAdminSetDnsServersRequest>(offset);
2222 fidl::encoding::Encode::<LookupAdminSetDnsServersRequest, D>::encode(
2224 (
2225 <fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.servers),
2226 ),
2227 encoder, offset, _depth
2228 )
2229 }
2230 }
2231 unsafe impl<
2232 D: fidl::encoding::ResourceDialect,
2233 T0: fidl::encoding::Encode<
2234 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2235 D,
2236 >,
2237 > fidl::encoding::Encode<LookupAdminSetDnsServersRequest, D> for (T0,)
2238 {
2239 #[inline]
2240 unsafe fn encode(
2241 self,
2242 encoder: &mut fidl::encoding::Encoder<'_, D>,
2243 offset: usize,
2244 depth: fidl::encoding::Depth,
2245 ) -> fidl::Result<()> {
2246 encoder.debug_check_bounds::<LookupAdminSetDnsServersRequest>(offset);
2247 self.0.encode(encoder, offset + 0, depth)?;
2251 Ok(())
2252 }
2253 }
2254
2255 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2256 for LookupAdminSetDnsServersRequest
2257 {
2258 #[inline(always)]
2259 fn new_empty() -> Self {
2260 Self {
2261 servers: fidl::new_empty!(
2262 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2263 D
2264 ),
2265 }
2266 }
2267
2268 #[inline]
2269 unsafe fn decode(
2270 &mut self,
2271 decoder: &mut fidl::encoding::Decoder<'_, D>,
2272 offset: usize,
2273 _depth: fidl::encoding::Depth,
2274 ) -> fidl::Result<()> {
2275 decoder.debug_check_bounds::<Self>(offset);
2276 fidl::decode!(
2278 fidl::encoding::UnboundedVector<fidl_fuchsia_net::SocketAddress>,
2279 D,
2280 &mut self.servers,
2281 decoder,
2282 offset + 0,
2283 _depth
2284 )?;
2285 Ok(())
2286 }
2287 }
2288
2289 impl fidl::encoding::ValueTypeMarker for LookupLookupHostnameRequest {
2290 type Borrowed<'a> = &'a Self;
2291 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2292 value
2293 }
2294 }
2295
2296 unsafe impl fidl::encoding::TypeMarker for LookupLookupHostnameRequest {
2297 type Owned = Self;
2298
2299 #[inline(always)]
2300 fn inline_align(_context: fidl::encoding::Context) -> usize {
2301 8
2302 }
2303
2304 #[inline(always)]
2305 fn inline_size(_context: fidl::encoding::Context) -> usize {
2306 16
2307 }
2308 }
2309
2310 unsafe impl<D: fidl::encoding::ResourceDialect>
2311 fidl::encoding::Encode<LookupLookupHostnameRequest, D> for &LookupLookupHostnameRequest
2312 {
2313 #[inline]
2314 unsafe fn encode(
2315 self,
2316 encoder: &mut fidl::encoding::Encoder<'_, D>,
2317 offset: usize,
2318 _depth: fidl::encoding::Depth,
2319 ) -> fidl::Result<()> {
2320 encoder.debug_check_bounds::<LookupLookupHostnameRequest>(offset);
2321 fidl::encoding::Encode::<LookupLookupHostnameRequest, D>::encode(
2323 (<fidl_fuchsia_net::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(
2324 &self.addr,
2325 ),),
2326 encoder,
2327 offset,
2328 _depth,
2329 )
2330 }
2331 }
2332 unsafe impl<
2333 D: fidl::encoding::ResourceDialect,
2334 T0: fidl::encoding::Encode<fidl_fuchsia_net::IpAddress, D>,
2335 > fidl::encoding::Encode<LookupLookupHostnameRequest, D> for (T0,)
2336 {
2337 #[inline]
2338 unsafe fn encode(
2339 self,
2340 encoder: &mut fidl::encoding::Encoder<'_, D>,
2341 offset: usize,
2342 depth: fidl::encoding::Depth,
2343 ) -> fidl::Result<()> {
2344 encoder.debug_check_bounds::<LookupLookupHostnameRequest>(offset);
2345 self.0.encode(encoder, offset + 0, depth)?;
2349 Ok(())
2350 }
2351 }
2352
2353 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2354 for LookupLookupHostnameRequest
2355 {
2356 #[inline(always)]
2357 fn new_empty() -> Self {
2358 Self { addr: fidl::new_empty!(fidl_fuchsia_net::IpAddress, D) }
2359 }
2360
2361 #[inline]
2362 unsafe fn decode(
2363 &mut self,
2364 decoder: &mut fidl::encoding::Decoder<'_, D>,
2365 offset: usize,
2366 _depth: fidl::encoding::Depth,
2367 ) -> fidl::Result<()> {
2368 decoder.debug_check_bounds::<Self>(offset);
2369 fidl::decode!(
2371 fidl_fuchsia_net::IpAddress,
2372 D,
2373 &mut self.addr,
2374 decoder,
2375 offset + 0,
2376 _depth
2377 )?;
2378 Ok(())
2379 }
2380 }
2381
2382 impl fidl::encoding::ValueTypeMarker for LookupLookupIpRequest {
2383 type Borrowed<'a> = &'a Self;
2384 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2385 value
2386 }
2387 }
2388
2389 unsafe impl fidl::encoding::TypeMarker for LookupLookupIpRequest {
2390 type Owned = Self;
2391
2392 #[inline(always)]
2393 fn inline_align(_context: fidl::encoding::Context) -> usize {
2394 8
2395 }
2396
2397 #[inline(always)]
2398 fn inline_size(_context: fidl::encoding::Context) -> usize {
2399 32
2400 }
2401 }
2402
2403 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LookupLookupIpRequest, D>
2404 for &LookupLookupIpRequest
2405 {
2406 #[inline]
2407 unsafe fn encode(
2408 self,
2409 encoder: &mut fidl::encoding::Encoder<'_, D>,
2410 offset: usize,
2411 _depth: fidl::encoding::Depth,
2412 ) -> fidl::Result<()> {
2413 encoder.debug_check_bounds::<LookupLookupIpRequest>(offset);
2414 fidl::encoding::Encode::<LookupLookupIpRequest, D>::encode(
2416 (
2417 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
2418 &self.hostname,
2419 ),
2420 <LookupIpOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2421 ),
2422 encoder,
2423 offset,
2424 _depth,
2425 )
2426 }
2427 }
2428 unsafe impl<
2429 D: fidl::encoding::ResourceDialect,
2430 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2431 T1: fidl::encoding::Encode<LookupIpOptions, D>,
2432 > fidl::encoding::Encode<LookupLookupIpRequest, D> for (T0, T1)
2433 {
2434 #[inline]
2435 unsafe fn encode(
2436 self,
2437 encoder: &mut fidl::encoding::Encoder<'_, D>,
2438 offset: usize,
2439 depth: fidl::encoding::Depth,
2440 ) -> fidl::Result<()> {
2441 encoder.debug_check_bounds::<LookupLookupIpRequest>(offset);
2442 self.0.encode(encoder, offset + 0, depth)?;
2446 self.1.encode(encoder, offset + 16, depth)?;
2447 Ok(())
2448 }
2449 }
2450
2451 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LookupLookupIpRequest {
2452 #[inline(always)]
2453 fn new_empty() -> Self {
2454 Self {
2455 hostname: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2456 options: fidl::new_empty!(LookupIpOptions, D),
2457 }
2458 }
2459
2460 #[inline]
2461 unsafe fn decode(
2462 &mut self,
2463 decoder: &mut fidl::encoding::Decoder<'_, D>,
2464 offset: usize,
2465 _depth: fidl::encoding::Depth,
2466 ) -> fidl::Result<()> {
2467 decoder.debug_check_bounds::<Self>(offset);
2468 fidl::decode!(
2470 fidl::encoding::BoundedString<255>,
2471 D,
2472 &mut self.hostname,
2473 decoder,
2474 offset + 0,
2475 _depth
2476 )?;
2477 fidl::decode!(LookupIpOptions, D, &mut self.options, decoder, offset + 16, _depth)?;
2478 Ok(())
2479 }
2480 }
2481
2482 impl fidl::encoding::ValueTypeMarker for LookupLookupHostnameResponse {
2483 type Borrowed<'a> = &'a Self;
2484 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2485 value
2486 }
2487 }
2488
2489 unsafe impl fidl::encoding::TypeMarker for LookupLookupHostnameResponse {
2490 type Owned = Self;
2491
2492 #[inline(always)]
2493 fn inline_align(_context: fidl::encoding::Context) -> usize {
2494 8
2495 }
2496
2497 #[inline(always)]
2498 fn inline_size(_context: fidl::encoding::Context) -> usize {
2499 16
2500 }
2501 }
2502
2503 unsafe impl<D: fidl::encoding::ResourceDialect>
2504 fidl::encoding::Encode<LookupLookupHostnameResponse, D> for &LookupLookupHostnameResponse
2505 {
2506 #[inline]
2507 unsafe fn encode(
2508 self,
2509 encoder: &mut fidl::encoding::Encoder<'_, D>,
2510 offset: usize,
2511 _depth: fidl::encoding::Depth,
2512 ) -> fidl::Result<()> {
2513 encoder.debug_check_bounds::<LookupLookupHostnameResponse>(offset);
2514 fidl::encoding::Encode::<LookupLookupHostnameResponse, D>::encode(
2516 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
2517 &self.hostname,
2518 ),),
2519 encoder,
2520 offset,
2521 _depth,
2522 )
2523 }
2524 }
2525 unsafe impl<
2526 D: fidl::encoding::ResourceDialect,
2527 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2528 > fidl::encoding::Encode<LookupLookupHostnameResponse, D> for (T0,)
2529 {
2530 #[inline]
2531 unsafe fn encode(
2532 self,
2533 encoder: &mut fidl::encoding::Encoder<'_, D>,
2534 offset: usize,
2535 depth: fidl::encoding::Depth,
2536 ) -> fidl::Result<()> {
2537 encoder.debug_check_bounds::<LookupLookupHostnameResponse>(offset);
2538 self.0.encode(encoder, offset + 0, depth)?;
2542 Ok(())
2543 }
2544 }
2545
2546 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2547 for LookupLookupHostnameResponse
2548 {
2549 #[inline(always)]
2550 fn new_empty() -> Self {
2551 Self { hostname: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
2552 }
2553
2554 #[inline]
2555 unsafe fn decode(
2556 &mut self,
2557 decoder: &mut fidl::encoding::Decoder<'_, D>,
2558 offset: usize,
2559 _depth: fidl::encoding::Depth,
2560 ) -> fidl::Result<()> {
2561 decoder.debug_check_bounds::<Self>(offset);
2562 fidl::decode!(
2564 fidl::encoding::BoundedString<255>,
2565 D,
2566 &mut self.hostname,
2567 decoder,
2568 offset + 0,
2569 _depth
2570 )?;
2571 Ok(())
2572 }
2573 }
2574
2575 impl fidl::encoding::ValueTypeMarker for LookupLookupIpResponse {
2576 type Borrowed<'a> = &'a Self;
2577 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2578 value
2579 }
2580 }
2581
2582 unsafe impl fidl::encoding::TypeMarker for LookupLookupIpResponse {
2583 type Owned = Self;
2584
2585 #[inline(always)]
2586 fn inline_align(_context: fidl::encoding::Context) -> usize {
2587 8
2588 }
2589
2590 #[inline(always)]
2591 fn inline_size(_context: fidl::encoding::Context) -> usize {
2592 16
2593 }
2594 }
2595
2596 unsafe impl<D: fidl::encoding::ResourceDialect>
2597 fidl::encoding::Encode<LookupLookupIpResponse, D> for &LookupLookupIpResponse
2598 {
2599 #[inline]
2600 unsafe fn encode(
2601 self,
2602 encoder: &mut fidl::encoding::Encoder<'_, D>,
2603 offset: usize,
2604 _depth: fidl::encoding::Depth,
2605 ) -> fidl::Result<()> {
2606 encoder.debug_check_bounds::<LookupLookupIpResponse>(offset);
2607 fidl::encoding::Encode::<LookupLookupIpResponse, D>::encode(
2609 (<LookupResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
2610 encoder,
2611 offset,
2612 _depth,
2613 )
2614 }
2615 }
2616 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LookupResult, D>>
2617 fidl::encoding::Encode<LookupLookupIpResponse, D> for (T0,)
2618 {
2619 #[inline]
2620 unsafe fn encode(
2621 self,
2622 encoder: &mut fidl::encoding::Encoder<'_, D>,
2623 offset: usize,
2624 depth: fidl::encoding::Depth,
2625 ) -> fidl::Result<()> {
2626 encoder.debug_check_bounds::<LookupLookupIpResponse>(offset);
2627 self.0.encode(encoder, offset + 0, depth)?;
2631 Ok(())
2632 }
2633 }
2634
2635 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2636 for LookupLookupIpResponse
2637 {
2638 #[inline(always)]
2639 fn new_empty() -> Self {
2640 Self { result: fidl::new_empty!(LookupResult, D) }
2641 }
2642
2643 #[inline]
2644 unsafe fn decode(
2645 &mut self,
2646 decoder: &mut fidl::encoding::Decoder<'_, D>,
2647 offset: usize,
2648 _depth: fidl::encoding::Depth,
2649 ) -> fidl::Result<()> {
2650 decoder.debug_check_bounds::<Self>(offset);
2651 fidl::decode!(LookupResult, D, &mut self.result, decoder, offset + 0, _depth)?;
2653 Ok(())
2654 }
2655 }
2656
2657 impl DhcpDnsServerSource {
2658 #[inline(always)]
2659 fn max_ordinal_present(&self) -> u64 {
2660 if let Some(_) = self.source_interface {
2661 return 1;
2662 }
2663 0
2664 }
2665 }
2666
2667 impl fidl::encoding::ValueTypeMarker for DhcpDnsServerSource {
2668 type Borrowed<'a> = &'a Self;
2669 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2670 value
2671 }
2672 }
2673
2674 unsafe impl fidl::encoding::TypeMarker for DhcpDnsServerSource {
2675 type Owned = Self;
2676
2677 #[inline(always)]
2678 fn inline_align(_context: fidl::encoding::Context) -> usize {
2679 8
2680 }
2681
2682 #[inline(always)]
2683 fn inline_size(_context: fidl::encoding::Context) -> usize {
2684 16
2685 }
2686 }
2687
2688 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DhcpDnsServerSource, D>
2689 for &DhcpDnsServerSource
2690 {
2691 unsafe fn encode(
2692 self,
2693 encoder: &mut fidl::encoding::Encoder<'_, D>,
2694 offset: usize,
2695 mut depth: fidl::encoding::Depth,
2696 ) -> fidl::Result<()> {
2697 encoder.debug_check_bounds::<DhcpDnsServerSource>(offset);
2698 let max_ordinal: u64 = self.max_ordinal_present();
2700 encoder.write_num(max_ordinal, offset);
2701 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2702 if max_ordinal == 0 {
2704 return Ok(());
2705 }
2706 depth.increment()?;
2707 let envelope_size = 8;
2708 let bytes_len = max_ordinal as usize * envelope_size;
2709 #[allow(unused_variables)]
2710 let offset = encoder.out_of_line_offset(bytes_len);
2711 let mut _prev_end_offset: usize = 0;
2712 if 1 > max_ordinal {
2713 return Ok(());
2714 }
2715
2716 let cur_offset: usize = (1 - 1) * envelope_size;
2719
2720 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2722
2723 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2728 self.source_interface
2729 .as_ref()
2730 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2731 encoder,
2732 offset + cur_offset,
2733 depth,
2734 )?;
2735
2736 _prev_end_offset = cur_offset + envelope_size;
2737
2738 Ok(())
2739 }
2740 }
2741
2742 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DhcpDnsServerSource {
2743 #[inline(always)]
2744 fn new_empty() -> Self {
2745 Self::default()
2746 }
2747
2748 unsafe fn decode(
2749 &mut self,
2750 decoder: &mut fidl::encoding::Decoder<'_, D>,
2751 offset: usize,
2752 mut depth: fidl::encoding::Depth,
2753 ) -> fidl::Result<()> {
2754 decoder.debug_check_bounds::<Self>(offset);
2755 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2756 None => return Err(fidl::Error::NotNullable),
2757 Some(len) => len,
2758 };
2759 if len == 0 {
2761 return Ok(());
2762 };
2763 depth.increment()?;
2764 let envelope_size = 8;
2765 let bytes_len = len * envelope_size;
2766 let offset = decoder.out_of_line_offset(bytes_len)?;
2767 let mut _next_ordinal_to_read = 0;
2769 let mut next_offset = offset;
2770 let end_offset = offset + bytes_len;
2771 _next_ordinal_to_read += 1;
2772 if next_offset >= end_offset {
2773 return Ok(());
2774 }
2775
2776 while _next_ordinal_to_read < 1 {
2778 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2779 _next_ordinal_to_read += 1;
2780 next_offset += envelope_size;
2781 }
2782
2783 let next_out_of_line = decoder.next_out_of_line();
2784 let handles_before = decoder.remaining_handles();
2785 if let Some((inlined, num_bytes, num_handles)) =
2786 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2787 {
2788 let member_inline_size =
2789 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2790 if inlined != (member_inline_size <= 4) {
2791 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2792 }
2793 let inner_offset;
2794 let mut inner_depth = depth.clone();
2795 if inlined {
2796 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2797 inner_offset = next_offset;
2798 } else {
2799 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2800 inner_depth.increment()?;
2801 }
2802 let val_ref = self.source_interface.get_or_insert_with(|| fidl::new_empty!(u64, D));
2803 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2804 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2805 {
2806 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2807 }
2808 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2809 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2810 }
2811 }
2812
2813 next_offset += envelope_size;
2814
2815 while next_offset < end_offset {
2817 _next_ordinal_to_read += 1;
2818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2819 next_offset += envelope_size;
2820 }
2821
2822 Ok(())
2823 }
2824 }
2825
2826 impl Dhcpv6DnsServerSource {
2827 #[inline(always)]
2828 fn max_ordinal_present(&self) -> u64 {
2829 if let Some(_) = self.source_interface {
2830 return 1;
2831 }
2832 0
2833 }
2834 }
2835
2836 impl fidl::encoding::ValueTypeMarker for Dhcpv6DnsServerSource {
2837 type Borrowed<'a> = &'a Self;
2838 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2839 value
2840 }
2841 }
2842
2843 unsafe impl fidl::encoding::TypeMarker for Dhcpv6DnsServerSource {
2844 type Owned = Self;
2845
2846 #[inline(always)]
2847 fn inline_align(_context: fidl::encoding::Context) -> usize {
2848 8
2849 }
2850
2851 #[inline(always)]
2852 fn inline_size(_context: fidl::encoding::Context) -> usize {
2853 16
2854 }
2855 }
2856
2857 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dhcpv6DnsServerSource, D>
2858 for &Dhcpv6DnsServerSource
2859 {
2860 unsafe fn encode(
2861 self,
2862 encoder: &mut fidl::encoding::Encoder<'_, D>,
2863 offset: usize,
2864 mut depth: fidl::encoding::Depth,
2865 ) -> fidl::Result<()> {
2866 encoder.debug_check_bounds::<Dhcpv6DnsServerSource>(offset);
2867 let max_ordinal: u64 = self.max_ordinal_present();
2869 encoder.write_num(max_ordinal, offset);
2870 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2871 if max_ordinal == 0 {
2873 return Ok(());
2874 }
2875 depth.increment()?;
2876 let envelope_size = 8;
2877 let bytes_len = max_ordinal as usize * envelope_size;
2878 #[allow(unused_variables)]
2879 let offset = encoder.out_of_line_offset(bytes_len);
2880 let mut _prev_end_offset: usize = 0;
2881 if 1 > max_ordinal {
2882 return Ok(());
2883 }
2884
2885 let cur_offset: usize = (1 - 1) * envelope_size;
2888
2889 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2891
2892 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2897 self.source_interface
2898 .as_ref()
2899 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2900 encoder,
2901 offset + cur_offset,
2902 depth,
2903 )?;
2904
2905 _prev_end_offset = cur_offset + envelope_size;
2906
2907 Ok(())
2908 }
2909 }
2910
2911 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcpv6DnsServerSource {
2912 #[inline(always)]
2913 fn new_empty() -> Self {
2914 Self::default()
2915 }
2916
2917 unsafe fn decode(
2918 &mut self,
2919 decoder: &mut fidl::encoding::Decoder<'_, D>,
2920 offset: usize,
2921 mut depth: fidl::encoding::Depth,
2922 ) -> fidl::Result<()> {
2923 decoder.debug_check_bounds::<Self>(offset);
2924 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2925 None => return Err(fidl::Error::NotNullable),
2926 Some(len) => len,
2927 };
2928 if len == 0 {
2930 return Ok(());
2931 };
2932 depth.increment()?;
2933 let envelope_size = 8;
2934 let bytes_len = len * envelope_size;
2935 let offset = decoder.out_of_line_offset(bytes_len)?;
2936 let mut _next_ordinal_to_read = 0;
2938 let mut next_offset = offset;
2939 let end_offset = offset + bytes_len;
2940 _next_ordinal_to_read += 1;
2941 if next_offset >= end_offset {
2942 return Ok(());
2943 }
2944
2945 while _next_ordinal_to_read < 1 {
2947 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2948 _next_ordinal_to_read += 1;
2949 next_offset += envelope_size;
2950 }
2951
2952 let next_out_of_line = decoder.next_out_of_line();
2953 let handles_before = decoder.remaining_handles();
2954 if let Some((inlined, num_bytes, num_handles)) =
2955 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2956 {
2957 let member_inline_size =
2958 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2959 if inlined != (member_inline_size <= 4) {
2960 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2961 }
2962 let inner_offset;
2963 let mut inner_depth = depth.clone();
2964 if inlined {
2965 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2966 inner_offset = next_offset;
2967 } else {
2968 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2969 inner_depth.increment()?;
2970 }
2971 let val_ref = self.source_interface.get_or_insert_with(|| fidl::new_empty!(u64, D));
2972 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2973 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2974 {
2975 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2976 }
2977 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2978 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2979 }
2980 }
2981
2982 next_offset += envelope_size;
2983
2984 while next_offset < end_offset {
2986 _next_ordinal_to_read += 1;
2987 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2988 next_offset += envelope_size;
2989 }
2990
2991 Ok(())
2992 }
2993 }
2994
2995 impl DnsServer_ {
2996 #[inline(always)]
2997 fn max_ordinal_present(&self) -> u64 {
2998 if let Some(_) = self.source {
2999 return 2;
3000 }
3001 if let Some(_) = self.address {
3002 return 1;
3003 }
3004 0
3005 }
3006 }
3007
3008 impl fidl::encoding::ValueTypeMarker for DnsServer_ {
3009 type Borrowed<'a> = &'a Self;
3010 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3011 value
3012 }
3013 }
3014
3015 unsafe impl fidl::encoding::TypeMarker for DnsServer_ {
3016 type Owned = Self;
3017
3018 #[inline(always)]
3019 fn inline_align(_context: fidl::encoding::Context) -> usize {
3020 8
3021 }
3022
3023 #[inline(always)]
3024 fn inline_size(_context: fidl::encoding::Context) -> usize {
3025 16
3026 }
3027 }
3028
3029 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnsServer_, D>
3030 for &DnsServer_
3031 {
3032 unsafe fn encode(
3033 self,
3034 encoder: &mut fidl::encoding::Encoder<'_, D>,
3035 offset: usize,
3036 mut depth: fidl::encoding::Depth,
3037 ) -> fidl::Result<()> {
3038 encoder.debug_check_bounds::<DnsServer_>(offset);
3039 let max_ordinal: u64 = self.max_ordinal_present();
3041 encoder.write_num(max_ordinal, offset);
3042 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3043 if max_ordinal == 0 {
3045 return Ok(());
3046 }
3047 depth.increment()?;
3048 let envelope_size = 8;
3049 let bytes_len = max_ordinal as usize * envelope_size;
3050 #[allow(unused_variables)]
3051 let offset = encoder.out_of_line_offset(bytes_len);
3052 let mut _prev_end_offset: usize = 0;
3053 if 1 > max_ordinal {
3054 return Ok(());
3055 }
3056
3057 let cur_offset: usize = (1 - 1) * envelope_size;
3060
3061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3063
3064 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::SocketAddress, D>(
3069 self.address.as_ref().map(
3070 <fidl_fuchsia_net::SocketAddress as fidl::encoding::ValueTypeMarker>::borrow,
3071 ),
3072 encoder,
3073 offset + cur_offset,
3074 depth,
3075 )?;
3076
3077 _prev_end_offset = cur_offset + envelope_size;
3078 if 2 > max_ordinal {
3079 return Ok(());
3080 }
3081
3082 let cur_offset: usize = (2 - 1) * envelope_size;
3085
3086 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3088
3089 fidl::encoding::encode_in_envelope_optional::<DnsServerSource, D>(
3094 self.source
3095 .as_ref()
3096 .map(<DnsServerSource as fidl::encoding::ValueTypeMarker>::borrow),
3097 encoder,
3098 offset + cur_offset,
3099 depth,
3100 )?;
3101
3102 _prev_end_offset = cur_offset + envelope_size;
3103
3104 Ok(())
3105 }
3106 }
3107
3108 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnsServer_ {
3109 #[inline(always)]
3110 fn new_empty() -> Self {
3111 Self::default()
3112 }
3113
3114 unsafe fn decode(
3115 &mut self,
3116 decoder: &mut fidl::encoding::Decoder<'_, D>,
3117 offset: usize,
3118 mut depth: fidl::encoding::Depth,
3119 ) -> fidl::Result<()> {
3120 decoder.debug_check_bounds::<Self>(offset);
3121 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3122 None => return Err(fidl::Error::NotNullable),
3123 Some(len) => len,
3124 };
3125 if len == 0 {
3127 return Ok(());
3128 };
3129 depth.increment()?;
3130 let envelope_size = 8;
3131 let bytes_len = len * envelope_size;
3132 let offset = decoder.out_of_line_offset(bytes_len)?;
3133 let mut _next_ordinal_to_read = 0;
3135 let mut next_offset = offset;
3136 let end_offset = offset + bytes_len;
3137 _next_ordinal_to_read += 1;
3138 if next_offset >= end_offset {
3139 return Ok(());
3140 }
3141
3142 while _next_ordinal_to_read < 1 {
3144 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3145 _next_ordinal_to_read += 1;
3146 next_offset += envelope_size;
3147 }
3148
3149 let next_out_of_line = decoder.next_out_of_line();
3150 let handles_before = decoder.remaining_handles();
3151 if let Some((inlined, num_bytes, num_handles)) =
3152 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3153 {
3154 let member_inline_size =
3155 <fidl_fuchsia_net::SocketAddress as fidl::encoding::TypeMarker>::inline_size(
3156 decoder.context,
3157 );
3158 if inlined != (member_inline_size <= 4) {
3159 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3160 }
3161 let inner_offset;
3162 let mut inner_depth = depth.clone();
3163 if inlined {
3164 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3165 inner_offset = next_offset;
3166 } else {
3167 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3168 inner_depth.increment()?;
3169 }
3170 let val_ref = self
3171 .address
3172 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::SocketAddress, D));
3173 fidl::decode!(
3174 fidl_fuchsia_net::SocketAddress,
3175 D,
3176 val_ref,
3177 decoder,
3178 inner_offset,
3179 inner_depth
3180 )?;
3181 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3182 {
3183 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3184 }
3185 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3186 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3187 }
3188 }
3189
3190 next_offset += envelope_size;
3191 _next_ordinal_to_read += 1;
3192 if next_offset >= end_offset {
3193 return Ok(());
3194 }
3195
3196 while _next_ordinal_to_read < 2 {
3198 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3199 _next_ordinal_to_read += 1;
3200 next_offset += envelope_size;
3201 }
3202
3203 let next_out_of_line = decoder.next_out_of_line();
3204 let handles_before = decoder.remaining_handles();
3205 if let Some((inlined, num_bytes, num_handles)) =
3206 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3207 {
3208 let member_inline_size =
3209 <DnsServerSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3210 if inlined != (member_inline_size <= 4) {
3211 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3212 }
3213 let inner_offset;
3214 let mut inner_depth = depth.clone();
3215 if inlined {
3216 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3217 inner_offset = next_offset;
3218 } else {
3219 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3220 inner_depth.increment()?;
3221 }
3222 let val_ref =
3223 self.source.get_or_insert_with(|| fidl::new_empty!(DnsServerSource, D));
3224 fidl::decode!(DnsServerSource, D, val_ref, decoder, inner_offset, inner_depth)?;
3225 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3226 {
3227 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3228 }
3229 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3230 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3231 }
3232 }
3233
3234 next_offset += envelope_size;
3235
3236 while next_offset < end_offset {
3238 _next_ordinal_to_read += 1;
3239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3240 next_offset += envelope_size;
3241 }
3242
3243 Ok(())
3244 }
3245 }
3246
3247 impl LookupIpOptions {
3248 #[inline(always)]
3249 fn max_ordinal_present(&self) -> u64 {
3250 if let Some(_) = self.canonical_name_lookup {
3251 return 4;
3252 }
3253 if let Some(_) = self.sort_addresses {
3254 return 3;
3255 }
3256 if let Some(_) = self.ipv6_lookup {
3257 return 2;
3258 }
3259 if let Some(_) = self.ipv4_lookup {
3260 return 1;
3261 }
3262 0
3263 }
3264 }
3265
3266 impl fidl::encoding::ValueTypeMarker for LookupIpOptions {
3267 type Borrowed<'a> = &'a Self;
3268 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3269 value
3270 }
3271 }
3272
3273 unsafe impl fidl::encoding::TypeMarker for LookupIpOptions {
3274 type Owned = Self;
3275
3276 #[inline(always)]
3277 fn inline_align(_context: fidl::encoding::Context) -> usize {
3278 8
3279 }
3280
3281 #[inline(always)]
3282 fn inline_size(_context: fidl::encoding::Context) -> usize {
3283 16
3284 }
3285 }
3286
3287 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LookupIpOptions, D>
3288 for &LookupIpOptions
3289 {
3290 unsafe fn encode(
3291 self,
3292 encoder: &mut fidl::encoding::Encoder<'_, D>,
3293 offset: usize,
3294 mut depth: fidl::encoding::Depth,
3295 ) -> fidl::Result<()> {
3296 encoder.debug_check_bounds::<LookupIpOptions>(offset);
3297 let max_ordinal: u64 = self.max_ordinal_present();
3299 encoder.write_num(max_ordinal, offset);
3300 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3301 if max_ordinal == 0 {
3303 return Ok(());
3304 }
3305 depth.increment()?;
3306 let envelope_size = 8;
3307 let bytes_len = max_ordinal as usize * envelope_size;
3308 #[allow(unused_variables)]
3309 let offset = encoder.out_of_line_offset(bytes_len);
3310 let mut _prev_end_offset: usize = 0;
3311 if 1 > max_ordinal {
3312 return Ok(());
3313 }
3314
3315 let cur_offset: usize = (1 - 1) * envelope_size;
3318
3319 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3321
3322 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3327 self.ipv4_lookup.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3328 encoder,
3329 offset + cur_offset,
3330 depth,
3331 )?;
3332
3333 _prev_end_offset = cur_offset + envelope_size;
3334 if 2 > max_ordinal {
3335 return Ok(());
3336 }
3337
3338 let cur_offset: usize = (2 - 1) * envelope_size;
3341
3342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3344
3345 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3350 self.ipv6_lookup.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3351 encoder,
3352 offset + cur_offset,
3353 depth,
3354 )?;
3355
3356 _prev_end_offset = cur_offset + envelope_size;
3357 if 3 > max_ordinal {
3358 return Ok(());
3359 }
3360
3361 let cur_offset: usize = (3 - 1) * envelope_size;
3364
3365 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3367
3368 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3373 self.sort_addresses.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3374 encoder,
3375 offset + cur_offset,
3376 depth,
3377 )?;
3378
3379 _prev_end_offset = cur_offset + envelope_size;
3380 if 4 > max_ordinal {
3381 return Ok(());
3382 }
3383
3384 let cur_offset: usize = (4 - 1) * envelope_size;
3387
3388 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3390
3391 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3396 self.canonical_name_lookup
3397 .as_ref()
3398 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3399 encoder,
3400 offset + cur_offset,
3401 depth,
3402 )?;
3403
3404 _prev_end_offset = cur_offset + envelope_size;
3405
3406 Ok(())
3407 }
3408 }
3409
3410 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LookupIpOptions {
3411 #[inline(always)]
3412 fn new_empty() -> Self {
3413 Self::default()
3414 }
3415
3416 unsafe fn decode(
3417 &mut self,
3418 decoder: &mut fidl::encoding::Decoder<'_, D>,
3419 offset: usize,
3420 mut depth: fidl::encoding::Depth,
3421 ) -> fidl::Result<()> {
3422 decoder.debug_check_bounds::<Self>(offset);
3423 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3424 None => return Err(fidl::Error::NotNullable),
3425 Some(len) => len,
3426 };
3427 if len == 0 {
3429 return Ok(());
3430 };
3431 depth.increment()?;
3432 let envelope_size = 8;
3433 let bytes_len = len * envelope_size;
3434 let offset = decoder.out_of_line_offset(bytes_len)?;
3435 let mut _next_ordinal_to_read = 0;
3437 let mut next_offset = offset;
3438 let end_offset = offset + bytes_len;
3439 _next_ordinal_to_read += 1;
3440 if next_offset >= end_offset {
3441 return Ok(());
3442 }
3443
3444 while _next_ordinal_to_read < 1 {
3446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3447 _next_ordinal_to_read += 1;
3448 next_offset += envelope_size;
3449 }
3450
3451 let next_out_of_line = decoder.next_out_of_line();
3452 let handles_before = decoder.remaining_handles();
3453 if let Some((inlined, num_bytes, num_handles)) =
3454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3455 {
3456 let member_inline_size =
3457 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3458 if inlined != (member_inline_size <= 4) {
3459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3460 }
3461 let inner_offset;
3462 let mut inner_depth = depth.clone();
3463 if inlined {
3464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3465 inner_offset = next_offset;
3466 } else {
3467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3468 inner_depth.increment()?;
3469 }
3470 let val_ref = self.ipv4_lookup.get_or_insert_with(|| fidl::new_empty!(bool, D));
3471 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3472 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3473 {
3474 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3475 }
3476 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3477 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3478 }
3479 }
3480
3481 next_offset += envelope_size;
3482 _next_ordinal_to_read += 1;
3483 if next_offset >= end_offset {
3484 return Ok(());
3485 }
3486
3487 while _next_ordinal_to_read < 2 {
3489 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3490 _next_ordinal_to_read += 1;
3491 next_offset += envelope_size;
3492 }
3493
3494 let next_out_of_line = decoder.next_out_of_line();
3495 let handles_before = decoder.remaining_handles();
3496 if let Some((inlined, num_bytes, num_handles)) =
3497 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3498 {
3499 let member_inline_size =
3500 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3501 if inlined != (member_inline_size <= 4) {
3502 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3503 }
3504 let inner_offset;
3505 let mut inner_depth = depth.clone();
3506 if inlined {
3507 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3508 inner_offset = next_offset;
3509 } else {
3510 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3511 inner_depth.increment()?;
3512 }
3513 let val_ref = self.ipv6_lookup.get_or_insert_with(|| fidl::new_empty!(bool, D));
3514 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3515 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3516 {
3517 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3518 }
3519 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3520 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3521 }
3522 }
3523
3524 next_offset += envelope_size;
3525 _next_ordinal_to_read += 1;
3526 if next_offset >= end_offset {
3527 return Ok(());
3528 }
3529
3530 while _next_ordinal_to_read < 3 {
3532 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3533 _next_ordinal_to_read += 1;
3534 next_offset += envelope_size;
3535 }
3536
3537 let next_out_of_line = decoder.next_out_of_line();
3538 let handles_before = decoder.remaining_handles();
3539 if let Some((inlined, num_bytes, num_handles)) =
3540 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3541 {
3542 let member_inline_size =
3543 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3544 if inlined != (member_inline_size <= 4) {
3545 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3546 }
3547 let inner_offset;
3548 let mut inner_depth = depth.clone();
3549 if inlined {
3550 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3551 inner_offset = next_offset;
3552 } else {
3553 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3554 inner_depth.increment()?;
3555 }
3556 let val_ref = self.sort_addresses.get_or_insert_with(|| fidl::new_empty!(bool, D));
3557 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3558 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3559 {
3560 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3561 }
3562 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3563 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3564 }
3565 }
3566
3567 next_offset += envelope_size;
3568 _next_ordinal_to_read += 1;
3569 if next_offset >= end_offset {
3570 return Ok(());
3571 }
3572
3573 while _next_ordinal_to_read < 4 {
3575 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3576 _next_ordinal_to_read += 1;
3577 next_offset += envelope_size;
3578 }
3579
3580 let next_out_of_line = decoder.next_out_of_line();
3581 let handles_before = decoder.remaining_handles();
3582 if let Some((inlined, num_bytes, num_handles)) =
3583 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3584 {
3585 let member_inline_size =
3586 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3587 if inlined != (member_inline_size <= 4) {
3588 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3589 }
3590 let inner_offset;
3591 let mut inner_depth = depth.clone();
3592 if inlined {
3593 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3594 inner_offset = next_offset;
3595 } else {
3596 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3597 inner_depth.increment()?;
3598 }
3599 let val_ref =
3600 self.canonical_name_lookup.get_or_insert_with(|| fidl::new_empty!(bool, D));
3601 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3602 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3603 {
3604 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3605 }
3606 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3607 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3608 }
3609 }
3610
3611 next_offset += envelope_size;
3612
3613 while next_offset < end_offset {
3615 _next_ordinal_to_read += 1;
3616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3617 next_offset += envelope_size;
3618 }
3619
3620 Ok(())
3621 }
3622 }
3623
3624 impl LookupResult {
3625 #[inline(always)]
3626 fn max_ordinal_present(&self) -> u64 {
3627 if let Some(_) = self.canonical_name {
3628 return 2;
3629 }
3630 if let Some(_) = self.addresses {
3631 return 1;
3632 }
3633 0
3634 }
3635 }
3636
3637 impl fidl::encoding::ValueTypeMarker for LookupResult {
3638 type Borrowed<'a> = &'a Self;
3639 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3640 value
3641 }
3642 }
3643
3644 unsafe impl fidl::encoding::TypeMarker for LookupResult {
3645 type Owned = Self;
3646
3647 #[inline(always)]
3648 fn inline_align(_context: fidl::encoding::Context) -> usize {
3649 8
3650 }
3651
3652 #[inline(always)]
3653 fn inline_size(_context: fidl::encoding::Context) -> usize {
3654 16
3655 }
3656 }
3657
3658 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LookupResult, D>
3659 for &LookupResult
3660 {
3661 unsafe fn encode(
3662 self,
3663 encoder: &mut fidl::encoding::Encoder<'_, D>,
3664 offset: usize,
3665 mut depth: fidl::encoding::Depth,
3666 ) -> fidl::Result<()> {
3667 encoder.debug_check_bounds::<LookupResult>(offset);
3668 let max_ordinal: u64 = self.max_ordinal_present();
3670 encoder.write_num(max_ordinal, offset);
3671 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3672 if max_ordinal == 0 {
3674 return Ok(());
3675 }
3676 depth.increment()?;
3677 let envelope_size = 8;
3678 let bytes_len = max_ordinal as usize * envelope_size;
3679 #[allow(unused_variables)]
3680 let offset = encoder.out_of_line_offset(bytes_len);
3681 let mut _prev_end_offset: usize = 0;
3682 if 1 > max_ordinal {
3683 return Ok(());
3684 }
3685
3686 let cur_offset: usize = (1 - 1) * envelope_size;
3689
3690 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3692
3693 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net::IpAddress, 1024>, D>(
3698 self.addresses.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net::IpAddress, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
3699 encoder, offset + cur_offset, depth
3700 )?;
3701
3702 _prev_end_offset = cur_offset + envelope_size;
3703 if 2 > max_ordinal {
3704 return Ok(());
3705 }
3706
3707 let cur_offset: usize = (2 - 1) * envelope_size;
3710
3711 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3713
3714 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3719 self.canonical_name.as_ref().map(
3720 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3721 ),
3722 encoder,
3723 offset + cur_offset,
3724 depth,
3725 )?;
3726
3727 _prev_end_offset = cur_offset + envelope_size;
3728
3729 Ok(())
3730 }
3731 }
3732
3733 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LookupResult {
3734 #[inline(always)]
3735 fn new_empty() -> Self {
3736 Self::default()
3737 }
3738
3739 unsafe fn decode(
3740 &mut self,
3741 decoder: &mut fidl::encoding::Decoder<'_, D>,
3742 offset: usize,
3743 mut depth: fidl::encoding::Depth,
3744 ) -> fidl::Result<()> {
3745 decoder.debug_check_bounds::<Self>(offset);
3746 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3747 None => return Err(fidl::Error::NotNullable),
3748 Some(len) => len,
3749 };
3750 if len == 0 {
3752 return Ok(());
3753 };
3754 depth.increment()?;
3755 let envelope_size = 8;
3756 let bytes_len = len * envelope_size;
3757 let offset = decoder.out_of_line_offset(bytes_len)?;
3758 let mut _next_ordinal_to_read = 0;
3760 let mut next_offset = offset;
3761 let end_offset = offset + bytes_len;
3762 _next_ordinal_to_read += 1;
3763 if next_offset >= end_offset {
3764 return Ok(());
3765 }
3766
3767 while _next_ordinal_to_read < 1 {
3769 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3770 _next_ordinal_to_read += 1;
3771 next_offset += envelope_size;
3772 }
3773
3774 let next_out_of_line = decoder.next_out_of_line();
3775 let handles_before = decoder.remaining_handles();
3776 if let Some((inlined, num_bytes, num_handles)) =
3777 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3778 {
3779 let member_inline_size = <fidl::encoding::Vector<fidl_fuchsia_net::IpAddress, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3780 if inlined != (member_inline_size <= 4) {
3781 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3782 }
3783 let inner_offset;
3784 let mut inner_depth = depth.clone();
3785 if inlined {
3786 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3787 inner_offset = next_offset;
3788 } else {
3789 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3790 inner_depth.increment()?;
3791 }
3792 let val_ref =
3793 self.addresses.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::IpAddress, 1024>, D));
3794 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::IpAddress, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
3795 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3796 {
3797 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3798 }
3799 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3800 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3801 }
3802 }
3803
3804 next_offset += envelope_size;
3805 _next_ordinal_to_read += 1;
3806 if next_offset >= end_offset {
3807 return Ok(());
3808 }
3809
3810 while _next_ordinal_to_read < 2 {
3812 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3813 _next_ordinal_to_read += 1;
3814 next_offset += envelope_size;
3815 }
3816
3817 let next_out_of_line = decoder.next_out_of_line();
3818 let handles_before = decoder.remaining_handles();
3819 if let Some((inlined, num_bytes, num_handles)) =
3820 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3821 {
3822 let member_inline_size =
3823 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3824 decoder.context,
3825 );
3826 if inlined != (member_inline_size <= 4) {
3827 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3828 }
3829 let inner_offset;
3830 let mut inner_depth = depth.clone();
3831 if inlined {
3832 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3833 inner_offset = next_offset;
3834 } else {
3835 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3836 inner_depth.increment()?;
3837 }
3838 let val_ref = self
3839 .canonical_name
3840 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3841 fidl::decode!(
3842 fidl::encoding::BoundedString<255>,
3843 D,
3844 val_ref,
3845 decoder,
3846 inner_offset,
3847 inner_depth
3848 )?;
3849 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3850 {
3851 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3852 }
3853 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3854 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3855 }
3856 }
3857
3858 next_offset += envelope_size;
3859
3860 while next_offset < end_offset {
3862 _next_ordinal_to_read += 1;
3863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3864 next_offset += envelope_size;
3865 }
3866
3867 Ok(())
3868 }
3869 }
3870
3871 impl NdpDnsServerSource {
3872 #[inline(always)]
3873 fn max_ordinal_present(&self) -> u64 {
3874 if let Some(_) = self.source_interface {
3875 return 1;
3876 }
3877 0
3878 }
3879 }
3880
3881 impl fidl::encoding::ValueTypeMarker for NdpDnsServerSource {
3882 type Borrowed<'a> = &'a Self;
3883 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3884 value
3885 }
3886 }
3887
3888 unsafe impl fidl::encoding::TypeMarker for NdpDnsServerSource {
3889 type Owned = Self;
3890
3891 #[inline(always)]
3892 fn inline_align(_context: fidl::encoding::Context) -> usize {
3893 8
3894 }
3895
3896 #[inline(always)]
3897 fn inline_size(_context: fidl::encoding::Context) -> usize {
3898 16
3899 }
3900 }
3901
3902 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NdpDnsServerSource, D>
3903 for &NdpDnsServerSource
3904 {
3905 unsafe fn encode(
3906 self,
3907 encoder: &mut fidl::encoding::Encoder<'_, D>,
3908 offset: usize,
3909 mut depth: fidl::encoding::Depth,
3910 ) -> fidl::Result<()> {
3911 encoder.debug_check_bounds::<NdpDnsServerSource>(offset);
3912 let max_ordinal: u64 = self.max_ordinal_present();
3914 encoder.write_num(max_ordinal, offset);
3915 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3916 if max_ordinal == 0 {
3918 return Ok(());
3919 }
3920 depth.increment()?;
3921 let envelope_size = 8;
3922 let bytes_len = max_ordinal as usize * envelope_size;
3923 #[allow(unused_variables)]
3924 let offset = encoder.out_of_line_offset(bytes_len);
3925 let mut _prev_end_offset: usize = 0;
3926 if 1 > max_ordinal {
3927 return Ok(());
3928 }
3929
3930 let cur_offset: usize = (1 - 1) * envelope_size;
3933
3934 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3936
3937 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3942 self.source_interface
3943 .as_ref()
3944 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3945 encoder,
3946 offset + cur_offset,
3947 depth,
3948 )?;
3949
3950 _prev_end_offset = cur_offset + envelope_size;
3951
3952 Ok(())
3953 }
3954 }
3955
3956 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NdpDnsServerSource {
3957 #[inline(always)]
3958 fn new_empty() -> Self {
3959 Self::default()
3960 }
3961
3962 unsafe fn decode(
3963 &mut self,
3964 decoder: &mut fidl::encoding::Decoder<'_, D>,
3965 offset: usize,
3966 mut depth: fidl::encoding::Depth,
3967 ) -> fidl::Result<()> {
3968 decoder.debug_check_bounds::<Self>(offset);
3969 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3970 None => return Err(fidl::Error::NotNullable),
3971 Some(len) => len,
3972 };
3973 if len == 0 {
3975 return Ok(());
3976 };
3977 depth.increment()?;
3978 let envelope_size = 8;
3979 let bytes_len = len * envelope_size;
3980 let offset = decoder.out_of_line_offset(bytes_len)?;
3981 let mut _next_ordinal_to_read = 0;
3983 let mut next_offset = offset;
3984 let end_offset = offset + bytes_len;
3985 _next_ordinal_to_read += 1;
3986 if next_offset >= end_offset {
3987 return Ok(());
3988 }
3989
3990 while _next_ordinal_to_read < 1 {
3992 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3993 _next_ordinal_to_read += 1;
3994 next_offset += envelope_size;
3995 }
3996
3997 let next_out_of_line = decoder.next_out_of_line();
3998 let handles_before = decoder.remaining_handles();
3999 if let Some((inlined, num_bytes, num_handles)) =
4000 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4001 {
4002 let member_inline_size =
4003 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4004 if inlined != (member_inline_size <= 4) {
4005 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4006 }
4007 let inner_offset;
4008 let mut inner_depth = depth.clone();
4009 if inlined {
4010 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4011 inner_offset = next_offset;
4012 } else {
4013 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4014 inner_depth.increment()?;
4015 }
4016 let val_ref = self.source_interface.get_or_insert_with(|| fidl::new_empty!(u64, D));
4017 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4018 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4019 {
4020 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4021 }
4022 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4023 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4024 }
4025 }
4026
4027 next_offset += envelope_size;
4028
4029 while next_offset < end_offset {
4031 _next_ordinal_to_read += 1;
4032 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4033 next_offset += envelope_size;
4034 }
4035
4036 Ok(())
4037 }
4038 }
4039
4040 impl StaticDnsServerSource {
4041 #[inline(always)]
4042 fn max_ordinal_present(&self) -> u64 {
4043 0
4044 }
4045 }
4046
4047 impl fidl::encoding::ValueTypeMarker for StaticDnsServerSource {
4048 type Borrowed<'a> = &'a Self;
4049 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4050 value
4051 }
4052 }
4053
4054 unsafe impl fidl::encoding::TypeMarker for StaticDnsServerSource {
4055 type Owned = Self;
4056
4057 #[inline(always)]
4058 fn inline_align(_context: fidl::encoding::Context) -> usize {
4059 8
4060 }
4061
4062 #[inline(always)]
4063 fn inline_size(_context: fidl::encoding::Context) -> usize {
4064 16
4065 }
4066 }
4067
4068 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StaticDnsServerSource, D>
4069 for &StaticDnsServerSource
4070 {
4071 unsafe fn encode(
4072 self,
4073 encoder: &mut fidl::encoding::Encoder<'_, D>,
4074 offset: usize,
4075 mut depth: fidl::encoding::Depth,
4076 ) -> fidl::Result<()> {
4077 encoder.debug_check_bounds::<StaticDnsServerSource>(offset);
4078 let max_ordinal: u64 = self.max_ordinal_present();
4080 encoder.write_num(max_ordinal, offset);
4081 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4082 if max_ordinal == 0 {
4084 return Ok(());
4085 }
4086 depth.increment()?;
4087 let envelope_size = 8;
4088 let bytes_len = max_ordinal as usize * envelope_size;
4089 #[allow(unused_variables)]
4090 let offset = encoder.out_of_line_offset(bytes_len);
4091 let mut _prev_end_offset: usize = 0;
4092
4093 Ok(())
4094 }
4095 }
4096
4097 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaticDnsServerSource {
4098 #[inline(always)]
4099 fn new_empty() -> Self {
4100 Self::default()
4101 }
4102
4103 unsafe fn decode(
4104 &mut self,
4105 decoder: &mut fidl::encoding::Decoder<'_, D>,
4106 offset: usize,
4107 mut depth: fidl::encoding::Depth,
4108 ) -> fidl::Result<()> {
4109 decoder.debug_check_bounds::<Self>(offset);
4110 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4111 None => return Err(fidl::Error::NotNullable),
4112 Some(len) => len,
4113 };
4114 if len == 0 {
4116 return Ok(());
4117 };
4118 depth.increment()?;
4119 let envelope_size = 8;
4120 let bytes_len = len * envelope_size;
4121 let offset = decoder.out_of_line_offset(bytes_len)?;
4122 let mut _next_ordinal_to_read = 0;
4124 let mut next_offset = offset;
4125 let end_offset = offset + bytes_len;
4126
4127 while next_offset < end_offset {
4129 _next_ordinal_to_read += 1;
4130 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4131 next_offset += envelope_size;
4132 }
4133
4134 Ok(())
4135 }
4136 }
4137
4138 impl fidl::encoding::ValueTypeMarker for DnsServerSource {
4139 type Borrowed<'a> = &'a Self;
4140 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4141 value
4142 }
4143 }
4144
4145 unsafe impl fidl::encoding::TypeMarker for DnsServerSource {
4146 type Owned = Self;
4147
4148 #[inline(always)]
4149 fn inline_align(_context: fidl::encoding::Context) -> usize {
4150 8
4151 }
4152
4153 #[inline(always)]
4154 fn inline_size(_context: fidl::encoding::Context) -> usize {
4155 16
4156 }
4157 }
4158
4159 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnsServerSource, D>
4160 for &DnsServerSource
4161 {
4162 #[inline]
4163 unsafe fn encode(
4164 self,
4165 encoder: &mut fidl::encoding::Encoder<'_, D>,
4166 offset: usize,
4167 _depth: fidl::encoding::Depth,
4168 ) -> fidl::Result<()> {
4169 encoder.debug_check_bounds::<DnsServerSource>(offset);
4170 encoder.write_num::<u64>(self.ordinal(), offset);
4171 match self {
4172 DnsServerSource::StaticSource(ref val) => {
4173 fidl::encoding::encode_in_envelope::<StaticDnsServerSource, D>(
4174 <StaticDnsServerSource as fidl::encoding::ValueTypeMarker>::borrow(val),
4175 encoder,
4176 offset + 8,
4177 _depth,
4178 )
4179 }
4180 DnsServerSource::Dhcp(ref val) => {
4181 fidl::encoding::encode_in_envelope::<DhcpDnsServerSource, D>(
4182 <DhcpDnsServerSource as fidl::encoding::ValueTypeMarker>::borrow(val),
4183 encoder,
4184 offset + 8,
4185 _depth,
4186 )
4187 }
4188 DnsServerSource::Ndp(ref val) => {
4189 fidl::encoding::encode_in_envelope::<NdpDnsServerSource, D>(
4190 <NdpDnsServerSource as fidl::encoding::ValueTypeMarker>::borrow(val),
4191 encoder,
4192 offset + 8,
4193 _depth,
4194 )
4195 }
4196 DnsServerSource::Dhcpv6(ref val) => {
4197 fidl::encoding::encode_in_envelope::<Dhcpv6DnsServerSource, D>(
4198 <Dhcpv6DnsServerSource as fidl::encoding::ValueTypeMarker>::borrow(val),
4199 encoder,
4200 offset + 8,
4201 _depth,
4202 )
4203 }
4204 }
4205 }
4206 }
4207
4208 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnsServerSource {
4209 #[inline(always)]
4210 fn new_empty() -> Self {
4211 Self::StaticSource(fidl::new_empty!(StaticDnsServerSource, D))
4212 }
4213
4214 #[inline]
4215 unsafe fn decode(
4216 &mut self,
4217 decoder: &mut fidl::encoding::Decoder<'_, D>,
4218 offset: usize,
4219 mut depth: fidl::encoding::Depth,
4220 ) -> fidl::Result<()> {
4221 decoder.debug_check_bounds::<Self>(offset);
4222 #[allow(unused_variables)]
4223 let next_out_of_line = decoder.next_out_of_line();
4224 let handles_before = decoder.remaining_handles();
4225 let (ordinal, inlined, num_bytes, num_handles) =
4226 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4227
4228 let member_inline_size = match ordinal {
4229 1 => <StaticDnsServerSource as fidl::encoding::TypeMarker>::inline_size(
4230 decoder.context,
4231 ),
4232 2 => <DhcpDnsServerSource as fidl::encoding::TypeMarker>::inline_size(
4233 decoder.context,
4234 ),
4235 3 => {
4236 <NdpDnsServerSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
4237 }
4238 4 => <Dhcpv6DnsServerSource as fidl::encoding::TypeMarker>::inline_size(
4239 decoder.context,
4240 ),
4241 _ => return Err(fidl::Error::UnknownUnionTag),
4242 };
4243
4244 if inlined != (member_inline_size <= 4) {
4245 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4246 }
4247 let _inner_offset;
4248 if inlined {
4249 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4250 _inner_offset = offset + 8;
4251 } else {
4252 depth.increment()?;
4253 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4254 }
4255 match ordinal {
4256 1 => {
4257 #[allow(irrefutable_let_patterns)]
4258 if let DnsServerSource::StaticSource(_) = self {
4259 } else {
4261 *self = DnsServerSource::StaticSource(fidl::new_empty!(
4263 StaticDnsServerSource,
4264 D
4265 ));
4266 }
4267 #[allow(irrefutable_let_patterns)]
4268 if let DnsServerSource::StaticSource(ref mut val) = self {
4269 fidl::decode!(
4270 StaticDnsServerSource,
4271 D,
4272 val,
4273 decoder,
4274 _inner_offset,
4275 depth
4276 )?;
4277 } else {
4278 unreachable!()
4279 }
4280 }
4281 2 => {
4282 #[allow(irrefutable_let_patterns)]
4283 if let DnsServerSource::Dhcp(_) = self {
4284 } else {
4286 *self = DnsServerSource::Dhcp(fidl::new_empty!(DhcpDnsServerSource, D));
4288 }
4289 #[allow(irrefutable_let_patterns)]
4290 if let DnsServerSource::Dhcp(ref mut val) = self {
4291 fidl::decode!(DhcpDnsServerSource, D, val, decoder, _inner_offset, depth)?;
4292 } else {
4293 unreachable!()
4294 }
4295 }
4296 3 => {
4297 #[allow(irrefutable_let_patterns)]
4298 if let DnsServerSource::Ndp(_) = self {
4299 } else {
4301 *self = DnsServerSource::Ndp(fidl::new_empty!(NdpDnsServerSource, D));
4303 }
4304 #[allow(irrefutable_let_patterns)]
4305 if let DnsServerSource::Ndp(ref mut val) = self {
4306 fidl::decode!(NdpDnsServerSource, D, val, decoder, _inner_offset, depth)?;
4307 } else {
4308 unreachable!()
4309 }
4310 }
4311 4 => {
4312 #[allow(irrefutable_let_patterns)]
4313 if let DnsServerSource::Dhcpv6(_) = self {
4314 } else {
4316 *self = DnsServerSource::Dhcpv6(fidl::new_empty!(Dhcpv6DnsServerSource, D));
4318 }
4319 #[allow(irrefutable_let_patterns)]
4320 if let DnsServerSource::Dhcpv6(ref mut val) = self {
4321 fidl::decode!(
4322 Dhcpv6DnsServerSource,
4323 D,
4324 val,
4325 decoder,
4326 _inner_offset,
4327 depth
4328 )?;
4329 } else {
4330 unreachable!()
4331 }
4332 }
4333 ordinal => panic!("unexpected ordinal {:?}", ordinal),
4334 }
4335 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4336 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4337 }
4338 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4339 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4340 }
4341 Ok(())
4342 }
4343 }
4344}