fidl_fuchsia_net_policy_socketproxy/
fidl_fuchsia_net_policy_socketproxy.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 _};
10pub use fidl_fuchsia_net_policy_socketproxy_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct FuchsiaNetworksMarker;
16
17impl fidl::endpoints::ProtocolMarker for FuchsiaNetworksMarker {
18    type Proxy = FuchsiaNetworksProxy;
19    type RequestStream = FuchsiaNetworksRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = FuchsiaNetworksSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.net.policy.socketproxy.FuchsiaNetworks";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for FuchsiaNetworksMarker {}
26
27pub trait FuchsiaNetworksProxyInterface: Send + Sync {
28    type SetDefaultResponseFut: std::future::Future<Output = Result<NetworkRegistrySetDefaultResult, fidl::Error>>
29        + Send;
30    fn r#set_default(
31        &self,
32        network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
33    ) -> Self::SetDefaultResponseFut;
34    type AddResponseFut: std::future::Future<Output = Result<NetworkRegistryAddResult, fidl::Error>>
35        + Send;
36    fn r#add(&self, network: &Network) -> Self::AddResponseFut;
37    type UpdateResponseFut: std::future::Future<Output = Result<NetworkRegistryUpdateResult, fidl::Error>>
38        + Send;
39    fn r#update(&self, network: &Network) -> Self::UpdateResponseFut;
40    type RemoveResponseFut: std::future::Future<Output = Result<NetworkRegistryRemoveResult, fidl::Error>>
41        + Send;
42    fn r#remove(&self, network_id: u32) -> Self::RemoveResponseFut;
43}
44#[derive(Debug)]
45#[cfg(target_os = "fuchsia")]
46pub struct FuchsiaNetworksSynchronousProxy {
47    client: fidl::client::sync::Client,
48}
49
50#[cfg(target_os = "fuchsia")]
51impl fidl::endpoints::SynchronousProxy for FuchsiaNetworksSynchronousProxy {
52    type Proxy = FuchsiaNetworksProxy;
53    type Protocol = FuchsiaNetworksMarker;
54
55    fn from_channel(inner: fidl::Channel) -> Self {
56        Self::new(inner)
57    }
58
59    fn into_channel(self) -> fidl::Channel {
60        self.client.into_channel()
61    }
62
63    fn as_channel(&self) -> &fidl::Channel {
64        self.client.as_channel()
65    }
66}
67
68#[cfg(target_os = "fuchsia")]
69impl FuchsiaNetworksSynchronousProxy {
70    pub fn new(channel: fidl::Channel) -> Self {
71        Self { client: fidl::client::sync::Client::new(channel) }
72    }
73
74    pub fn into_channel(self) -> fidl::Channel {
75        self.client.into_channel()
76    }
77
78    /// Waits until an event arrives and returns it. It is safe for other
79    /// threads to make concurrent requests while waiting for an event.
80    pub fn wait_for_event(
81        &self,
82        deadline: zx::MonotonicInstant,
83    ) -> Result<FuchsiaNetworksEvent, fidl::Error> {
84        FuchsiaNetworksEvent::decode(self.client.wait_for_event::<FuchsiaNetworksMarker>(deadline)?)
85    }
86
87    /// Sets the default network.
88    ///
89    /// The network must have previously been registered by a call to `Add`.
90    pub fn r#set_default(
91        &self,
92        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
93        ___deadline: zx::MonotonicInstant,
94    ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
95        let _response =
96            self.client.send_query::<NetworkRegistrySetDefaultRequest, fidl::encoding::ResultType<
97                fidl::encoding::EmptyStruct,
98                NetworkRegistrySetDefaultError,
99            >, FuchsiaNetworksMarker>(
100                (network_id,),
101                0x787930c67b8cf82c,
102                fidl::encoding::DynamicFlags::empty(),
103                ___deadline,
104            )?;
105        Ok(_response.map(|x| x))
106    }
107
108    /// Add a new network.
109    ///
110    /// This call will not return until the DNS servers have been successfully
111    /// updated in netcfg.
112    pub fn r#add(
113        &self,
114        mut network: &Network,
115        ___deadline: zx::MonotonicInstant,
116    ) -> Result<NetworkRegistryAddResult, fidl::Error> {
117        let _response =
118            self.client.send_query::<NetworkRegistryAddRequest, fidl::encoding::ResultType<
119                fidl::encoding::EmptyStruct,
120                NetworkRegistryAddError,
121            >, FuchsiaNetworksMarker>(
122                (network,),
123                0x197e70a1cbeab3ad,
124                fidl::encoding::DynamicFlags::empty(),
125                ___deadline,
126            )?;
127        Ok(_response.map(|x| x))
128    }
129
130    /// Update a previously Added network.
131    ///
132    /// This call will not return until the DNS servers have been
133    /// successfully updated in netcfg.
134    pub fn r#update(
135        &self,
136        mut network: &Network,
137        ___deadline: zx::MonotonicInstant,
138    ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
139        let _response =
140            self.client.send_query::<NetworkRegistryUpdateRequest, fidl::encoding::ResultType<
141                fidl::encoding::EmptyStruct,
142                NetworkRegistryUpdateError,
143            >, FuchsiaNetworksMarker>(
144                (network,),
145                0x3bc790ae5418ff0e,
146                fidl::encoding::DynamicFlags::empty(),
147                ___deadline,
148            )?;
149        Ok(_response.map(|x| x))
150    }
151
152    /// Remove a previously Added network.
153    ///
154    /// This call will not return until the DNS servers have been
155    /// successfully updated in netcfg.
156    pub fn r#remove(
157        &self,
158        mut network_id: u32,
159        ___deadline: zx::MonotonicInstant,
160    ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
161        let _response =
162            self.client.send_query::<NetworkRegistryRemoveRequest, fidl::encoding::ResultType<
163                fidl::encoding::EmptyStruct,
164                NetworkRegistryRemoveError,
165            >, FuchsiaNetworksMarker>(
166                (network_id,),
167                0x1302df41dca6379e,
168                fidl::encoding::DynamicFlags::empty(),
169                ___deadline,
170            )?;
171        Ok(_response.map(|x| x))
172    }
173}
174
175#[cfg(target_os = "fuchsia")]
176impl From<FuchsiaNetworksSynchronousProxy> for zx::NullableHandle {
177    fn from(value: FuchsiaNetworksSynchronousProxy) -> Self {
178        value.into_channel().into()
179    }
180}
181
182#[cfg(target_os = "fuchsia")]
183impl From<fidl::Channel> for FuchsiaNetworksSynchronousProxy {
184    fn from(value: fidl::Channel) -> Self {
185        Self::new(value)
186    }
187}
188
189#[cfg(target_os = "fuchsia")]
190impl fidl::endpoints::FromClient for FuchsiaNetworksSynchronousProxy {
191    type Protocol = FuchsiaNetworksMarker;
192
193    fn from_client(value: fidl::endpoints::ClientEnd<FuchsiaNetworksMarker>) -> Self {
194        Self::new(value.into_channel())
195    }
196}
197
198#[derive(Debug, Clone)]
199pub struct FuchsiaNetworksProxy {
200    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
201}
202
203impl fidl::endpoints::Proxy for FuchsiaNetworksProxy {
204    type Protocol = FuchsiaNetworksMarker;
205
206    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
207        Self::new(inner)
208    }
209
210    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
211        self.client.into_channel().map_err(|client| Self { client })
212    }
213
214    fn as_channel(&self) -> &::fidl::AsyncChannel {
215        self.client.as_channel()
216    }
217}
218
219impl FuchsiaNetworksProxy {
220    /// Create a new Proxy for fuchsia.net.policy.socketproxy/FuchsiaNetworks.
221    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
222        let protocol_name = <FuchsiaNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
223        Self { client: fidl::client::Client::new(channel, protocol_name) }
224    }
225
226    /// Get a Stream of events from the remote end of the protocol.
227    ///
228    /// # Panics
229    ///
230    /// Panics if the event stream was already taken.
231    pub fn take_event_stream(&self) -> FuchsiaNetworksEventStream {
232        FuchsiaNetworksEventStream { event_receiver: self.client.take_event_receiver() }
233    }
234
235    /// Sets the default network.
236    ///
237    /// The network must have previously been registered by a call to `Add`.
238    pub fn r#set_default(
239        &self,
240        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
241    ) -> fidl::client::QueryResponseFut<
242        NetworkRegistrySetDefaultResult,
243        fidl::encoding::DefaultFuchsiaResourceDialect,
244    > {
245        FuchsiaNetworksProxyInterface::r#set_default(self, network_id)
246    }
247
248    /// Add a new network.
249    ///
250    /// This call will not return until the DNS servers have been successfully
251    /// updated in netcfg.
252    pub fn r#add(
253        &self,
254        mut network: &Network,
255    ) -> fidl::client::QueryResponseFut<
256        NetworkRegistryAddResult,
257        fidl::encoding::DefaultFuchsiaResourceDialect,
258    > {
259        FuchsiaNetworksProxyInterface::r#add(self, network)
260    }
261
262    /// Update a previously Added network.
263    ///
264    /// This call will not return until the DNS servers have been
265    /// successfully updated in netcfg.
266    pub fn r#update(
267        &self,
268        mut network: &Network,
269    ) -> fidl::client::QueryResponseFut<
270        NetworkRegistryUpdateResult,
271        fidl::encoding::DefaultFuchsiaResourceDialect,
272    > {
273        FuchsiaNetworksProxyInterface::r#update(self, network)
274    }
275
276    /// Remove a previously Added network.
277    ///
278    /// This call will not return until the DNS servers have been
279    /// successfully updated in netcfg.
280    pub fn r#remove(
281        &self,
282        mut network_id: u32,
283    ) -> fidl::client::QueryResponseFut<
284        NetworkRegistryRemoveResult,
285        fidl::encoding::DefaultFuchsiaResourceDialect,
286    > {
287        FuchsiaNetworksProxyInterface::r#remove(self, network_id)
288    }
289}
290
291impl FuchsiaNetworksProxyInterface for FuchsiaNetworksProxy {
292    type SetDefaultResponseFut = fidl::client::QueryResponseFut<
293        NetworkRegistrySetDefaultResult,
294        fidl::encoding::DefaultFuchsiaResourceDialect,
295    >;
296    fn r#set_default(
297        &self,
298        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
299    ) -> Self::SetDefaultResponseFut {
300        fn _decode(
301            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
302        ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
303            let _response = fidl::client::decode_transaction_body::<
304                fidl::encoding::ResultType<
305                    fidl::encoding::EmptyStruct,
306                    NetworkRegistrySetDefaultError,
307                >,
308                fidl::encoding::DefaultFuchsiaResourceDialect,
309                0x787930c67b8cf82c,
310            >(_buf?)?;
311            Ok(_response.map(|x| x))
312        }
313        self.client.send_query_and_decode::<
314            NetworkRegistrySetDefaultRequest,
315            NetworkRegistrySetDefaultResult,
316        >(
317            (network_id,),
318            0x787930c67b8cf82c,
319            fidl::encoding::DynamicFlags::empty(),
320            _decode,
321        )
322    }
323
324    type AddResponseFut = fidl::client::QueryResponseFut<
325        NetworkRegistryAddResult,
326        fidl::encoding::DefaultFuchsiaResourceDialect,
327    >;
328    fn r#add(&self, mut network: &Network) -> Self::AddResponseFut {
329        fn _decode(
330            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
331        ) -> Result<NetworkRegistryAddResult, fidl::Error> {
332            let _response = fidl::client::decode_transaction_body::<
333                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryAddError>,
334                fidl::encoding::DefaultFuchsiaResourceDialect,
335                0x197e70a1cbeab3ad,
336            >(_buf?)?;
337            Ok(_response.map(|x| x))
338        }
339        self.client.send_query_and_decode::<NetworkRegistryAddRequest, NetworkRegistryAddResult>(
340            (network,),
341            0x197e70a1cbeab3ad,
342            fidl::encoding::DynamicFlags::empty(),
343            _decode,
344        )
345    }
346
347    type UpdateResponseFut = fidl::client::QueryResponseFut<
348        NetworkRegistryUpdateResult,
349        fidl::encoding::DefaultFuchsiaResourceDialect,
350    >;
351    fn r#update(&self, mut network: &Network) -> Self::UpdateResponseFut {
352        fn _decode(
353            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
354        ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
355            let _response = fidl::client::decode_transaction_body::<
356                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryUpdateError>,
357                fidl::encoding::DefaultFuchsiaResourceDialect,
358                0x3bc790ae5418ff0e,
359            >(_buf?)?;
360            Ok(_response.map(|x| x))
361        }
362        self.client
363            .send_query_and_decode::<NetworkRegistryUpdateRequest, NetworkRegistryUpdateResult>(
364                (network,),
365                0x3bc790ae5418ff0e,
366                fidl::encoding::DynamicFlags::empty(),
367                _decode,
368            )
369    }
370
371    type RemoveResponseFut = fidl::client::QueryResponseFut<
372        NetworkRegistryRemoveResult,
373        fidl::encoding::DefaultFuchsiaResourceDialect,
374    >;
375    fn r#remove(&self, mut network_id: u32) -> Self::RemoveResponseFut {
376        fn _decode(
377            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
378        ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
379            let _response = fidl::client::decode_transaction_body::<
380                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryRemoveError>,
381                fidl::encoding::DefaultFuchsiaResourceDialect,
382                0x1302df41dca6379e,
383            >(_buf?)?;
384            Ok(_response.map(|x| x))
385        }
386        self.client
387            .send_query_and_decode::<NetworkRegistryRemoveRequest, NetworkRegistryRemoveResult>(
388                (network_id,),
389                0x1302df41dca6379e,
390                fidl::encoding::DynamicFlags::empty(),
391                _decode,
392            )
393    }
394}
395
396pub struct FuchsiaNetworksEventStream {
397    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
398}
399
400impl std::marker::Unpin for FuchsiaNetworksEventStream {}
401
402impl futures::stream::FusedStream for FuchsiaNetworksEventStream {
403    fn is_terminated(&self) -> bool {
404        self.event_receiver.is_terminated()
405    }
406}
407
408impl futures::Stream for FuchsiaNetworksEventStream {
409    type Item = Result<FuchsiaNetworksEvent, fidl::Error>;
410
411    fn poll_next(
412        mut self: std::pin::Pin<&mut Self>,
413        cx: &mut std::task::Context<'_>,
414    ) -> std::task::Poll<Option<Self::Item>> {
415        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
416            &mut self.event_receiver,
417            cx
418        )?) {
419            Some(buf) => std::task::Poll::Ready(Some(FuchsiaNetworksEvent::decode(buf))),
420            None => std::task::Poll::Ready(None),
421        }
422    }
423}
424
425#[derive(Debug)]
426pub enum FuchsiaNetworksEvent {}
427
428impl FuchsiaNetworksEvent {
429    /// Decodes a message buffer as a [`FuchsiaNetworksEvent`].
430    fn decode(
431        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
432    ) -> Result<FuchsiaNetworksEvent, fidl::Error> {
433        let (bytes, _handles) = buf.split_mut();
434        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
435        debug_assert_eq!(tx_header.tx_id, 0);
436        match tx_header.ordinal {
437            _ => Err(fidl::Error::UnknownOrdinal {
438                ordinal: tx_header.ordinal,
439                protocol_name:
440                    <FuchsiaNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
441            }),
442        }
443    }
444}
445
446/// A Stream of incoming requests for fuchsia.net.policy.socketproxy/FuchsiaNetworks.
447pub struct FuchsiaNetworksRequestStream {
448    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
449    is_terminated: bool,
450}
451
452impl std::marker::Unpin for FuchsiaNetworksRequestStream {}
453
454impl futures::stream::FusedStream for FuchsiaNetworksRequestStream {
455    fn is_terminated(&self) -> bool {
456        self.is_terminated
457    }
458}
459
460impl fidl::endpoints::RequestStream for FuchsiaNetworksRequestStream {
461    type Protocol = FuchsiaNetworksMarker;
462    type ControlHandle = FuchsiaNetworksControlHandle;
463
464    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
465        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
466    }
467
468    fn control_handle(&self) -> Self::ControlHandle {
469        FuchsiaNetworksControlHandle { inner: self.inner.clone() }
470    }
471
472    fn into_inner(
473        self,
474    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
475    {
476        (self.inner, self.is_terminated)
477    }
478
479    fn from_inner(
480        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
481        is_terminated: bool,
482    ) -> Self {
483        Self { inner, is_terminated }
484    }
485}
486
487impl futures::Stream for FuchsiaNetworksRequestStream {
488    type Item = Result<FuchsiaNetworksRequest, fidl::Error>;
489
490    fn poll_next(
491        mut self: std::pin::Pin<&mut Self>,
492        cx: &mut std::task::Context<'_>,
493    ) -> std::task::Poll<Option<Self::Item>> {
494        let this = &mut *self;
495        if this.inner.check_shutdown(cx) {
496            this.is_terminated = true;
497            return std::task::Poll::Ready(None);
498        }
499        if this.is_terminated {
500            panic!("polled FuchsiaNetworksRequestStream after completion");
501        }
502        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
503            |bytes, handles| {
504                match this.inner.channel().read_etc(cx, bytes, handles) {
505                    std::task::Poll::Ready(Ok(())) => {}
506                    std::task::Poll::Pending => return std::task::Poll::Pending,
507                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
508                        this.is_terminated = true;
509                        return std::task::Poll::Ready(None);
510                    }
511                    std::task::Poll::Ready(Err(e)) => {
512                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
513                            e.into(),
514                        ))));
515                    }
516                }
517
518                // A message has been received from the channel
519                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
520
521                std::task::Poll::Ready(Some(match header.ordinal {
522                    0x787930c67b8cf82c => {
523                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
524                        let mut req = fidl::new_empty!(
525                            NetworkRegistrySetDefaultRequest,
526                            fidl::encoding::DefaultFuchsiaResourceDialect
527                        );
528                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistrySetDefaultRequest>(&header, _body_bytes, handles, &mut req)?;
529                        let control_handle =
530                            FuchsiaNetworksControlHandle { inner: this.inner.clone() };
531                        Ok(FuchsiaNetworksRequest::SetDefault {
532                            network_id: req.network_id,
533
534                            responder: FuchsiaNetworksSetDefaultResponder {
535                                control_handle: std::mem::ManuallyDrop::new(control_handle),
536                                tx_id: header.tx_id,
537                            },
538                        })
539                    }
540                    0x197e70a1cbeab3ad => {
541                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
542                        let mut req = fidl::new_empty!(
543                            NetworkRegistryAddRequest,
544                            fidl::encoding::DefaultFuchsiaResourceDialect
545                        );
546                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryAddRequest>(&header, _body_bytes, handles, &mut req)?;
547                        let control_handle =
548                            FuchsiaNetworksControlHandle { inner: this.inner.clone() };
549                        Ok(FuchsiaNetworksRequest::Add {
550                            network: req.network,
551
552                            responder: FuchsiaNetworksAddResponder {
553                                control_handle: std::mem::ManuallyDrop::new(control_handle),
554                                tx_id: header.tx_id,
555                            },
556                        })
557                    }
558                    0x3bc790ae5418ff0e => {
559                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
560                        let mut req = fidl::new_empty!(
561                            NetworkRegistryUpdateRequest,
562                            fidl::encoding::DefaultFuchsiaResourceDialect
563                        );
564                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
565                        let control_handle =
566                            FuchsiaNetworksControlHandle { inner: this.inner.clone() };
567                        Ok(FuchsiaNetworksRequest::Update {
568                            network: req.network,
569
570                            responder: FuchsiaNetworksUpdateResponder {
571                                control_handle: std::mem::ManuallyDrop::new(control_handle),
572                                tx_id: header.tx_id,
573                            },
574                        })
575                    }
576                    0x1302df41dca6379e => {
577                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
578                        let mut req = fidl::new_empty!(
579                            NetworkRegistryRemoveRequest,
580                            fidl::encoding::DefaultFuchsiaResourceDialect
581                        );
582                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryRemoveRequest>(&header, _body_bytes, handles, &mut req)?;
583                        let control_handle =
584                            FuchsiaNetworksControlHandle { inner: this.inner.clone() };
585                        Ok(FuchsiaNetworksRequest::Remove {
586                            network_id: req.network_id,
587
588                            responder: FuchsiaNetworksRemoveResponder {
589                                control_handle: std::mem::ManuallyDrop::new(control_handle),
590                                tx_id: header.tx_id,
591                            },
592                        })
593                    }
594                    _ => Err(fidl::Error::UnknownOrdinal {
595                        ordinal: header.ordinal,
596                        protocol_name:
597                            <FuchsiaNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
598                    }),
599                }))
600            },
601        )
602    }
603}
604
605/// FuchsiaNetworks is used for Fuchsia to communicate changes to the network.
606/// Only one connection to this service is considered valid at any one time.
607/// If the connection is lost for any reason, all previously registered
608/// networks are considered invalid and will be removed.
609#[derive(Debug)]
610pub enum FuchsiaNetworksRequest {
611    /// Sets the default network.
612    ///
613    /// The network must have previously been registered by a call to `Add`.
614    SetDefault {
615        network_id: fidl_fuchsia_posix_socket::OptionalUint32,
616        responder: FuchsiaNetworksSetDefaultResponder,
617    },
618    /// Add a new network.
619    ///
620    /// This call will not return until the DNS servers have been successfully
621    /// updated in netcfg.
622    Add { network: Network, responder: FuchsiaNetworksAddResponder },
623    /// Update a previously Added network.
624    ///
625    /// This call will not return until the DNS servers have been
626    /// successfully updated in netcfg.
627    Update { network: Network, responder: FuchsiaNetworksUpdateResponder },
628    /// Remove a previously Added network.
629    ///
630    /// This call will not return until the DNS servers have been
631    /// successfully updated in netcfg.
632    Remove { network_id: u32, responder: FuchsiaNetworksRemoveResponder },
633}
634
635impl FuchsiaNetworksRequest {
636    #[allow(irrefutable_let_patterns)]
637    pub fn into_set_default(
638        self,
639    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint32, FuchsiaNetworksSetDefaultResponder)>
640    {
641        if let FuchsiaNetworksRequest::SetDefault { network_id, responder } = self {
642            Some((network_id, responder))
643        } else {
644            None
645        }
646    }
647
648    #[allow(irrefutable_let_patterns)]
649    pub fn into_add(self) -> Option<(Network, FuchsiaNetworksAddResponder)> {
650        if let FuchsiaNetworksRequest::Add { network, responder } = self {
651            Some((network, responder))
652        } else {
653            None
654        }
655    }
656
657    #[allow(irrefutable_let_patterns)]
658    pub fn into_update(self) -> Option<(Network, FuchsiaNetworksUpdateResponder)> {
659        if let FuchsiaNetworksRequest::Update { network, responder } = self {
660            Some((network, responder))
661        } else {
662            None
663        }
664    }
665
666    #[allow(irrefutable_let_patterns)]
667    pub fn into_remove(self) -> Option<(u32, FuchsiaNetworksRemoveResponder)> {
668        if let FuchsiaNetworksRequest::Remove { network_id, responder } = self {
669            Some((network_id, responder))
670        } else {
671            None
672        }
673    }
674
675    /// Name of the method defined in FIDL
676    pub fn method_name(&self) -> &'static str {
677        match *self {
678            FuchsiaNetworksRequest::SetDefault { .. } => "set_default",
679            FuchsiaNetworksRequest::Add { .. } => "add",
680            FuchsiaNetworksRequest::Update { .. } => "update",
681            FuchsiaNetworksRequest::Remove { .. } => "remove",
682        }
683    }
684}
685
686#[derive(Debug, Clone)]
687pub struct FuchsiaNetworksControlHandle {
688    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
689}
690
691impl FuchsiaNetworksControlHandle {
692    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
693        self.inner.shutdown_with_epitaph(status.into())
694    }
695}
696
697impl fidl::endpoints::ControlHandle for FuchsiaNetworksControlHandle {
698    fn shutdown(&self) {
699        self.inner.shutdown()
700    }
701
702    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
703        self.inner.shutdown_with_epitaph(status)
704    }
705
706    fn is_closed(&self) -> bool {
707        self.inner.channel().is_closed()
708    }
709    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
710        self.inner.channel().on_closed()
711    }
712
713    #[cfg(target_os = "fuchsia")]
714    fn signal_peer(
715        &self,
716        clear_mask: zx::Signals,
717        set_mask: zx::Signals,
718    ) -> Result<(), zx_status::Status> {
719        use fidl::Peered;
720        self.inner.channel().signal_peer(clear_mask, set_mask)
721    }
722}
723
724impl FuchsiaNetworksControlHandle {}
725
726#[must_use = "FIDL methods require a response to be sent"]
727#[derive(Debug)]
728pub struct FuchsiaNetworksSetDefaultResponder {
729    control_handle: std::mem::ManuallyDrop<FuchsiaNetworksControlHandle>,
730    tx_id: u32,
731}
732
733/// Set the the channel to be shutdown (see [`FuchsiaNetworksControlHandle::shutdown`])
734/// if the responder is dropped without sending a response, so that the client
735/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
736impl std::ops::Drop for FuchsiaNetworksSetDefaultResponder {
737    fn drop(&mut self) {
738        self.control_handle.shutdown();
739        // Safety: drops once, never accessed again
740        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
741    }
742}
743
744impl fidl::endpoints::Responder for FuchsiaNetworksSetDefaultResponder {
745    type ControlHandle = FuchsiaNetworksControlHandle;
746
747    fn control_handle(&self) -> &FuchsiaNetworksControlHandle {
748        &self.control_handle
749    }
750
751    fn drop_without_shutdown(mut self) {
752        // Safety: drops once, never accessed again due to mem::forget
753        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
754        // Prevent Drop from running (which would shut down the channel)
755        std::mem::forget(self);
756    }
757}
758
759impl FuchsiaNetworksSetDefaultResponder {
760    /// Sends a response to the FIDL transaction.
761    ///
762    /// Sets the channel to shutdown if an error occurs.
763    pub fn send(
764        self,
765        mut result: Result<(), NetworkRegistrySetDefaultError>,
766    ) -> Result<(), fidl::Error> {
767        let _result = self.send_raw(result);
768        if _result.is_err() {
769            self.control_handle.shutdown();
770        }
771        self.drop_without_shutdown();
772        _result
773    }
774
775    /// Similar to "send" but does not shutdown the channel if an error occurs.
776    pub fn send_no_shutdown_on_err(
777        self,
778        mut result: Result<(), NetworkRegistrySetDefaultError>,
779    ) -> Result<(), fidl::Error> {
780        let _result = self.send_raw(result);
781        self.drop_without_shutdown();
782        _result
783    }
784
785    fn send_raw(
786        &self,
787        mut result: Result<(), NetworkRegistrySetDefaultError>,
788    ) -> Result<(), fidl::Error> {
789        self.control_handle.inner.send::<fidl::encoding::ResultType<
790            fidl::encoding::EmptyStruct,
791            NetworkRegistrySetDefaultError,
792        >>(
793            result,
794            self.tx_id,
795            0x787930c67b8cf82c,
796            fidl::encoding::DynamicFlags::empty(),
797        )
798    }
799}
800
801#[must_use = "FIDL methods require a response to be sent"]
802#[derive(Debug)]
803pub struct FuchsiaNetworksAddResponder {
804    control_handle: std::mem::ManuallyDrop<FuchsiaNetworksControlHandle>,
805    tx_id: u32,
806}
807
808/// Set the the channel to be shutdown (see [`FuchsiaNetworksControlHandle::shutdown`])
809/// if the responder is dropped without sending a response, so that the client
810/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
811impl std::ops::Drop for FuchsiaNetworksAddResponder {
812    fn drop(&mut self) {
813        self.control_handle.shutdown();
814        // Safety: drops once, never accessed again
815        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
816    }
817}
818
819impl fidl::endpoints::Responder for FuchsiaNetworksAddResponder {
820    type ControlHandle = FuchsiaNetworksControlHandle;
821
822    fn control_handle(&self) -> &FuchsiaNetworksControlHandle {
823        &self.control_handle
824    }
825
826    fn drop_without_shutdown(mut self) {
827        // Safety: drops once, never accessed again due to mem::forget
828        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
829        // Prevent Drop from running (which would shut down the channel)
830        std::mem::forget(self);
831    }
832}
833
834impl FuchsiaNetworksAddResponder {
835    /// Sends a response to the FIDL transaction.
836    ///
837    /// Sets the channel to shutdown if an error occurs.
838    pub fn send(self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
839        let _result = self.send_raw(result);
840        if _result.is_err() {
841            self.control_handle.shutdown();
842        }
843        self.drop_without_shutdown();
844        _result
845    }
846
847    /// Similar to "send" but does not shutdown the channel if an error occurs.
848    pub fn send_no_shutdown_on_err(
849        self,
850        mut result: Result<(), NetworkRegistryAddError>,
851    ) -> Result<(), fidl::Error> {
852        let _result = self.send_raw(result);
853        self.drop_without_shutdown();
854        _result
855    }
856
857    fn send_raw(&self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
858        self.control_handle.inner.send::<fidl::encoding::ResultType<
859            fidl::encoding::EmptyStruct,
860            NetworkRegistryAddError,
861        >>(
862            result,
863            self.tx_id,
864            0x197e70a1cbeab3ad,
865            fidl::encoding::DynamicFlags::empty(),
866        )
867    }
868}
869
870#[must_use = "FIDL methods require a response to be sent"]
871#[derive(Debug)]
872pub struct FuchsiaNetworksUpdateResponder {
873    control_handle: std::mem::ManuallyDrop<FuchsiaNetworksControlHandle>,
874    tx_id: u32,
875}
876
877/// Set the the channel to be shutdown (see [`FuchsiaNetworksControlHandle::shutdown`])
878/// if the responder is dropped without sending a response, so that the client
879/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
880impl std::ops::Drop for FuchsiaNetworksUpdateResponder {
881    fn drop(&mut self) {
882        self.control_handle.shutdown();
883        // Safety: drops once, never accessed again
884        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
885    }
886}
887
888impl fidl::endpoints::Responder for FuchsiaNetworksUpdateResponder {
889    type ControlHandle = FuchsiaNetworksControlHandle;
890
891    fn control_handle(&self) -> &FuchsiaNetworksControlHandle {
892        &self.control_handle
893    }
894
895    fn drop_without_shutdown(mut self) {
896        // Safety: drops once, never accessed again due to mem::forget
897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
898        // Prevent Drop from running (which would shut down the channel)
899        std::mem::forget(self);
900    }
901}
902
903impl FuchsiaNetworksUpdateResponder {
904    /// Sends a response to the FIDL transaction.
905    ///
906    /// Sets the channel to shutdown if an error occurs.
907    pub fn send(
908        self,
909        mut result: Result<(), NetworkRegistryUpdateError>,
910    ) -> Result<(), fidl::Error> {
911        let _result = self.send_raw(result);
912        if _result.is_err() {
913            self.control_handle.shutdown();
914        }
915        self.drop_without_shutdown();
916        _result
917    }
918
919    /// Similar to "send" but does not shutdown the channel if an error occurs.
920    pub fn send_no_shutdown_on_err(
921        self,
922        mut result: Result<(), NetworkRegistryUpdateError>,
923    ) -> Result<(), fidl::Error> {
924        let _result = self.send_raw(result);
925        self.drop_without_shutdown();
926        _result
927    }
928
929    fn send_raw(
930        &self,
931        mut result: Result<(), NetworkRegistryUpdateError>,
932    ) -> Result<(), fidl::Error> {
933        self.control_handle.inner.send::<fidl::encoding::ResultType<
934            fidl::encoding::EmptyStruct,
935            NetworkRegistryUpdateError,
936        >>(
937            result,
938            self.tx_id,
939            0x3bc790ae5418ff0e,
940            fidl::encoding::DynamicFlags::empty(),
941        )
942    }
943}
944
945#[must_use = "FIDL methods require a response to be sent"]
946#[derive(Debug)]
947pub struct FuchsiaNetworksRemoveResponder {
948    control_handle: std::mem::ManuallyDrop<FuchsiaNetworksControlHandle>,
949    tx_id: u32,
950}
951
952/// Set the the channel to be shutdown (see [`FuchsiaNetworksControlHandle::shutdown`])
953/// if the responder is dropped without sending a response, so that the client
954/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
955impl std::ops::Drop for FuchsiaNetworksRemoveResponder {
956    fn drop(&mut self) {
957        self.control_handle.shutdown();
958        // Safety: drops once, never accessed again
959        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
960    }
961}
962
963impl fidl::endpoints::Responder for FuchsiaNetworksRemoveResponder {
964    type ControlHandle = FuchsiaNetworksControlHandle;
965
966    fn control_handle(&self) -> &FuchsiaNetworksControlHandle {
967        &self.control_handle
968    }
969
970    fn drop_without_shutdown(mut self) {
971        // Safety: drops once, never accessed again due to mem::forget
972        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
973        // Prevent Drop from running (which would shut down the channel)
974        std::mem::forget(self);
975    }
976}
977
978impl FuchsiaNetworksRemoveResponder {
979    /// Sends a response to the FIDL transaction.
980    ///
981    /// Sets the channel to shutdown if an error occurs.
982    pub fn send(
983        self,
984        mut result: Result<(), NetworkRegistryRemoveError>,
985    ) -> Result<(), fidl::Error> {
986        let _result = self.send_raw(result);
987        if _result.is_err() {
988            self.control_handle.shutdown();
989        }
990        self.drop_without_shutdown();
991        _result
992    }
993
994    /// Similar to "send" but does not shutdown the channel if an error occurs.
995    pub fn send_no_shutdown_on_err(
996        self,
997        mut result: Result<(), NetworkRegistryRemoveError>,
998    ) -> Result<(), fidl::Error> {
999        let _result = self.send_raw(result);
1000        self.drop_without_shutdown();
1001        _result
1002    }
1003
1004    fn send_raw(
1005        &self,
1006        mut result: Result<(), NetworkRegistryRemoveError>,
1007    ) -> Result<(), fidl::Error> {
1008        self.control_handle.inner.send::<fidl::encoding::ResultType<
1009            fidl::encoding::EmptyStruct,
1010            NetworkRegistryRemoveError,
1011        >>(
1012            result,
1013            self.tx_id,
1014            0x1302df41dca6379e,
1015            fidl::encoding::DynamicFlags::empty(),
1016        )
1017    }
1018}
1019
1020#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1021pub struct NetworkRegistryMarker;
1022
1023impl fidl::endpoints::ProtocolMarker for NetworkRegistryMarker {
1024    type Proxy = NetworkRegistryProxy;
1025    type RequestStream = NetworkRegistryRequestStream;
1026    #[cfg(target_os = "fuchsia")]
1027    type SynchronousProxy = NetworkRegistrySynchronousProxy;
1028
1029    const DEBUG_NAME: &'static str = "fuchsia.net.policy.socketproxy.NetworkRegistry";
1030}
1031impl fidl::endpoints::DiscoverableProtocolMarker for NetworkRegistryMarker {}
1032pub type NetworkRegistrySetDefaultResult = Result<(), NetworkRegistrySetDefaultError>;
1033pub type NetworkRegistryAddResult = Result<(), NetworkRegistryAddError>;
1034pub type NetworkRegistryUpdateResult = Result<(), NetworkRegistryUpdateError>;
1035pub type NetworkRegistryRemoveResult = Result<(), NetworkRegistryRemoveError>;
1036
1037pub trait NetworkRegistryProxyInterface: Send + Sync {
1038    type SetDefaultResponseFut: std::future::Future<Output = Result<NetworkRegistrySetDefaultResult, fidl::Error>>
1039        + Send;
1040    fn r#set_default(
1041        &self,
1042        network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
1043    ) -> Self::SetDefaultResponseFut;
1044    type AddResponseFut: std::future::Future<Output = Result<NetworkRegistryAddResult, fidl::Error>>
1045        + Send;
1046    fn r#add(&self, network: &Network) -> Self::AddResponseFut;
1047    type UpdateResponseFut: std::future::Future<Output = Result<NetworkRegistryUpdateResult, fidl::Error>>
1048        + Send;
1049    fn r#update(&self, network: &Network) -> Self::UpdateResponseFut;
1050    type RemoveResponseFut: std::future::Future<Output = Result<NetworkRegistryRemoveResult, fidl::Error>>
1051        + Send;
1052    fn r#remove(&self, network_id: u32) -> Self::RemoveResponseFut;
1053}
1054#[derive(Debug)]
1055#[cfg(target_os = "fuchsia")]
1056pub struct NetworkRegistrySynchronousProxy {
1057    client: fidl::client::sync::Client,
1058}
1059
1060#[cfg(target_os = "fuchsia")]
1061impl fidl::endpoints::SynchronousProxy for NetworkRegistrySynchronousProxy {
1062    type Proxy = NetworkRegistryProxy;
1063    type Protocol = NetworkRegistryMarker;
1064
1065    fn from_channel(inner: fidl::Channel) -> Self {
1066        Self::new(inner)
1067    }
1068
1069    fn into_channel(self) -> fidl::Channel {
1070        self.client.into_channel()
1071    }
1072
1073    fn as_channel(&self) -> &fidl::Channel {
1074        self.client.as_channel()
1075    }
1076}
1077
1078#[cfg(target_os = "fuchsia")]
1079impl NetworkRegistrySynchronousProxy {
1080    pub fn new(channel: fidl::Channel) -> Self {
1081        Self { client: fidl::client::sync::Client::new(channel) }
1082    }
1083
1084    pub fn into_channel(self) -> fidl::Channel {
1085        self.client.into_channel()
1086    }
1087
1088    /// Waits until an event arrives and returns it. It is safe for other
1089    /// threads to make concurrent requests while waiting for an event.
1090    pub fn wait_for_event(
1091        &self,
1092        deadline: zx::MonotonicInstant,
1093    ) -> Result<NetworkRegistryEvent, fidl::Error> {
1094        NetworkRegistryEvent::decode(self.client.wait_for_event::<NetworkRegistryMarker>(deadline)?)
1095    }
1096
1097    /// Sets the default network.
1098    ///
1099    /// The network must have previously been registered by a call to `Add`.
1100    pub fn r#set_default(
1101        &self,
1102        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
1103        ___deadline: zx::MonotonicInstant,
1104    ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
1105        let _response =
1106            self.client.send_query::<NetworkRegistrySetDefaultRequest, fidl::encoding::ResultType<
1107                fidl::encoding::EmptyStruct,
1108                NetworkRegistrySetDefaultError,
1109            >, NetworkRegistryMarker>(
1110                (network_id,),
1111                0x787930c67b8cf82c,
1112                fidl::encoding::DynamicFlags::empty(),
1113                ___deadline,
1114            )?;
1115        Ok(_response.map(|x| x))
1116    }
1117
1118    /// Add a new network.
1119    ///
1120    /// This call will not return until the DNS servers have been successfully
1121    /// updated in netcfg.
1122    pub fn r#add(
1123        &self,
1124        mut network: &Network,
1125        ___deadline: zx::MonotonicInstant,
1126    ) -> Result<NetworkRegistryAddResult, fidl::Error> {
1127        let _response =
1128            self.client.send_query::<NetworkRegistryAddRequest, fidl::encoding::ResultType<
1129                fidl::encoding::EmptyStruct,
1130                NetworkRegistryAddError,
1131            >, NetworkRegistryMarker>(
1132                (network,),
1133                0x197e70a1cbeab3ad,
1134                fidl::encoding::DynamicFlags::empty(),
1135                ___deadline,
1136            )?;
1137        Ok(_response.map(|x| x))
1138    }
1139
1140    /// Update a previously Added network.
1141    ///
1142    /// This call will not return until the DNS servers have been
1143    /// successfully updated in netcfg.
1144    pub fn r#update(
1145        &self,
1146        mut network: &Network,
1147        ___deadline: zx::MonotonicInstant,
1148    ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
1149        let _response =
1150            self.client.send_query::<NetworkRegistryUpdateRequest, fidl::encoding::ResultType<
1151                fidl::encoding::EmptyStruct,
1152                NetworkRegistryUpdateError,
1153            >, NetworkRegistryMarker>(
1154                (network,),
1155                0x3bc790ae5418ff0e,
1156                fidl::encoding::DynamicFlags::empty(),
1157                ___deadline,
1158            )?;
1159        Ok(_response.map(|x| x))
1160    }
1161
1162    /// Remove a previously Added network.
1163    ///
1164    /// This call will not return until the DNS servers have been
1165    /// successfully updated in netcfg.
1166    pub fn r#remove(
1167        &self,
1168        mut network_id: u32,
1169        ___deadline: zx::MonotonicInstant,
1170    ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
1171        let _response =
1172            self.client.send_query::<NetworkRegistryRemoveRequest, fidl::encoding::ResultType<
1173                fidl::encoding::EmptyStruct,
1174                NetworkRegistryRemoveError,
1175            >, NetworkRegistryMarker>(
1176                (network_id,),
1177                0x1302df41dca6379e,
1178                fidl::encoding::DynamicFlags::empty(),
1179                ___deadline,
1180            )?;
1181        Ok(_response.map(|x| x))
1182    }
1183}
1184
1185#[cfg(target_os = "fuchsia")]
1186impl From<NetworkRegistrySynchronousProxy> for zx::NullableHandle {
1187    fn from(value: NetworkRegistrySynchronousProxy) -> Self {
1188        value.into_channel().into()
1189    }
1190}
1191
1192#[cfg(target_os = "fuchsia")]
1193impl From<fidl::Channel> for NetworkRegistrySynchronousProxy {
1194    fn from(value: fidl::Channel) -> Self {
1195        Self::new(value)
1196    }
1197}
1198
1199#[cfg(target_os = "fuchsia")]
1200impl fidl::endpoints::FromClient for NetworkRegistrySynchronousProxy {
1201    type Protocol = NetworkRegistryMarker;
1202
1203    fn from_client(value: fidl::endpoints::ClientEnd<NetworkRegistryMarker>) -> Self {
1204        Self::new(value.into_channel())
1205    }
1206}
1207
1208#[derive(Debug, Clone)]
1209pub struct NetworkRegistryProxy {
1210    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1211}
1212
1213impl fidl::endpoints::Proxy for NetworkRegistryProxy {
1214    type Protocol = NetworkRegistryMarker;
1215
1216    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1217        Self::new(inner)
1218    }
1219
1220    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1221        self.client.into_channel().map_err(|client| Self { client })
1222    }
1223
1224    fn as_channel(&self) -> &::fidl::AsyncChannel {
1225        self.client.as_channel()
1226    }
1227}
1228
1229impl NetworkRegistryProxy {
1230    /// Create a new Proxy for fuchsia.net.policy.socketproxy/NetworkRegistry.
1231    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1232        let protocol_name = <NetworkRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1233        Self { client: fidl::client::Client::new(channel, protocol_name) }
1234    }
1235
1236    /// Get a Stream of events from the remote end of the protocol.
1237    ///
1238    /// # Panics
1239    ///
1240    /// Panics if the event stream was already taken.
1241    pub fn take_event_stream(&self) -> NetworkRegistryEventStream {
1242        NetworkRegistryEventStream { event_receiver: self.client.take_event_receiver() }
1243    }
1244
1245    /// Sets the default network.
1246    ///
1247    /// The network must have previously been registered by a call to `Add`.
1248    pub fn r#set_default(
1249        &self,
1250        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
1251    ) -> fidl::client::QueryResponseFut<
1252        NetworkRegistrySetDefaultResult,
1253        fidl::encoding::DefaultFuchsiaResourceDialect,
1254    > {
1255        NetworkRegistryProxyInterface::r#set_default(self, network_id)
1256    }
1257
1258    /// Add a new network.
1259    ///
1260    /// This call will not return until the DNS servers have been successfully
1261    /// updated in netcfg.
1262    pub fn r#add(
1263        &self,
1264        mut network: &Network,
1265    ) -> fidl::client::QueryResponseFut<
1266        NetworkRegistryAddResult,
1267        fidl::encoding::DefaultFuchsiaResourceDialect,
1268    > {
1269        NetworkRegistryProxyInterface::r#add(self, network)
1270    }
1271
1272    /// Update a previously Added network.
1273    ///
1274    /// This call will not return until the DNS servers have been
1275    /// successfully updated in netcfg.
1276    pub fn r#update(
1277        &self,
1278        mut network: &Network,
1279    ) -> fidl::client::QueryResponseFut<
1280        NetworkRegistryUpdateResult,
1281        fidl::encoding::DefaultFuchsiaResourceDialect,
1282    > {
1283        NetworkRegistryProxyInterface::r#update(self, network)
1284    }
1285
1286    /// Remove a previously Added network.
1287    ///
1288    /// This call will not return until the DNS servers have been
1289    /// successfully updated in netcfg.
1290    pub fn r#remove(
1291        &self,
1292        mut network_id: u32,
1293    ) -> fidl::client::QueryResponseFut<
1294        NetworkRegistryRemoveResult,
1295        fidl::encoding::DefaultFuchsiaResourceDialect,
1296    > {
1297        NetworkRegistryProxyInterface::r#remove(self, network_id)
1298    }
1299}
1300
1301impl NetworkRegistryProxyInterface for NetworkRegistryProxy {
1302    type SetDefaultResponseFut = fidl::client::QueryResponseFut<
1303        NetworkRegistrySetDefaultResult,
1304        fidl::encoding::DefaultFuchsiaResourceDialect,
1305    >;
1306    fn r#set_default(
1307        &self,
1308        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
1309    ) -> Self::SetDefaultResponseFut {
1310        fn _decode(
1311            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1312        ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
1313            let _response = fidl::client::decode_transaction_body::<
1314                fidl::encoding::ResultType<
1315                    fidl::encoding::EmptyStruct,
1316                    NetworkRegistrySetDefaultError,
1317                >,
1318                fidl::encoding::DefaultFuchsiaResourceDialect,
1319                0x787930c67b8cf82c,
1320            >(_buf?)?;
1321            Ok(_response.map(|x| x))
1322        }
1323        self.client.send_query_and_decode::<
1324            NetworkRegistrySetDefaultRequest,
1325            NetworkRegistrySetDefaultResult,
1326        >(
1327            (network_id,),
1328            0x787930c67b8cf82c,
1329            fidl::encoding::DynamicFlags::empty(),
1330            _decode,
1331        )
1332    }
1333
1334    type AddResponseFut = fidl::client::QueryResponseFut<
1335        NetworkRegistryAddResult,
1336        fidl::encoding::DefaultFuchsiaResourceDialect,
1337    >;
1338    fn r#add(&self, mut network: &Network) -> Self::AddResponseFut {
1339        fn _decode(
1340            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1341        ) -> Result<NetworkRegistryAddResult, fidl::Error> {
1342            let _response = fidl::client::decode_transaction_body::<
1343                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryAddError>,
1344                fidl::encoding::DefaultFuchsiaResourceDialect,
1345                0x197e70a1cbeab3ad,
1346            >(_buf?)?;
1347            Ok(_response.map(|x| x))
1348        }
1349        self.client.send_query_and_decode::<NetworkRegistryAddRequest, NetworkRegistryAddResult>(
1350            (network,),
1351            0x197e70a1cbeab3ad,
1352            fidl::encoding::DynamicFlags::empty(),
1353            _decode,
1354        )
1355    }
1356
1357    type UpdateResponseFut = fidl::client::QueryResponseFut<
1358        NetworkRegistryUpdateResult,
1359        fidl::encoding::DefaultFuchsiaResourceDialect,
1360    >;
1361    fn r#update(&self, mut network: &Network) -> Self::UpdateResponseFut {
1362        fn _decode(
1363            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1364        ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
1365            let _response = fidl::client::decode_transaction_body::<
1366                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryUpdateError>,
1367                fidl::encoding::DefaultFuchsiaResourceDialect,
1368                0x3bc790ae5418ff0e,
1369            >(_buf?)?;
1370            Ok(_response.map(|x| x))
1371        }
1372        self.client
1373            .send_query_and_decode::<NetworkRegistryUpdateRequest, NetworkRegistryUpdateResult>(
1374                (network,),
1375                0x3bc790ae5418ff0e,
1376                fidl::encoding::DynamicFlags::empty(),
1377                _decode,
1378            )
1379    }
1380
1381    type RemoveResponseFut = fidl::client::QueryResponseFut<
1382        NetworkRegistryRemoveResult,
1383        fidl::encoding::DefaultFuchsiaResourceDialect,
1384    >;
1385    fn r#remove(&self, mut network_id: u32) -> Self::RemoveResponseFut {
1386        fn _decode(
1387            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1388        ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
1389            let _response = fidl::client::decode_transaction_body::<
1390                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryRemoveError>,
1391                fidl::encoding::DefaultFuchsiaResourceDialect,
1392                0x1302df41dca6379e,
1393            >(_buf?)?;
1394            Ok(_response.map(|x| x))
1395        }
1396        self.client
1397            .send_query_and_decode::<NetworkRegistryRemoveRequest, NetworkRegistryRemoveResult>(
1398                (network_id,),
1399                0x1302df41dca6379e,
1400                fidl::encoding::DynamicFlags::empty(),
1401                _decode,
1402            )
1403    }
1404}
1405
1406pub struct NetworkRegistryEventStream {
1407    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1408}
1409
1410impl std::marker::Unpin for NetworkRegistryEventStream {}
1411
1412impl futures::stream::FusedStream for NetworkRegistryEventStream {
1413    fn is_terminated(&self) -> bool {
1414        self.event_receiver.is_terminated()
1415    }
1416}
1417
1418impl futures::Stream for NetworkRegistryEventStream {
1419    type Item = Result<NetworkRegistryEvent, fidl::Error>;
1420
1421    fn poll_next(
1422        mut self: std::pin::Pin<&mut Self>,
1423        cx: &mut std::task::Context<'_>,
1424    ) -> std::task::Poll<Option<Self::Item>> {
1425        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1426            &mut self.event_receiver,
1427            cx
1428        )?) {
1429            Some(buf) => std::task::Poll::Ready(Some(NetworkRegistryEvent::decode(buf))),
1430            None => std::task::Poll::Ready(None),
1431        }
1432    }
1433}
1434
1435#[derive(Debug)]
1436pub enum NetworkRegistryEvent {}
1437
1438impl NetworkRegistryEvent {
1439    /// Decodes a message buffer as a [`NetworkRegistryEvent`].
1440    fn decode(
1441        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1442    ) -> Result<NetworkRegistryEvent, fidl::Error> {
1443        let (bytes, _handles) = buf.split_mut();
1444        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1445        debug_assert_eq!(tx_header.tx_id, 0);
1446        match tx_header.ordinal {
1447            _ => Err(fidl::Error::UnknownOrdinal {
1448                ordinal: tx_header.ordinal,
1449                protocol_name:
1450                    <NetworkRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1451            }),
1452        }
1453    }
1454}
1455
1456/// A Stream of incoming requests for fuchsia.net.policy.socketproxy/NetworkRegistry.
1457pub struct NetworkRegistryRequestStream {
1458    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1459    is_terminated: bool,
1460}
1461
1462impl std::marker::Unpin for NetworkRegistryRequestStream {}
1463
1464impl futures::stream::FusedStream for NetworkRegistryRequestStream {
1465    fn is_terminated(&self) -> bool {
1466        self.is_terminated
1467    }
1468}
1469
1470impl fidl::endpoints::RequestStream for NetworkRegistryRequestStream {
1471    type Protocol = NetworkRegistryMarker;
1472    type ControlHandle = NetworkRegistryControlHandle;
1473
1474    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1475        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1476    }
1477
1478    fn control_handle(&self) -> Self::ControlHandle {
1479        NetworkRegistryControlHandle { inner: self.inner.clone() }
1480    }
1481
1482    fn into_inner(
1483        self,
1484    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1485    {
1486        (self.inner, self.is_terminated)
1487    }
1488
1489    fn from_inner(
1490        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1491        is_terminated: bool,
1492    ) -> Self {
1493        Self { inner, is_terminated }
1494    }
1495}
1496
1497impl futures::Stream for NetworkRegistryRequestStream {
1498    type Item = Result<NetworkRegistryRequest, fidl::Error>;
1499
1500    fn poll_next(
1501        mut self: std::pin::Pin<&mut Self>,
1502        cx: &mut std::task::Context<'_>,
1503    ) -> std::task::Poll<Option<Self::Item>> {
1504        let this = &mut *self;
1505        if this.inner.check_shutdown(cx) {
1506            this.is_terminated = true;
1507            return std::task::Poll::Ready(None);
1508        }
1509        if this.is_terminated {
1510            panic!("polled NetworkRegistryRequestStream after completion");
1511        }
1512        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1513            |bytes, handles| {
1514                match this.inner.channel().read_etc(cx, bytes, handles) {
1515                    std::task::Poll::Ready(Ok(())) => {}
1516                    std::task::Poll::Pending => return std::task::Poll::Pending,
1517                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1518                        this.is_terminated = true;
1519                        return std::task::Poll::Ready(None);
1520                    }
1521                    std::task::Poll::Ready(Err(e)) => {
1522                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1523                            e.into(),
1524                        ))));
1525                    }
1526                }
1527
1528                // A message has been received from the channel
1529                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1530
1531                std::task::Poll::Ready(Some(match header.ordinal {
1532                    0x787930c67b8cf82c => {
1533                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1534                        let mut req = fidl::new_empty!(
1535                            NetworkRegistrySetDefaultRequest,
1536                            fidl::encoding::DefaultFuchsiaResourceDialect
1537                        );
1538                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistrySetDefaultRequest>(&header, _body_bytes, handles, &mut req)?;
1539                        let control_handle =
1540                            NetworkRegistryControlHandle { inner: this.inner.clone() };
1541                        Ok(NetworkRegistryRequest::SetDefault {
1542                            network_id: req.network_id,
1543
1544                            responder: NetworkRegistrySetDefaultResponder {
1545                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1546                                tx_id: header.tx_id,
1547                            },
1548                        })
1549                    }
1550                    0x197e70a1cbeab3ad => {
1551                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1552                        let mut req = fidl::new_empty!(
1553                            NetworkRegistryAddRequest,
1554                            fidl::encoding::DefaultFuchsiaResourceDialect
1555                        );
1556                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryAddRequest>(&header, _body_bytes, handles, &mut req)?;
1557                        let control_handle =
1558                            NetworkRegistryControlHandle { inner: this.inner.clone() };
1559                        Ok(NetworkRegistryRequest::Add {
1560                            network: req.network,
1561
1562                            responder: NetworkRegistryAddResponder {
1563                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1564                                tx_id: header.tx_id,
1565                            },
1566                        })
1567                    }
1568                    0x3bc790ae5418ff0e => {
1569                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1570                        let mut req = fidl::new_empty!(
1571                            NetworkRegistryUpdateRequest,
1572                            fidl::encoding::DefaultFuchsiaResourceDialect
1573                        );
1574                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
1575                        let control_handle =
1576                            NetworkRegistryControlHandle { inner: this.inner.clone() };
1577                        Ok(NetworkRegistryRequest::Update {
1578                            network: req.network,
1579
1580                            responder: NetworkRegistryUpdateResponder {
1581                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1582                                tx_id: header.tx_id,
1583                            },
1584                        })
1585                    }
1586                    0x1302df41dca6379e => {
1587                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1588                        let mut req = fidl::new_empty!(
1589                            NetworkRegistryRemoveRequest,
1590                            fidl::encoding::DefaultFuchsiaResourceDialect
1591                        );
1592                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryRemoveRequest>(&header, _body_bytes, handles, &mut req)?;
1593                        let control_handle =
1594                            NetworkRegistryControlHandle { inner: this.inner.clone() };
1595                        Ok(NetworkRegistryRequest::Remove {
1596                            network_id: req.network_id,
1597
1598                            responder: NetworkRegistryRemoveResponder {
1599                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1600                                tx_id: header.tx_id,
1601                            },
1602                        })
1603                    }
1604                    _ => Err(fidl::Error::UnknownOrdinal {
1605                        ordinal: header.ordinal,
1606                        protocol_name:
1607                            <NetworkRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1608                    }),
1609                }))
1610            },
1611        )
1612    }
1613}
1614
1615#[derive(Debug)]
1616pub enum NetworkRegistryRequest {
1617    /// Sets the default network.
1618    ///
1619    /// The network must have previously been registered by a call to `Add`.
1620    SetDefault {
1621        network_id: fidl_fuchsia_posix_socket::OptionalUint32,
1622        responder: NetworkRegistrySetDefaultResponder,
1623    },
1624    /// Add a new network.
1625    ///
1626    /// This call will not return until the DNS servers have been successfully
1627    /// updated in netcfg.
1628    Add { network: Network, responder: NetworkRegistryAddResponder },
1629    /// Update a previously Added network.
1630    ///
1631    /// This call will not return until the DNS servers have been
1632    /// successfully updated in netcfg.
1633    Update { network: Network, responder: NetworkRegistryUpdateResponder },
1634    /// Remove a previously Added network.
1635    ///
1636    /// This call will not return until the DNS servers have been
1637    /// successfully updated in netcfg.
1638    Remove { network_id: u32, responder: NetworkRegistryRemoveResponder },
1639}
1640
1641impl NetworkRegistryRequest {
1642    #[allow(irrefutable_let_patterns)]
1643    pub fn into_set_default(
1644        self,
1645    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint32, NetworkRegistrySetDefaultResponder)>
1646    {
1647        if let NetworkRegistryRequest::SetDefault { network_id, responder } = self {
1648            Some((network_id, responder))
1649        } else {
1650            None
1651        }
1652    }
1653
1654    #[allow(irrefutable_let_patterns)]
1655    pub fn into_add(self) -> Option<(Network, NetworkRegistryAddResponder)> {
1656        if let NetworkRegistryRequest::Add { network, responder } = self {
1657            Some((network, responder))
1658        } else {
1659            None
1660        }
1661    }
1662
1663    #[allow(irrefutable_let_patterns)]
1664    pub fn into_update(self) -> Option<(Network, NetworkRegistryUpdateResponder)> {
1665        if let NetworkRegistryRequest::Update { network, responder } = self {
1666            Some((network, responder))
1667        } else {
1668            None
1669        }
1670    }
1671
1672    #[allow(irrefutable_let_patterns)]
1673    pub fn into_remove(self) -> Option<(u32, NetworkRegistryRemoveResponder)> {
1674        if let NetworkRegistryRequest::Remove { network_id, responder } = self {
1675            Some((network_id, responder))
1676        } else {
1677            None
1678        }
1679    }
1680
1681    /// Name of the method defined in FIDL
1682    pub fn method_name(&self) -> &'static str {
1683        match *self {
1684            NetworkRegistryRequest::SetDefault { .. } => "set_default",
1685            NetworkRegistryRequest::Add { .. } => "add",
1686            NetworkRegistryRequest::Update { .. } => "update",
1687            NetworkRegistryRequest::Remove { .. } => "remove",
1688        }
1689    }
1690}
1691
1692#[derive(Debug, Clone)]
1693pub struct NetworkRegistryControlHandle {
1694    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1695}
1696
1697impl NetworkRegistryControlHandle {
1698    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
1699        self.inner.shutdown_with_epitaph(status.into())
1700    }
1701}
1702
1703impl fidl::endpoints::ControlHandle for NetworkRegistryControlHandle {
1704    fn shutdown(&self) {
1705        self.inner.shutdown()
1706    }
1707
1708    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
1709        self.inner.shutdown_with_epitaph(status)
1710    }
1711
1712    fn is_closed(&self) -> bool {
1713        self.inner.channel().is_closed()
1714    }
1715    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1716        self.inner.channel().on_closed()
1717    }
1718
1719    #[cfg(target_os = "fuchsia")]
1720    fn signal_peer(
1721        &self,
1722        clear_mask: zx::Signals,
1723        set_mask: zx::Signals,
1724    ) -> Result<(), zx_status::Status> {
1725        use fidl::Peered;
1726        self.inner.channel().signal_peer(clear_mask, set_mask)
1727    }
1728}
1729
1730impl NetworkRegistryControlHandle {}
1731
1732#[must_use = "FIDL methods require a response to be sent"]
1733#[derive(Debug)]
1734pub struct NetworkRegistrySetDefaultResponder {
1735    control_handle: std::mem::ManuallyDrop<NetworkRegistryControlHandle>,
1736    tx_id: u32,
1737}
1738
1739/// Set the the channel to be shutdown (see [`NetworkRegistryControlHandle::shutdown`])
1740/// if the responder is dropped without sending a response, so that the client
1741/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1742impl std::ops::Drop for NetworkRegistrySetDefaultResponder {
1743    fn drop(&mut self) {
1744        self.control_handle.shutdown();
1745        // Safety: drops once, never accessed again
1746        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1747    }
1748}
1749
1750impl fidl::endpoints::Responder for NetworkRegistrySetDefaultResponder {
1751    type ControlHandle = NetworkRegistryControlHandle;
1752
1753    fn control_handle(&self) -> &NetworkRegistryControlHandle {
1754        &self.control_handle
1755    }
1756
1757    fn drop_without_shutdown(mut self) {
1758        // Safety: drops once, never accessed again due to mem::forget
1759        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1760        // Prevent Drop from running (which would shut down the channel)
1761        std::mem::forget(self);
1762    }
1763}
1764
1765impl NetworkRegistrySetDefaultResponder {
1766    /// Sends a response to the FIDL transaction.
1767    ///
1768    /// Sets the channel to shutdown if an error occurs.
1769    pub fn send(
1770        self,
1771        mut result: Result<(), NetworkRegistrySetDefaultError>,
1772    ) -> Result<(), fidl::Error> {
1773        let _result = self.send_raw(result);
1774        if _result.is_err() {
1775            self.control_handle.shutdown();
1776        }
1777        self.drop_without_shutdown();
1778        _result
1779    }
1780
1781    /// Similar to "send" but does not shutdown the channel if an error occurs.
1782    pub fn send_no_shutdown_on_err(
1783        self,
1784        mut result: Result<(), NetworkRegistrySetDefaultError>,
1785    ) -> Result<(), fidl::Error> {
1786        let _result = self.send_raw(result);
1787        self.drop_without_shutdown();
1788        _result
1789    }
1790
1791    fn send_raw(
1792        &self,
1793        mut result: Result<(), NetworkRegistrySetDefaultError>,
1794    ) -> Result<(), fidl::Error> {
1795        self.control_handle.inner.send::<fidl::encoding::ResultType<
1796            fidl::encoding::EmptyStruct,
1797            NetworkRegistrySetDefaultError,
1798        >>(
1799            result,
1800            self.tx_id,
1801            0x787930c67b8cf82c,
1802            fidl::encoding::DynamicFlags::empty(),
1803        )
1804    }
1805}
1806
1807#[must_use = "FIDL methods require a response to be sent"]
1808#[derive(Debug)]
1809pub struct NetworkRegistryAddResponder {
1810    control_handle: std::mem::ManuallyDrop<NetworkRegistryControlHandle>,
1811    tx_id: u32,
1812}
1813
1814/// Set the the channel to be shutdown (see [`NetworkRegistryControlHandle::shutdown`])
1815/// if the responder is dropped without sending a response, so that the client
1816/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1817impl std::ops::Drop for NetworkRegistryAddResponder {
1818    fn drop(&mut self) {
1819        self.control_handle.shutdown();
1820        // Safety: drops once, never accessed again
1821        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1822    }
1823}
1824
1825impl fidl::endpoints::Responder for NetworkRegistryAddResponder {
1826    type ControlHandle = NetworkRegistryControlHandle;
1827
1828    fn control_handle(&self) -> &NetworkRegistryControlHandle {
1829        &self.control_handle
1830    }
1831
1832    fn drop_without_shutdown(mut self) {
1833        // Safety: drops once, never accessed again due to mem::forget
1834        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1835        // Prevent Drop from running (which would shut down the channel)
1836        std::mem::forget(self);
1837    }
1838}
1839
1840impl NetworkRegistryAddResponder {
1841    /// Sends a response to the FIDL transaction.
1842    ///
1843    /// Sets the channel to shutdown if an error occurs.
1844    pub fn send(self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
1845        let _result = self.send_raw(result);
1846        if _result.is_err() {
1847            self.control_handle.shutdown();
1848        }
1849        self.drop_without_shutdown();
1850        _result
1851    }
1852
1853    /// Similar to "send" but does not shutdown the channel if an error occurs.
1854    pub fn send_no_shutdown_on_err(
1855        self,
1856        mut result: Result<(), NetworkRegistryAddError>,
1857    ) -> Result<(), fidl::Error> {
1858        let _result = self.send_raw(result);
1859        self.drop_without_shutdown();
1860        _result
1861    }
1862
1863    fn send_raw(&self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
1864        self.control_handle.inner.send::<fidl::encoding::ResultType<
1865            fidl::encoding::EmptyStruct,
1866            NetworkRegistryAddError,
1867        >>(
1868            result,
1869            self.tx_id,
1870            0x197e70a1cbeab3ad,
1871            fidl::encoding::DynamicFlags::empty(),
1872        )
1873    }
1874}
1875
1876#[must_use = "FIDL methods require a response to be sent"]
1877#[derive(Debug)]
1878pub struct NetworkRegistryUpdateResponder {
1879    control_handle: std::mem::ManuallyDrop<NetworkRegistryControlHandle>,
1880    tx_id: u32,
1881}
1882
1883/// Set the the channel to be shutdown (see [`NetworkRegistryControlHandle::shutdown`])
1884/// if the responder is dropped without sending a response, so that the client
1885/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1886impl std::ops::Drop for NetworkRegistryUpdateResponder {
1887    fn drop(&mut self) {
1888        self.control_handle.shutdown();
1889        // Safety: drops once, never accessed again
1890        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1891    }
1892}
1893
1894impl fidl::endpoints::Responder for NetworkRegistryUpdateResponder {
1895    type ControlHandle = NetworkRegistryControlHandle;
1896
1897    fn control_handle(&self) -> &NetworkRegistryControlHandle {
1898        &self.control_handle
1899    }
1900
1901    fn drop_without_shutdown(mut self) {
1902        // Safety: drops once, never accessed again due to mem::forget
1903        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1904        // Prevent Drop from running (which would shut down the channel)
1905        std::mem::forget(self);
1906    }
1907}
1908
1909impl NetworkRegistryUpdateResponder {
1910    /// Sends a response to the FIDL transaction.
1911    ///
1912    /// Sets the channel to shutdown if an error occurs.
1913    pub fn send(
1914        self,
1915        mut result: Result<(), NetworkRegistryUpdateError>,
1916    ) -> Result<(), fidl::Error> {
1917        let _result = self.send_raw(result);
1918        if _result.is_err() {
1919            self.control_handle.shutdown();
1920        }
1921        self.drop_without_shutdown();
1922        _result
1923    }
1924
1925    /// Similar to "send" but does not shutdown the channel if an error occurs.
1926    pub fn send_no_shutdown_on_err(
1927        self,
1928        mut result: Result<(), NetworkRegistryUpdateError>,
1929    ) -> Result<(), fidl::Error> {
1930        let _result = self.send_raw(result);
1931        self.drop_without_shutdown();
1932        _result
1933    }
1934
1935    fn send_raw(
1936        &self,
1937        mut result: Result<(), NetworkRegistryUpdateError>,
1938    ) -> Result<(), fidl::Error> {
1939        self.control_handle.inner.send::<fidl::encoding::ResultType<
1940            fidl::encoding::EmptyStruct,
1941            NetworkRegistryUpdateError,
1942        >>(
1943            result,
1944            self.tx_id,
1945            0x3bc790ae5418ff0e,
1946            fidl::encoding::DynamicFlags::empty(),
1947        )
1948    }
1949}
1950
1951#[must_use = "FIDL methods require a response to be sent"]
1952#[derive(Debug)]
1953pub struct NetworkRegistryRemoveResponder {
1954    control_handle: std::mem::ManuallyDrop<NetworkRegistryControlHandle>,
1955    tx_id: u32,
1956}
1957
1958/// Set the the channel to be shutdown (see [`NetworkRegistryControlHandle::shutdown`])
1959/// if the responder is dropped without sending a response, so that the client
1960/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1961impl std::ops::Drop for NetworkRegistryRemoveResponder {
1962    fn drop(&mut self) {
1963        self.control_handle.shutdown();
1964        // Safety: drops once, never accessed again
1965        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1966    }
1967}
1968
1969impl fidl::endpoints::Responder for NetworkRegistryRemoveResponder {
1970    type ControlHandle = NetworkRegistryControlHandle;
1971
1972    fn control_handle(&self) -> &NetworkRegistryControlHandle {
1973        &self.control_handle
1974    }
1975
1976    fn drop_without_shutdown(mut self) {
1977        // Safety: drops once, never accessed again due to mem::forget
1978        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1979        // Prevent Drop from running (which would shut down the channel)
1980        std::mem::forget(self);
1981    }
1982}
1983
1984impl NetworkRegistryRemoveResponder {
1985    /// Sends a response to the FIDL transaction.
1986    ///
1987    /// Sets the channel to shutdown if an error occurs.
1988    pub fn send(
1989        self,
1990        mut result: Result<(), NetworkRegistryRemoveError>,
1991    ) -> Result<(), fidl::Error> {
1992        let _result = self.send_raw(result);
1993        if _result.is_err() {
1994            self.control_handle.shutdown();
1995        }
1996        self.drop_without_shutdown();
1997        _result
1998    }
1999
2000    /// Similar to "send" but does not shutdown the channel if an error occurs.
2001    pub fn send_no_shutdown_on_err(
2002        self,
2003        mut result: Result<(), NetworkRegistryRemoveError>,
2004    ) -> Result<(), fidl::Error> {
2005        let _result = self.send_raw(result);
2006        self.drop_without_shutdown();
2007        _result
2008    }
2009
2010    fn send_raw(
2011        &self,
2012        mut result: Result<(), NetworkRegistryRemoveError>,
2013    ) -> Result<(), fidl::Error> {
2014        self.control_handle.inner.send::<fidl::encoding::ResultType<
2015            fidl::encoding::EmptyStruct,
2016            NetworkRegistryRemoveError,
2017        >>(
2018            result,
2019            self.tx_id,
2020            0x1302df41dca6379e,
2021            fidl::encoding::DynamicFlags::empty(),
2022        )
2023    }
2024}
2025
2026#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
2027pub struct StarnixNetworksMarker;
2028
2029impl fidl::endpoints::ProtocolMarker for StarnixNetworksMarker {
2030    type Proxy = StarnixNetworksProxy;
2031    type RequestStream = StarnixNetworksRequestStream;
2032    #[cfg(target_os = "fuchsia")]
2033    type SynchronousProxy = StarnixNetworksSynchronousProxy;
2034
2035    const DEBUG_NAME: &'static str = "fuchsia.net.policy.socketproxy.StarnixNetworks";
2036}
2037impl fidl::endpoints::DiscoverableProtocolMarker for StarnixNetworksMarker {}
2038
2039pub trait StarnixNetworksProxyInterface: Send + Sync {
2040    type SetDefaultResponseFut: std::future::Future<Output = Result<NetworkRegistrySetDefaultResult, fidl::Error>>
2041        + Send;
2042    fn r#set_default(
2043        &self,
2044        network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
2045    ) -> Self::SetDefaultResponseFut;
2046    type AddResponseFut: std::future::Future<Output = Result<NetworkRegistryAddResult, fidl::Error>>
2047        + Send;
2048    fn r#add(&self, network: &Network) -> Self::AddResponseFut;
2049    type UpdateResponseFut: std::future::Future<Output = Result<NetworkRegistryUpdateResult, fidl::Error>>
2050        + Send;
2051    fn r#update(&self, network: &Network) -> Self::UpdateResponseFut;
2052    type RemoveResponseFut: std::future::Future<Output = Result<NetworkRegistryRemoveResult, fidl::Error>>
2053        + Send;
2054    fn r#remove(&self, network_id: u32) -> Self::RemoveResponseFut;
2055}
2056#[derive(Debug)]
2057#[cfg(target_os = "fuchsia")]
2058pub struct StarnixNetworksSynchronousProxy {
2059    client: fidl::client::sync::Client,
2060}
2061
2062#[cfg(target_os = "fuchsia")]
2063impl fidl::endpoints::SynchronousProxy for StarnixNetworksSynchronousProxy {
2064    type Proxy = StarnixNetworksProxy;
2065    type Protocol = StarnixNetworksMarker;
2066
2067    fn from_channel(inner: fidl::Channel) -> Self {
2068        Self::new(inner)
2069    }
2070
2071    fn into_channel(self) -> fidl::Channel {
2072        self.client.into_channel()
2073    }
2074
2075    fn as_channel(&self) -> &fidl::Channel {
2076        self.client.as_channel()
2077    }
2078}
2079
2080#[cfg(target_os = "fuchsia")]
2081impl StarnixNetworksSynchronousProxy {
2082    pub fn new(channel: fidl::Channel) -> Self {
2083        Self { client: fidl::client::sync::Client::new(channel) }
2084    }
2085
2086    pub fn into_channel(self) -> fidl::Channel {
2087        self.client.into_channel()
2088    }
2089
2090    /// Waits until an event arrives and returns it. It is safe for other
2091    /// threads to make concurrent requests while waiting for an event.
2092    pub fn wait_for_event(
2093        &self,
2094        deadline: zx::MonotonicInstant,
2095    ) -> Result<StarnixNetworksEvent, fidl::Error> {
2096        StarnixNetworksEvent::decode(self.client.wait_for_event::<StarnixNetworksMarker>(deadline)?)
2097    }
2098
2099    /// Sets the default network.
2100    ///
2101    /// The network must have previously been registered by a call to `Add`.
2102    pub fn r#set_default(
2103        &self,
2104        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
2105        ___deadline: zx::MonotonicInstant,
2106    ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
2107        let _response =
2108            self.client.send_query::<NetworkRegistrySetDefaultRequest, fidl::encoding::ResultType<
2109                fidl::encoding::EmptyStruct,
2110                NetworkRegistrySetDefaultError,
2111            >, StarnixNetworksMarker>(
2112                (network_id,),
2113                0x787930c67b8cf82c,
2114                fidl::encoding::DynamicFlags::empty(),
2115                ___deadline,
2116            )?;
2117        Ok(_response.map(|x| x))
2118    }
2119
2120    /// Add a new network.
2121    ///
2122    /// This call will not return until the DNS servers have been successfully
2123    /// updated in netcfg.
2124    pub fn r#add(
2125        &self,
2126        mut network: &Network,
2127        ___deadline: zx::MonotonicInstant,
2128    ) -> Result<NetworkRegistryAddResult, fidl::Error> {
2129        let _response =
2130            self.client.send_query::<NetworkRegistryAddRequest, fidl::encoding::ResultType<
2131                fidl::encoding::EmptyStruct,
2132                NetworkRegistryAddError,
2133            >, StarnixNetworksMarker>(
2134                (network,),
2135                0x197e70a1cbeab3ad,
2136                fidl::encoding::DynamicFlags::empty(),
2137                ___deadline,
2138            )?;
2139        Ok(_response.map(|x| x))
2140    }
2141
2142    /// Update a previously Added network.
2143    ///
2144    /// This call will not return until the DNS servers have been
2145    /// successfully updated in netcfg.
2146    pub fn r#update(
2147        &self,
2148        mut network: &Network,
2149        ___deadline: zx::MonotonicInstant,
2150    ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
2151        let _response =
2152            self.client.send_query::<NetworkRegistryUpdateRequest, fidl::encoding::ResultType<
2153                fidl::encoding::EmptyStruct,
2154                NetworkRegistryUpdateError,
2155            >, StarnixNetworksMarker>(
2156                (network,),
2157                0x3bc790ae5418ff0e,
2158                fidl::encoding::DynamicFlags::empty(),
2159                ___deadline,
2160            )?;
2161        Ok(_response.map(|x| x))
2162    }
2163
2164    /// Remove a previously Added network.
2165    ///
2166    /// This call will not return until the DNS servers have been
2167    /// successfully updated in netcfg.
2168    pub fn r#remove(
2169        &self,
2170        mut network_id: u32,
2171        ___deadline: zx::MonotonicInstant,
2172    ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
2173        let _response =
2174            self.client.send_query::<NetworkRegistryRemoveRequest, fidl::encoding::ResultType<
2175                fidl::encoding::EmptyStruct,
2176                NetworkRegistryRemoveError,
2177            >, StarnixNetworksMarker>(
2178                (network_id,),
2179                0x1302df41dca6379e,
2180                fidl::encoding::DynamicFlags::empty(),
2181                ___deadline,
2182            )?;
2183        Ok(_response.map(|x| x))
2184    }
2185}
2186
2187#[cfg(target_os = "fuchsia")]
2188impl From<StarnixNetworksSynchronousProxy> for zx::NullableHandle {
2189    fn from(value: StarnixNetworksSynchronousProxy) -> Self {
2190        value.into_channel().into()
2191    }
2192}
2193
2194#[cfg(target_os = "fuchsia")]
2195impl From<fidl::Channel> for StarnixNetworksSynchronousProxy {
2196    fn from(value: fidl::Channel) -> Self {
2197        Self::new(value)
2198    }
2199}
2200
2201#[cfg(target_os = "fuchsia")]
2202impl fidl::endpoints::FromClient for StarnixNetworksSynchronousProxy {
2203    type Protocol = StarnixNetworksMarker;
2204
2205    fn from_client(value: fidl::endpoints::ClientEnd<StarnixNetworksMarker>) -> Self {
2206        Self::new(value.into_channel())
2207    }
2208}
2209
2210#[derive(Debug, Clone)]
2211pub struct StarnixNetworksProxy {
2212    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
2213}
2214
2215impl fidl::endpoints::Proxy for StarnixNetworksProxy {
2216    type Protocol = StarnixNetworksMarker;
2217
2218    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
2219        Self::new(inner)
2220    }
2221
2222    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
2223        self.client.into_channel().map_err(|client| Self { client })
2224    }
2225
2226    fn as_channel(&self) -> &::fidl::AsyncChannel {
2227        self.client.as_channel()
2228    }
2229}
2230
2231impl StarnixNetworksProxy {
2232    /// Create a new Proxy for fuchsia.net.policy.socketproxy/StarnixNetworks.
2233    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
2234        let protocol_name = <StarnixNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2235        Self { client: fidl::client::Client::new(channel, protocol_name) }
2236    }
2237
2238    /// Get a Stream of events from the remote end of the protocol.
2239    ///
2240    /// # Panics
2241    ///
2242    /// Panics if the event stream was already taken.
2243    pub fn take_event_stream(&self) -> StarnixNetworksEventStream {
2244        StarnixNetworksEventStream { event_receiver: self.client.take_event_receiver() }
2245    }
2246
2247    /// Sets the default network.
2248    ///
2249    /// The network must have previously been registered by a call to `Add`.
2250    pub fn r#set_default(
2251        &self,
2252        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
2253    ) -> fidl::client::QueryResponseFut<
2254        NetworkRegistrySetDefaultResult,
2255        fidl::encoding::DefaultFuchsiaResourceDialect,
2256    > {
2257        StarnixNetworksProxyInterface::r#set_default(self, network_id)
2258    }
2259
2260    /// Add a new network.
2261    ///
2262    /// This call will not return until the DNS servers have been successfully
2263    /// updated in netcfg.
2264    pub fn r#add(
2265        &self,
2266        mut network: &Network,
2267    ) -> fidl::client::QueryResponseFut<
2268        NetworkRegistryAddResult,
2269        fidl::encoding::DefaultFuchsiaResourceDialect,
2270    > {
2271        StarnixNetworksProxyInterface::r#add(self, network)
2272    }
2273
2274    /// Update a previously Added network.
2275    ///
2276    /// This call will not return until the DNS servers have been
2277    /// successfully updated in netcfg.
2278    pub fn r#update(
2279        &self,
2280        mut network: &Network,
2281    ) -> fidl::client::QueryResponseFut<
2282        NetworkRegistryUpdateResult,
2283        fidl::encoding::DefaultFuchsiaResourceDialect,
2284    > {
2285        StarnixNetworksProxyInterface::r#update(self, network)
2286    }
2287
2288    /// Remove a previously Added network.
2289    ///
2290    /// This call will not return until the DNS servers have been
2291    /// successfully updated in netcfg.
2292    pub fn r#remove(
2293        &self,
2294        mut network_id: u32,
2295    ) -> fidl::client::QueryResponseFut<
2296        NetworkRegistryRemoveResult,
2297        fidl::encoding::DefaultFuchsiaResourceDialect,
2298    > {
2299        StarnixNetworksProxyInterface::r#remove(self, network_id)
2300    }
2301}
2302
2303impl StarnixNetworksProxyInterface for StarnixNetworksProxy {
2304    type SetDefaultResponseFut = fidl::client::QueryResponseFut<
2305        NetworkRegistrySetDefaultResult,
2306        fidl::encoding::DefaultFuchsiaResourceDialect,
2307    >;
2308    fn r#set_default(
2309        &self,
2310        mut network_id: &fidl_fuchsia_posix_socket::OptionalUint32,
2311    ) -> Self::SetDefaultResponseFut {
2312        fn _decode(
2313            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2314        ) -> Result<NetworkRegistrySetDefaultResult, fidl::Error> {
2315            let _response = fidl::client::decode_transaction_body::<
2316                fidl::encoding::ResultType<
2317                    fidl::encoding::EmptyStruct,
2318                    NetworkRegistrySetDefaultError,
2319                >,
2320                fidl::encoding::DefaultFuchsiaResourceDialect,
2321                0x787930c67b8cf82c,
2322            >(_buf?)?;
2323            Ok(_response.map(|x| x))
2324        }
2325        self.client.send_query_and_decode::<
2326            NetworkRegistrySetDefaultRequest,
2327            NetworkRegistrySetDefaultResult,
2328        >(
2329            (network_id,),
2330            0x787930c67b8cf82c,
2331            fidl::encoding::DynamicFlags::empty(),
2332            _decode,
2333        )
2334    }
2335
2336    type AddResponseFut = fidl::client::QueryResponseFut<
2337        NetworkRegistryAddResult,
2338        fidl::encoding::DefaultFuchsiaResourceDialect,
2339    >;
2340    fn r#add(&self, mut network: &Network) -> Self::AddResponseFut {
2341        fn _decode(
2342            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2343        ) -> Result<NetworkRegistryAddResult, fidl::Error> {
2344            let _response = fidl::client::decode_transaction_body::<
2345                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryAddError>,
2346                fidl::encoding::DefaultFuchsiaResourceDialect,
2347                0x197e70a1cbeab3ad,
2348            >(_buf?)?;
2349            Ok(_response.map(|x| x))
2350        }
2351        self.client.send_query_and_decode::<NetworkRegistryAddRequest, NetworkRegistryAddResult>(
2352            (network,),
2353            0x197e70a1cbeab3ad,
2354            fidl::encoding::DynamicFlags::empty(),
2355            _decode,
2356        )
2357    }
2358
2359    type UpdateResponseFut = fidl::client::QueryResponseFut<
2360        NetworkRegistryUpdateResult,
2361        fidl::encoding::DefaultFuchsiaResourceDialect,
2362    >;
2363    fn r#update(&self, mut network: &Network) -> Self::UpdateResponseFut {
2364        fn _decode(
2365            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2366        ) -> Result<NetworkRegistryUpdateResult, fidl::Error> {
2367            let _response = fidl::client::decode_transaction_body::<
2368                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryUpdateError>,
2369                fidl::encoding::DefaultFuchsiaResourceDialect,
2370                0x3bc790ae5418ff0e,
2371            >(_buf?)?;
2372            Ok(_response.map(|x| x))
2373        }
2374        self.client
2375            .send_query_and_decode::<NetworkRegistryUpdateRequest, NetworkRegistryUpdateResult>(
2376                (network,),
2377                0x3bc790ae5418ff0e,
2378                fidl::encoding::DynamicFlags::empty(),
2379                _decode,
2380            )
2381    }
2382
2383    type RemoveResponseFut = fidl::client::QueryResponseFut<
2384        NetworkRegistryRemoveResult,
2385        fidl::encoding::DefaultFuchsiaResourceDialect,
2386    >;
2387    fn r#remove(&self, mut network_id: u32) -> Self::RemoveResponseFut {
2388        fn _decode(
2389            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2390        ) -> Result<NetworkRegistryRemoveResult, fidl::Error> {
2391            let _response = fidl::client::decode_transaction_body::<
2392                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkRegistryRemoveError>,
2393                fidl::encoding::DefaultFuchsiaResourceDialect,
2394                0x1302df41dca6379e,
2395            >(_buf?)?;
2396            Ok(_response.map(|x| x))
2397        }
2398        self.client
2399            .send_query_and_decode::<NetworkRegistryRemoveRequest, NetworkRegistryRemoveResult>(
2400                (network_id,),
2401                0x1302df41dca6379e,
2402                fidl::encoding::DynamicFlags::empty(),
2403                _decode,
2404            )
2405    }
2406}
2407
2408pub struct StarnixNetworksEventStream {
2409    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2410}
2411
2412impl std::marker::Unpin for StarnixNetworksEventStream {}
2413
2414impl futures::stream::FusedStream for StarnixNetworksEventStream {
2415    fn is_terminated(&self) -> bool {
2416        self.event_receiver.is_terminated()
2417    }
2418}
2419
2420impl futures::Stream for StarnixNetworksEventStream {
2421    type Item = Result<StarnixNetworksEvent, fidl::Error>;
2422
2423    fn poll_next(
2424        mut self: std::pin::Pin<&mut Self>,
2425        cx: &mut std::task::Context<'_>,
2426    ) -> std::task::Poll<Option<Self::Item>> {
2427        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2428            &mut self.event_receiver,
2429            cx
2430        )?) {
2431            Some(buf) => std::task::Poll::Ready(Some(StarnixNetworksEvent::decode(buf))),
2432            None => std::task::Poll::Ready(None),
2433        }
2434    }
2435}
2436
2437#[derive(Debug)]
2438pub enum StarnixNetworksEvent {}
2439
2440impl StarnixNetworksEvent {
2441    /// Decodes a message buffer as a [`StarnixNetworksEvent`].
2442    fn decode(
2443        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2444    ) -> Result<StarnixNetworksEvent, fidl::Error> {
2445        let (bytes, _handles) = buf.split_mut();
2446        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2447        debug_assert_eq!(tx_header.tx_id, 0);
2448        match tx_header.ordinal {
2449            _ => Err(fidl::Error::UnknownOrdinal {
2450                ordinal: tx_header.ordinal,
2451                protocol_name:
2452                    <StarnixNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2453            }),
2454        }
2455    }
2456}
2457
2458/// A Stream of incoming requests for fuchsia.net.policy.socketproxy/StarnixNetworks.
2459pub struct StarnixNetworksRequestStream {
2460    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2461    is_terminated: bool,
2462}
2463
2464impl std::marker::Unpin for StarnixNetworksRequestStream {}
2465
2466impl futures::stream::FusedStream for StarnixNetworksRequestStream {
2467    fn is_terminated(&self) -> bool {
2468        self.is_terminated
2469    }
2470}
2471
2472impl fidl::endpoints::RequestStream for StarnixNetworksRequestStream {
2473    type Protocol = StarnixNetworksMarker;
2474    type ControlHandle = StarnixNetworksControlHandle;
2475
2476    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2477        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2478    }
2479
2480    fn control_handle(&self) -> Self::ControlHandle {
2481        StarnixNetworksControlHandle { inner: self.inner.clone() }
2482    }
2483
2484    fn into_inner(
2485        self,
2486    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2487    {
2488        (self.inner, self.is_terminated)
2489    }
2490
2491    fn from_inner(
2492        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2493        is_terminated: bool,
2494    ) -> Self {
2495        Self { inner, is_terminated }
2496    }
2497}
2498
2499impl futures::Stream for StarnixNetworksRequestStream {
2500    type Item = Result<StarnixNetworksRequest, fidl::Error>;
2501
2502    fn poll_next(
2503        mut self: std::pin::Pin<&mut Self>,
2504        cx: &mut std::task::Context<'_>,
2505    ) -> std::task::Poll<Option<Self::Item>> {
2506        let this = &mut *self;
2507        if this.inner.check_shutdown(cx) {
2508            this.is_terminated = true;
2509            return std::task::Poll::Ready(None);
2510        }
2511        if this.is_terminated {
2512            panic!("polled StarnixNetworksRequestStream after completion");
2513        }
2514        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2515            |bytes, handles| {
2516                match this.inner.channel().read_etc(cx, bytes, handles) {
2517                    std::task::Poll::Ready(Ok(())) => {}
2518                    std::task::Poll::Pending => return std::task::Poll::Pending,
2519                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2520                        this.is_terminated = true;
2521                        return std::task::Poll::Ready(None);
2522                    }
2523                    std::task::Poll::Ready(Err(e)) => {
2524                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2525                            e.into(),
2526                        ))));
2527                    }
2528                }
2529
2530                // A message has been received from the channel
2531                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2532
2533                std::task::Poll::Ready(Some(match header.ordinal {
2534                    0x787930c67b8cf82c => {
2535                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2536                        let mut req = fidl::new_empty!(
2537                            NetworkRegistrySetDefaultRequest,
2538                            fidl::encoding::DefaultFuchsiaResourceDialect
2539                        );
2540                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistrySetDefaultRequest>(&header, _body_bytes, handles, &mut req)?;
2541                        let control_handle =
2542                            StarnixNetworksControlHandle { inner: this.inner.clone() };
2543                        Ok(StarnixNetworksRequest::SetDefault {
2544                            network_id: req.network_id,
2545
2546                            responder: StarnixNetworksSetDefaultResponder {
2547                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2548                                tx_id: header.tx_id,
2549                            },
2550                        })
2551                    }
2552                    0x197e70a1cbeab3ad => {
2553                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2554                        let mut req = fidl::new_empty!(
2555                            NetworkRegistryAddRequest,
2556                            fidl::encoding::DefaultFuchsiaResourceDialect
2557                        );
2558                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryAddRequest>(&header, _body_bytes, handles, &mut req)?;
2559                        let control_handle =
2560                            StarnixNetworksControlHandle { inner: this.inner.clone() };
2561                        Ok(StarnixNetworksRequest::Add {
2562                            network: req.network,
2563
2564                            responder: StarnixNetworksAddResponder {
2565                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2566                                tx_id: header.tx_id,
2567                            },
2568                        })
2569                    }
2570                    0x3bc790ae5418ff0e => {
2571                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2572                        let mut req = fidl::new_empty!(
2573                            NetworkRegistryUpdateRequest,
2574                            fidl::encoding::DefaultFuchsiaResourceDialect
2575                        );
2576                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
2577                        let control_handle =
2578                            StarnixNetworksControlHandle { inner: this.inner.clone() };
2579                        Ok(StarnixNetworksRequest::Update {
2580                            network: req.network,
2581
2582                            responder: StarnixNetworksUpdateResponder {
2583                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2584                                tx_id: header.tx_id,
2585                            },
2586                        })
2587                    }
2588                    0x1302df41dca6379e => {
2589                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2590                        let mut req = fidl::new_empty!(
2591                            NetworkRegistryRemoveRequest,
2592                            fidl::encoding::DefaultFuchsiaResourceDialect
2593                        );
2594                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRegistryRemoveRequest>(&header, _body_bytes, handles, &mut req)?;
2595                        let control_handle =
2596                            StarnixNetworksControlHandle { inner: this.inner.clone() };
2597                        Ok(StarnixNetworksRequest::Remove {
2598                            network_id: req.network_id,
2599
2600                            responder: StarnixNetworksRemoveResponder {
2601                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2602                                tx_id: header.tx_id,
2603                            },
2604                        })
2605                    }
2606                    _ => Err(fidl::Error::UnknownOrdinal {
2607                        ordinal: header.ordinal,
2608                        protocol_name:
2609                            <StarnixNetworksMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2610                    }),
2611                }))
2612            },
2613        )
2614    }
2615}
2616
2617/// StarnixNetworks is used for the starnix nmfs service to communicate changes
2618/// to the network. Only one connection to this service is considered valid at
2619/// any one time. If the connection is lost for any reason, all previously
2620/// registered networks are considered invalid and will be removed.
2621#[derive(Debug)]
2622pub enum StarnixNetworksRequest {
2623    /// Sets the default network.
2624    ///
2625    /// The network must have previously been registered by a call to `Add`.
2626    SetDefault {
2627        network_id: fidl_fuchsia_posix_socket::OptionalUint32,
2628        responder: StarnixNetworksSetDefaultResponder,
2629    },
2630    /// Add a new network.
2631    ///
2632    /// This call will not return until the DNS servers have been successfully
2633    /// updated in netcfg.
2634    Add { network: Network, responder: StarnixNetworksAddResponder },
2635    /// Update a previously Added network.
2636    ///
2637    /// This call will not return until the DNS servers have been
2638    /// successfully updated in netcfg.
2639    Update { network: Network, responder: StarnixNetworksUpdateResponder },
2640    /// Remove a previously Added network.
2641    ///
2642    /// This call will not return until the DNS servers have been
2643    /// successfully updated in netcfg.
2644    Remove { network_id: u32, responder: StarnixNetworksRemoveResponder },
2645}
2646
2647impl StarnixNetworksRequest {
2648    #[allow(irrefutable_let_patterns)]
2649    pub fn into_set_default(
2650        self,
2651    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint32, StarnixNetworksSetDefaultResponder)>
2652    {
2653        if let StarnixNetworksRequest::SetDefault { network_id, responder } = self {
2654            Some((network_id, responder))
2655        } else {
2656            None
2657        }
2658    }
2659
2660    #[allow(irrefutable_let_patterns)]
2661    pub fn into_add(self) -> Option<(Network, StarnixNetworksAddResponder)> {
2662        if let StarnixNetworksRequest::Add { network, responder } = self {
2663            Some((network, responder))
2664        } else {
2665            None
2666        }
2667    }
2668
2669    #[allow(irrefutable_let_patterns)]
2670    pub fn into_update(self) -> Option<(Network, StarnixNetworksUpdateResponder)> {
2671        if let StarnixNetworksRequest::Update { network, responder } = self {
2672            Some((network, responder))
2673        } else {
2674            None
2675        }
2676    }
2677
2678    #[allow(irrefutable_let_patterns)]
2679    pub fn into_remove(self) -> Option<(u32, StarnixNetworksRemoveResponder)> {
2680        if let StarnixNetworksRequest::Remove { network_id, responder } = self {
2681            Some((network_id, responder))
2682        } else {
2683            None
2684        }
2685    }
2686
2687    /// Name of the method defined in FIDL
2688    pub fn method_name(&self) -> &'static str {
2689        match *self {
2690            StarnixNetworksRequest::SetDefault { .. } => "set_default",
2691            StarnixNetworksRequest::Add { .. } => "add",
2692            StarnixNetworksRequest::Update { .. } => "update",
2693            StarnixNetworksRequest::Remove { .. } => "remove",
2694        }
2695    }
2696}
2697
2698#[derive(Debug, Clone)]
2699pub struct StarnixNetworksControlHandle {
2700    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2701}
2702
2703impl StarnixNetworksControlHandle {
2704    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
2705        self.inner.shutdown_with_epitaph(status.into())
2706    }
2707}
2708
2709impl fidl::endpoints::ControlHandle for StarnixNetworksControlHandle {
2710    fn shutdown(&self) {
2711        self.inner.shutdown()
2712    }
2713
2714    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
2715        self.inner.shutdown_with_epitaph(status)
2716    }
2717
2718    fn is_closed(&self) -> bool {
2719        self.inner.channel().is_closed()
2720    }
2721    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2722        self.inner.channel().on_closed()
2723    }
2724
2725    #[cfg(target_os = "fuchsia")]
2726    fn signal_peer(
2727        &self,
2728        clear_mask: zx::Signals,
2729        set_mask: zx::Signals,
2730    ) -> Result<(), zx_status::Status> {
2731        use fidl::Peered;
2732        self.inner.channel().signal_peer(clear_mask, set_mask)
2733    }
2734}
2735
2736impl StarnixNetworksControlHandle {}
2737
2738#[must_use = "FIDL methods require a response to be sent"]
2739#[derive(Debug)]
2740pub struct StarnixNetworksSetDefaultResponder {
2741    control_handle: std::mem::ManuallyDrop<StarnixNetworksControlHandle>,
2742    tx_id: u32,
2743}
2744
2745/// Set the the channel to be shutdown (see [`StarnixNetworksControlHandle::shutdown`])
2746/// if the responder is dropped without sending a response, so that the client
2747/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2748impl std::ops::Drop for StarnixNetworksSetDefaultResponder {
2749    fn drop(&mut self) {
2750        self.control_handle.shutdown();
2751        // Safety: drops once, never accessed again
2752        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2753    }
2754}
2755
2756impl fidl::endpoints::Responder for StarnixNetworksSetDefaultResponder {
2757    type ControlHandle = StarnixNetworksControlHandle;
2758
2759    fn control_handle(&self) -> &StarnixNetworksControlHandle {
2760        &self.control_handle
2761    }
2762
2763    fn drop_without_shutdown(mut self) {
2764        // Safety: drops once, never accessed again due to mem::forget
2765        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2766        // Prevent Drop from running (which would shut down the channel)
2767        std::mem::forget(self);
2768    }
2769}
2770
2771impl StarnixNetworksSetDefaultResponder {
2772    /// Sends a response to the FIDL transaction.
2773    ///
2774    /// Sets the channel to shutdown if an error occurs.
2775    pub fn send(
2776        self,
2777        mut result: Result<(), NetworkRegistrySetDefaultError>,
2778    ) -> Result<(), fidl::Error> {
2779        let _result = self.send_raw(result);
2780        if _result.is_err() {
2781            self.control_handle.shutdown();
2782        }
2783        self.drop_without_shutdown();
2784        _result
2785    }
2786
2787    /// Similar to "send" but does not shutdown the channel if an error occurs.
2788    pub fn send_no_shutdown_on_err(
2789        self,
2790        mut result: Result<(), NetworkRegistrySetDefaultError>,
2791    ) -> Result<(), fidl::Error> {
2792        let _result = self.send_raw(result);
2793        self.drop_without_shutdown();
2794        _result
2795    }
2796
2797    fn send_raw(
2798        &self,
2799        mut result: Result<(), NetworkRegistrySetDefaultError>,
2800    ) -> Result<(), fidl::Error> {
2801        self.control_handle.inner.send::<fidl::encoding::ResultType<
2802            fidl::encoding::EmptyStruct,
2803            NetworkRegistrySetDefaultError,
2804        >>(
2805            result,
2806            self.tx_id,
2807            0x787930c67b8cf82c,
2808            fidl::encoding::DynamicFlags::empty(),
2809        )
2810    }
2811}
2812
2813#[must_use = "FIDL methods require a response to be sent"]
2814#[derive(Debug)]
2815pub struct StarnixNetworksAddResponder {
2816    control_handle: std::mem::ManuallyDrop<StarnixNetworksControlHandle>,
2817    tx_id: u32,
2818}
2819
2820/// Set the the channel to be shutdown (see [`StarnixNetworksControlHandle::shutdown`])
2821/// if the responder is dropped without sending a response, so that the client
2822/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2823impl std::ops::Drop for StarnixNetworksAddResponder {
2824    fn drop(&mut self) {
2825        self.control_handle.shutdown();
2826        // Safety: drops once, never accessed again
2827        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2828    }
2829}
2830
2831impl fidl::endpoints::Responder for StarnixNetworksAddResponder {
2832    type ControlHandle = StarnixNetworksControlHandle;
2833
2834    fn control_handle(&self) -> &StarnixNetworksControlHandle {
2835        &self.control_handle
2836    }
2837
2838    fn drop_without_shutdown(mut self) {
2839        // Safety: drops once, never accessed again due to mem::forget
2840        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2841        // Prevent Drop from running (which would shut down the channel)
2842        std::mem::forget(self);
2843    }
2844}
2845
2846impl StarnixNetworksAddResponder {
2847    /// Sends a response to the FIDL transaction.
2848    ///
2849    /// Sets the channel to shutdown if an error occurs.
2850    pub fn send(self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
2851        let _result = self.send_raw(result);
2852        if _result.is_err() {
2853            self.control_handle.shutdown();
2854        }
2855        self.drop_without_shutdown();
2856        _result
2857    }
2858
2859    /// Similar to "send" but does not shutdown the channel if an error occurs.
2860    pub fn send_no_shutdown_on_err(
2861        self,
2862        mut result: Result<(), NetworkRegistryAddError>,
2863    ) -> Result<(), fidl::Error> {
2864        let _result = self.send_raw(result);
2865        self.drop_without_shutdown();
2866        _result
2867    }
2868
2869    fn send_raw(&self, mut result: Result<(), NetworkRegistryAddError>) -> Result<(), fidl::Error> {
2870        self.control_handle.inner.send::<fidl::encoding::ResultType<
2871            fidl::encoding::EmptyStruct,
2872            NetworkRegistryAddError,
2873        >>(
2874            result,
2875            self.tx_id,
2876            0x197e70a1cbeab3ad,
2877            fidl::encoding::DynamicFlags::empty(),
2878        )
2879    }
2880}
2881
2882#[must_use = "FIDL methods require a response to be sent"]
2883#[derive(Debug)]
2884pub struct StarnixNetworksUpdateResponder {
2885    control_handle: std::mem::ManuallyDrop<StarnixNetworksControlHandle>,
2886    tx_id: u32,
2887}
2888
2889/// Set the the channel to be shutdown (see [`StarnixNetworksControlHandle::shutdown`])
2890/// if the responder is dropped without sending a response, so that the client
2891/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2892impl std::ops::Drop for StarnixNetworksUpdateResponder {
2893    fn drop(&mut self) {
2894        self.control_handle.shutdown();
2895        // Safety: drops once, never accessed again
2896        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2897    }
2898}
2899
2900impl fidl::endpoints::Responder for StarnixNetworksUpdateResponder {
2901    type ControlHandle = StarnixNetworksControlHandle;
2902
2903    fn control_handle(&self) -> &StarnixNetworksControlHandle {
2904        &self.control_handle
2905    }
2906
2907    fn drop_without_shutdown(mut self) {
2908        // Safety: drops once, never accessed again due to mem::forget
2909        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2910        // Prevent Drop from running (which would shut down the channel)
2911        std::mem::forget(self);
2912    }
2913}
2914
2915impl StarnixNetworksUpdateResponder {
2916    /// Sends a response to the FIDL transaction.
2917    ///
2918    /// Sets the channel to shutdown if an error occurs.
2919    pub fn send(
2920        self,
2921        mut result: Result<(), NetworkRegistryUpdateError>,
2922    ) -> Result<(), fidl::Error> {
2923        let _result = self.send_raw(result);
2924        if _result.is_err() {
2925            self.control_handle.shutdown();
2926        }
2927        self.drop_without_shutdown();
2928        _result
2929    }
2930
2931    /// Similar to "send" but does not shutdown the channel if an error occurs.
2932    pub fn send_no_shutdown_on_err(
2933        self,
2934        mut result: Result<(), NetworkRegistryUpdateError>,
2935    ) -> Result<(), fidl::Error> {
2936        let _result = self.send_raw(result);
2937        self.drop_without_shutdown();
2938        _result
2939    }
2940
2941    fn send_raw(
2942        &self,
2943        mut result: Result<(), NetworkRegistryUpdateError>,
2944    ) -> Result<(), fidl::Error> {
2945        self.control_handle.inner.send::<fidl::encoding::ResultType<
2946            fidl::encoding::EmptyStruct,
2947            NetworkRegistryUpdateError,
2948        >>(
2949            result,
2950            self.tx_id,
2951            0x3bc790ae5418ff0e,
2952            fidl::encoding::DynamicFlags::empty(),
2953        )
2954    }
2955}
2956
2957#[must_use = "FIDL methods require a response to be sent"]
2958#[derive(Debug)]
2959pub struct StarnixNetworksRemoveResponder {
2960    control_handle: std::mem::ManuallyDrop<StarnixNetworksControlHandle>,
2961    tx_id: u32,
2962}
2963
2964/// Set the the channel to be shutdown (see [`StarnixNetworksControlHandle::shutdown`])
2965/// if the responder is dropped without sending a response, so that the client
2966/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2967impl std::ops::Drop for StarnixNetworksRemoveResponder {
2968    fn drop(&mut self) {
2969        self.control_handle.shutdown();
2970        // Safety: drops once, never accessed again
2971        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2972    }
2973}
2974
2975impl fidl::endpoints::Responder for StarnixNetworksRemoveResponder {
2976    type ControlHandle = StarnixNetworksControlHandle;
2977
2978    fn control_handle(&self) -> &StarnixNetworksControlHandle {
2979        &self.control_handle
2980    }
2981
2982    fn drop_without_shutdown(mut self) {
2983        // Safety: drops once, never accessed again due to mem::forget
2984        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2985        // Prevent Drop from running (which would shut down the channel)
2986        std::mem::forget(self);
2987    }
2988}
2989
2990impl StarnixNetworksRemoveResponder {
2991    /// Sends a response to the FIDL transaction.
2992    ///
2993    /// Sets the channel to shutdown if an error occurs.
2994    pub fn send(
2995        self,
2996        mut result: Result<(), NetworkRegistryRemoveError>,
2997    ) -> Result<(), fidl::Error> {
2998        let _result = self.send_raw(result);
2999        if _result.is_err() {
3000            self.control_handle.shutdown();
3001        }
3002        self.drop_without_shutdown();
3003        _result
3004    }
3005
3006    /// Similar to "send" but does not shutdown the channel if an error occurs.
3007    pub fn send_no_shutdown_on_err(
3008        self,
3009        mut result: Result<(), NetworkRegistryRemoveError>,
3010    ) -> Result<(), fidl::Error> {
3011        let _result = self.send_raw(result);
3012        self.drop_without_shutdown();
3013        _result
3014    }
3015
3016    fn send_raw(
3017        &self,
3018        mut result: Result<(), NetworkRegistryRemoveError>,
3019    ) -> Result<(), fidl::Error> {
3020        self.control_handle.inner.send::<fidl::encoding::ResultType<
3021            fidl::encoding::EmptyStruct,
3022            NetworkRegistryRemoveError,
3023        >>(
3024            result,
3025            self.tx_id,
3026            0x1302df41dca6379e,
3027            fidl::encoding::DynamicFlags::empty(),
3028        )
3029    }
3030}
3031
3032mod internal {
3033    use super::*;
3034}
fidl_fuchsia_net_policy_socketproxy/fidl_fuchsia_net_policy_socketproxy.rs

fidl_fuchsia_net_policy_socketproxy/
fidl_fuchsia_net_policy_socketproxy.rs
