fidl_fuchsia_net_name/
fidl_fuchsia_net_name.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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
13/// Maximum number of addresses that can be returned by a lookup.
14pub const MAX_ADDRESSES: u16 = 1024;
15
16/// Lookup operation errors.
17#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18#[repr(u32)]
19pub enum LookupError {
20    /// No result was found for this query.
21    NotFound = 1,
22    /// The lookup failed, but may succeed at a later time. For instance, the
23    /// network or DNS server may be unreachable.
24    Transient = 2,
25    /// The lookup failed due to an invalid argument (for instance, the hostname
26    /// was not encoded correctly, or was too long).
27    InvalidArgs = 3,
28    /// The lookup failed due to an internal error.
29    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    /// The hostname to look up.
87    ///
88    /// Must be a valid host domain name; i.e. may not be an IP address in
89    /// dotted-decimal notation.
90    ///
91    /// If it is an Internationalized Domain Name, it must be encoded as per
92    /// RFC 3490.
93    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    /// The interface index over which this server was discovered.
116    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    /// The interface index over which this server was discovered.
126    pub source_interface: Option<u64>,
127    #[doc(hidden)]
128    pub __source_breaking: fidl::marker::SourceBreaking,
129}
130
131impl fidl::Persistable for Dhcpv6DnsServerSource {}
132
133/// A DNS server configuration.
134#[derive(Clone, Debug, Default, PartialEq)]
135pub struct DnsServer_ {
136    /// The server's address, must be provided.
137    pub address: Option<fidl_fuchsia_net::SocketAddress>,
138    /// The configuration source for this server. Defaults to
139    /// [`fuchsia.net.name/DnsServerSource.static_source`].
140    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    /// Include IPv4 results.
150    ///
151    /// If not set, interpreted as false.
152    pub ipv4_lookup: Option<bool>,
153    /// Include IPv6 results.
154    ///
155    /// If not set, interpreted as false.
156    pub ipv6_lookup: Option<bool>,
157    /// Sort addresses in order of preference.
158    ///
159    /// It true, Addresses are sorted according to destination address
160    /// selection described in
161    /// [RFC 6724 Section 6](https://tools.ietf.org/html/rfc6724#section-6).
162    ///
163    /// If not set, interpreted as false.
164    pub sort_addresses: Option<bool>,
165    /// Include the canonical name.
166    ///
167    /// If not set, interpreted as false.
168    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    /// The IP addresses resulting from a lookup.
178    ///
179    /// If sorting was requested, `addresses` is sorted in order of
180    /// preference, most preferred destination address first.
181    pub addresses: Option<Vec<fidl_fuchsia_net::IpAddress>>,
182    /// The canonical name of the requested hostname.
183    ///
184    /// Provided only if requested.
185    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    /// The interface index over which this server was discovered.
195    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    /// The server is statically configured through
213    /// [`fuchsia.net.name/LookupAdmin.SetDefaultServers`].
214    StaticSource(StaticDnsServerSource),
215    /// The server was discovered through DHCPv4.
216    Dhcp(DhcpDnsServerSource),
217    /// The server was discovered through an NDP Router Advertisement.
218    Ndp(NdpDnsServerSource),
219    /// The server was discovered through DHCPv6.
220    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    /// Waits until an event arrives and returns it. It is safe for other
297    /// threads to make concurrent requests while waiting for an event.
298    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    /// Returns a list of DNS servers.
306    ///
307    /// First call always returns a snapshot of the current list of servers or blocks if an empty
308    /// list would be returned. Subsequent calls will block until the list of servers changes.
309    ///
310    /// The list of servers changes over time by configuration or network topology changes,
311    /// expiration, etc. Callers must repeatedly call `WatchServers` and replace any previously
312    /// returned `servers` with new ones to avoid using stale or expired entries.
313    ///
314    /// It is invalid to call this method while a previous call is pending. Doing so will cause the
315    /// server end of the protocol to be closed.
316    ///
317    /// - response `servers` The list of servers to use for DNS resolution, in priority order.
318    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    /// Create a new Proxy for fuchsia.net.name/DnsServerWatcher.
357    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    /// Get a Stream of events from the remote end of the protocol.
363    ///
364    /// # Panics
365    ///
366    /// Panics if the event stream was already taken.
367    pub fn take_event_stream(&self) -> DnsServerWatcherEventStream {
368        DnsServerWatcherEventStream { event_receiver: self.client.take_event_receiver() }
369    }
370
371    /// Returns a list of DNS servers.
372    ///
373    /// First call always returns a snapshot of the current list of servers or blocks if an empty
374    /// list would be returned. Subsequent calls will block until the list of servers changes.
375    ///
376    /// The list of servers changes over time by configuration or network topology changes,
377    /// expiration, etc. Callers must repeatedly call `WatchServers` and replace any previously
378    /// returned `servers` with new ones to avoid using stale or expired entries.
379    ///
380    /// It is invalid to call this method while a previous call is pending. Doing so will cause the
381    /// server end of the protocol to be closed.
382    ///
383    /// - response `servers` The list of servers to use for DNS resolution, in priority order.
384    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    /// Decodes a message buffer as a [`DnsServerWatcherEvent`].
453    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
469/// A Stream of incoming requests for fuchsia.net.name/DnsServerWatcher.
470pub 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                // A message has been received from the channel
542                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/// Provides a hanging get interface to watch for DNS servers configuration.
573#[derive(Debug)]
574pub enum DnsServerWatcherRequest {
575    /// Returns a list of DNS servers.
576    ///
577    /// First call always returns a snapshot of the current list of servers or blocks if an empty
578    /// list would be returned. Subsequent calls will block until the list of servers changes.
579    ///
580    /// The list of servers changes over time by configuration or network topology changes,
581    /// expiration, etc. Callers must repeatedly call `WatchServers` and replace any previously
582    /// returned `servers` with new ones to avoid using stale or expired entries.
583    ///
584    /// It is invalid to call this method while a previous call is pending. Doing so will cause the
585    /// server end of the protocol to be closed.
586    ///
587    /// - response `servers` The list of servers to use for DNS resolution, in priority order.
588    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    /// Name of the method defined in FIDL
602    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
649/// Set the the channel to be shutdown (see [`DnsServerWatcherControlHandle::shutdown`])
650/// if the responder is dropped without sending a response, so that the client
651/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
652impl std::ops::Drop for DnsServerWatcherWatchServersResponder {
653    fn drop(&mut self) {
654        self.control_handle.shutdown();
655        // Safety: drops once, never accessed again
656        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        // Safety: drops once, never accessed again due to mem::forget
669        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
670        // Prevent Drop from running (which would shut down the channel)
671        std::mem::forget(self);
672    }
673}
674
675impl DnsServerWatcherWatchServersResponder {
676    /// Sends a response to the FIDL transaction.
677    ///
678    /// Sets the channel to shutdown if an error occurs.
679    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
689    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    /// Waits until an event arrives and returns it. It is safe for other
767    /// threads to make concurrent requests while waiting for an event.
768    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    /// Lookup a list of IP addresses by hostname.
776    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    /// Look up a hostname by IP address.
795    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    /// Create a new Proxy for fuchsia.net.name/Lookup.
836    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    /// Get a Stream of events from the remote end of the protocol.
842    ///
843    /// # Panics
844    ///
845    /// Panics if the event stream was already taken.
846    pub fn take_event_stream(&self) -> LookupEventStream {
847        LookupEventStream { event_receiver: self.client.take_event_receiver() }
848    }
849
850    /// Lookup a list of IP addresses by hostname.
851    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    /// Look up a hostname by IP address.
863    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    /// Decodes a message buffer as a [`LookupEvent`].
964    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
979/// A Stream of incoming requests for fuchsia.net.name/Lookup.
980pub 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                // A message has been received from the channel
1052                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/// Provides name and address resolution.
1102#[derive(Debug)]
1103pub enum LookupRequest {
1104    /// Lookup a list of IP addresses by hostname.
1105    LookupIp { hostname: String, options: LookupIpOptions, responder: LookupLookupIpResponder },
1106    /// Look up a hostname by IP address.
1107    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    /// Name of the method defined in FIDL
1132    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
1180/// Set the the channel to be shutdown (see [`LookupControlHandle::shutdown`])
1181/// if the responder is dropped without sending a response, so that the client
1182/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1183impl std::ops::Drop for LookupLookupIpResponder {
1184    fn drop(&mut self) {
1185        self.control_handle.shutdown();
1186        // Safety: drops once, never accessed again
1187        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        // Safety: drops once, never accessed again due to mem::forget
1200        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1201        // Prevent Drop from running (which would shut down the channel)
1202        std::mem::forget(self);
1203    }
1204}
1205
1206impl LookupLookupIpResponder {
1207    /// Sends a response to the FIDL transaction.
1208    ///
1209    /// Sets the channel to shutdown if an error occurs.
1210    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1220    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
1248/// Set the the channel to be shutdown (see [`LookupControlHandle::shutdown`])
1249/// if the responder is dropped without sending a response, so that the client
1250/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1251impl std::ops::Drop for LookupLookupHostnameResponder {
1252    fn drop(&mut self) {
1253        self.control_handle.shutdown();
1254        // Safety: drops once, never accessed again
1255        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        // Safety: drops once, never accessed again due to mem::forget
1268        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1269        // Prevent Drop from running (which would shut down the channel)
1270        std::mem::forget(self);
1271    }
1272}
1273
1274impl LookupLookupHostnameResponder {
1275    /// Sends a response to the FIDL transaction.
1276    ///
1277    /// Sets the channel to shutdown if an error occurs.
1278    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1288    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    /// Waits until an event arrives and returns it. It is safe for other
1371    /// threads to make concurrent requests while waiting for an event.
1372    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    /// Sets the DNS servers to `servers`
1380    ///
1381    /// + request `servers` The list of servers to use for domain name resolution, in priority
1382    /// order. An empty list means no servers will be used and name resolution may fail. Each
1383    /// `SocketAddress` in `servers` must be a valid unicast socket address. The list of servers
1384    /// will be deduplicated.
1385    /// * error Returns `ZX_ERR_INVALID_ARGS` if any of the provided addresses does not meet the
1386    /// conditions above.
1387    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    /// Gets the DNS servers currently in use to resolve name lookups.
1405    /// - response `servers` The list of servers in use by `LookupAdmin`, in priority order.
1406    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    /// Create a new Proxy for fuchsia.net.name/LookupAdmin.
1445    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    /// Get a Stream of events from the remote end of the protocol.
1451    ///
1452    /// # Panics
1453    ///
1454    /// Panics if the event stream was already taken.
1455    pub fn take_event_stream(&self) -> LookupAdminEventStream {
1456        LookupAdminEventStream { event_receiver: self.client.take_event_receiver() }
1457    }
1458
1459    /// Sets the DNS servers to `servers`
1460    ///
1461    /// + request `servers` The list of servers to use for domain name resolution, in priority
1462    /// order. An empty list means no servers will be used and name resolution may fail. Each
1463    /// `SocketAddress` in `servers` must be a valid unicast socket address. The list of servers
1464    /// will be deduplicated.
1465    /// * error Returns `ZX_ERR_INVALID_ARGS` if any of the provided addresses does not meet the
1466    /// conditions above.
1467    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    /// Gets the DNS servers currently in use to resolve name lookups.
1478    /// - response `servers` The list of servers in use by `LookupAdmin`, in priority order.
1479    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    /// Decodes a message buffer as a [`LookupAdminEvent`].
1580    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
1595/// A Stream of incoming requests for fuchsia.net.name/LookupAdmin.
1596pub 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                // A message has been received from the channel
1668                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/// Provides administration controls over name resolution settings.
1715#[derive(Debug)]
1716pub enum LookupAdminRequest {
1717    /// Sets the DNS servers to `servers`
1718    ///
1719    /// + request `servers` The list of servers to use for domain name resolution, in priority
1720    /// order. An empty list means no servers will be used and name resolution may fail. Each
1721    /// `SocketAddress` in `servers` must be a valid unicast socket address. The list of servers
1722    /// will be deduplicated.
1723    /// * error Returns `ZX_ERR_INVALID_ARGS` if any of the provided addresses does not meet the
1724    /// conditions above.
1725    SetDnsServers {
1726        servers: Vec<fidl_fuchsia_net::SocketAddress>,
1727        responder: LookupAdminSetDnsServersResponder,
1728    },
1729    /// Gets the DNS servers currently in use to resolve name lookups.
1730    /// - response `servers` The list of servers in use by `LookupAdmin`, in priority order.
1731    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    /// Name of the method defined in FIDL
1756    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
1804/// Set the the channel to be shutdown (see [`LookupAdminControlHandle::shutdown`])
1805/// if the responder is dropped without sending a response, so that the client
1806/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1807impl std::ops::Drop for LookupAdminSetDnsServersResponder {
1808    fn drop(&mut self) {
1809        self.control_handle.shutdown();
1810        // Safety: drops once, never accessed again
1811        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        // Safety: drops once, never accessed again due to mem::forget
1824        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1825        // Prevent Drop from running (which would shut down the channel)
1826        std::mem::forget(self);
1827    }
1828}
1829
1830impl LookupAdminSetDnsServersResponder {
1831    /// Sends a response to the FIDL transaction.
1832    ///
1833    /// Sets the channel to shutdown if an error occurs.
1834    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1844    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
1869/// Set the the channel to be shutdown (see [`LookupAdminControlHandle::shutdown`])
1870/// if the responder is dropped without sending a response, so that the client
1871/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1872impl std::ops::Drop for LookupAdminGetDnsServersResponder {
1873    fn drop(&mut self) {
1874        self.control_handle.shutdown();
1875        // Safety: drops once, never accessed again
1876        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        // Safety: drops once, never accessed again due to mem::forget
1889        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1890        // Prevent Drop from running (which would shut down the channel)
1891        std::mem::forget(self);
1892    }
1893}
1894
1895impl LookupAdminGetDnsServersResponder {
1896    /// Sends a response to the FIDL transaction.
1897    ///
1898    /// Sets the channel to shutdown if an error occurs.
1899    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1909    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            // Delegate to tuple encoding.
2031            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            // Zero out padding regions. There's no need to apply masks
2053            // because the unmasked parts will be overwritten by fields.
2054            // Write the fields.
2055            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            // Verify that padding bytes are zero.
2077            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            // Delegate to tuple encoding.
2123            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            // Zero out padding regions. There's no need to apply masks
2148            // because the unmasked parts will be overwritten by fields.
2149            // Write the fields.
2150            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            // Verify that padding bytes are zero.
2177            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            // Delegate to tuple encoding.
2223            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            // Zero out padding regions. There's no need to apply masks
2248            // because the unmasked parts will be overwritten by fields.
2249            // Write the fields.
2250            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            // Verify that padding bytes are zero.
2277            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            // Delegate to tuple encoding.
2322            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            // Zero out padding regions. There's no need to apply masks
2346            // because the unmasked parts will be overwritten by fields.
2347            // Write the fields.
2348            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            // Verify that padding bytes are zero.
2370            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            // Delegate to tuple encoding.
2415            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            // Zero out padding regions. There's no need to apply masks
2443            // because the unmasked parts will be overwritten by fields.
2444            // Write the fields.
2445            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            // Verify that padding bytes are zero.
2469            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            // Delegate to tuple encoding.
2515            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            // Zero out padding regions. There's no need to apply masks
2539            // because the unmasked parts will be overwritten by fields.
2540            // Write the fields.
2541            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            // Verify that padding bytes are zero.
2563            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            // Delegate to tuple encoding.
2608            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            // Zero out padding regions. There's no need to apply masks
2628            // because the unmasked parts will be overwritten by fields.
2629            // Write the fields.
2630            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            // Verify that padding bytes are zero.
2652            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            // Vector header
2699            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2703            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2717            // are envelope_size bytes.
2718            let cur_offset: usize = (1 - 1) * envelope_size;
2719
2720            // Zero reserved fields.
2721            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2722
2723            // Safety:
2724            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2725            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2726            //   envelope_size bytes, there is always sufficient room.
2727            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2760            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            // Decode the envelope for each type.
2768            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            // Decode unknown envelopes for gaps in ordinals.
2777            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            // Decode the remaining unknown envelopes.
2816            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            // Vector header
2868            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2872            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2886            // are envelope_size bytes.
2887            let cur_offset: usize = (1 - 1) * envelope_size;
2888
2889            // Zero reserved fields.
2890            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2891
2892            // Safety:
2893            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2894            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2895            //   envelope_size bytes, there is always sufficient room.
2896            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2929            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            // Decode the envelope for each type.
2937            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            // Decode unknown envelopes for gaps in ordinals.
2946            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            // Decode the remaining unknown envelopes.
2985            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            // Vector header
3040            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3044            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3058            // are envelope_size bytes.
3059            let cur_offset: usize = (1 - 1) * envelope_size;
3060
3061            // Zero reserved fields.
3062            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3063
3064            // Safety:
3065            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3066            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3067            //   envelope_size bytes, there is always sufficient room.
3068            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3083            // are envelope_size bytes.
3084            let cur_offset: usize = (2 - 1) * envelope_size;
3085
3086            // Zero reserved fields.
3087            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3088
3089            // Safety:
3090            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3091            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3092            //   envelope_size bytes, there is always sufficient room.
3093            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3126            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            // Decode the envelope for each type.
3134            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            // Decode unknown envelopes for gaps in ordinals.
3143            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            // Decode unknown envelopes for gaps in ordinals.
3197            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            // Decode the remaining unknown envelopes.
3237            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            // Vector header
3298            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3302            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3316            // are envelope_size bytes.
3317            let cur_offset: usize = (1 - 1) * envelope_size;
3318
3319            // Zero reserved fields.
3320            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3321
3322            // Safety:
3323            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3324            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3325            //   envelope_size bytes, there is always sufficient room.
3326            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3339            // are envelope_size bytes.
3340            let cur_offset: usize = (2 - 1) * envelope_size;
3341
3342            // Zero reserved fields.
3343            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3344
3345            // Safety:
3346            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3347            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3348            //   envelope_size bytes, there is always sufficient room.
3349            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3362            // are envelope_size bytes.
3363            let cur_offset: usize = (3 - 1) * envelope_size;
3364
3365            // Zero reserved fields.
3366            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3367
3368            // Safety:
3369            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3370            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3371            //   envelope_size bytes, there is always sufficient room.
3372            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3385            // are envelope_size bytes.
3386            let cur_offset: usize = (4 - 1) * envelope_size;
3387
3388            // Zero reserved fields.
3389            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3390
3391            // Safety:
3392            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3393            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3394            //   envelope_size bytes, there is always sufficient room.
3395            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3428            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            // Decode the envelope for each type.
3436            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            // Decode unknown envelopes for gaps in ordinals.
3445            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            // Decode unknown envelopes for gaps in ordinals.
3488            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            // Decode unknown envelopes for gaps in ordinals.
3531            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            // Decode unknown envelopes for gaps in ordinals.
3574            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            // Decode the remaining unknown envelopes.
3614            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            // Vector header
3669            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3673            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3687            // are envelope_size bytes.
3688            let cur_offset: usize = (1 - 1) * envelope_size;
3689
3690            // Zero reserved fields.
3691            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3692
3693            // Safety:
3694            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3695            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3696            //   envelope_size bytes, there is always sufficient room.
3697            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3708            // are envelope_size bytes.
3709            let cur_offset: usize = (2 - 1) * envelope_size;
3710
3711            // Zero reserved fields.
3712            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3713
3714            // Safety:
3715            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3716            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3717            //   envelope_size bytes, there is always sufficient room.
3718            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3751            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            // Decode the envelope for each type.
3759            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            // Decode unknown envelopes for gaps in ordinals.
3768            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            // Decode unknown envelopes for gaps in ordinals.
3811            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            // Decode the remaining unknown envelopes.
3861            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            // Vector header
3913            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3917            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3931            // are envelope_size bytes.
3932            let cur_offset: usize = (1 - 1) * envelope_size;
3933
3934            // Zero reserved fields.
3935            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3936
3937            // Safety:
3938            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3939            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3940            //   envelope_size bytes, there is always sufficient room.
3941            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3974            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            // Decode the envelope for each type.
3982            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            // Decode unknown envelopes for gaps in ordinals.
3991            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            // Decode the remaining unknown envelopes.
4030            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            // Vector header
4079            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            // Calling encoder.out_of_line_offset(0) is not allowed.
4083            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            // Calling decoder.out_of_line_offset(0) is not allowed.
4115            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            // Decode the envelope for each type.
4123            let mut _next_ordinal_to_read = 0;
4124            let mut next_offset = offset;
4125            let end_offset = offset + bytes_len;
4126
4127            // Decode the remaining unknown envelopes.
4128            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                        // Do nothing, read the value into the object
4260                    } else {
4261                        // Initialize `self` to the right variant
4262                        *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                        // Do nothing, read the value into the object
4285                    } else {
4286                        // Initialize `self` to the right variant
4287                        *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                        // Do nothing, read the value into the object
4300                    } else {
4301                        // Initialize `self` to the right variant
4302                        *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                        // Do nothing, read the value into the object
4315                    } else {
4316                        // Initialize `self` to the right variant
4317                        *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}