fidl_fuchsia_netemul_network/
fidl_fuchsia_netemul_network.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_netemul_network__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct DeviceProxyServeControllerRequest {
16    pub req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for DeviceProxyServeControllerRequest
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct DeviceProxyServeDeviceRequest {
26    pub req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
30    for DeviceProxyServeDeviceRequest
31{
32}
33
34#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
35pub struct EndpointGetPortRequest {
36    pub port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
37}
38
39impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EndpointGetPortRequest {}
40
41#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
42pub struct EndpointGetProxyRequest {
43    pub proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
44}
45
46impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EndpointGetProxyRequest {}
47
48#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
49pub struct EndpointManagerCreateEndpointResponse {
50    pub status: i32,
51    pub endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
52}
53
54impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
55    for EndpointManagerCreateEndpointResponse
56{
57}
58
59#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
60pub struct EndpointManagerGetEndpointResponse {
61    pub endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
62}
63
64impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
65    for EndpointManagerGetEndpointResponse
66{
67}
68
69#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70pub struct NetworkContextCloneRequest {
71    pub network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
72}
73
74impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
75    for NetworkContextCloneRequest
76{
77}
78
79#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
80pub struct NetworkContextGetEndpointManagerRequest {
81    pub endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
82}
83
84impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
85    for NetworkContextGetEndpointManagerRequest
86{
87}
88
89#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
90pub struct NetworkContextGetNetworkManagerRequest {
91    pub net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
92}
93
94impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
95    for NetworkContextGetNetworkManagerRequest
96{
97}
98
99#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
100pub struct NetworkContextSetupResponse {
101    pub status: i32,
102    pub setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
103}
104
105impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
106    for NetworkContextSetupResponse
107{
108}
109
110#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
111pub struct NetworkCreateFakeEndpointRequest {
112    pub ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
113}
114
115impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
116    for NetworkCreateFakeEndpointRequest
117{
118}
119
120#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
121pub struct NetworkManagerCreateNetworkResponse {
122    pub status: i32,
123    pub net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
124}
125
126impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
127    for NetworkManagerCreateNetworkResponse
128{
129}
130
131#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
132pub struct NetworkManagerGetNetworkResponse {
133    pub net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
134}
135
136impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
137    for NetworkManagerGetNetworkResponse
138{
139}
140
141#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
142pub struct DeviceProxy_Marker;
143
144impl fidl::endpoints::ProtocolMarker for DeviceProxy_Marker {
145    type Proxy = DeviceProxy_Proxy;
146    type RequestStream = DeviceProxy_RequestStream;
147    #[cfg(target_os = "fuchsia")]
148    type SynchronousProxy = DeviceProxy_SynchronousProxy;
149
150    const DEBUG_NAME: &'static str = "(anonymous) DeviceProxy_";
151}
152
153pub trait DeviceProxy_ProxyInterface: Send + Sync {
154    fn r#serve_controller(
155        &self,
156        req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
157    ) -> Result<(), fidl::Error>;
158    fn r#serve_device(
159        &self,
160        req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
161    ) -> Result<(), fidl::Error>;
162}
163#[derive(Debug)]
164#[cfg(target_os = "fuchsia")]
165pub struct DeviceProxy_SynchronousProxy {
166    client: fidl::client::sync::Client,
167}
168
169#[cfg(target_os = "fuchsia")]
170impl fidl::endpoints::SynchronousProxy for DeviceProxy_SynchronousProxy {
171    type Proxy = DeviceProxy_Proxy;
172    type Protocol = DeviceProxy_Marker;
173
174    fn from_channel(inner: fidl::Channel) -> Self {
175        Self::new(inner)
176    }
177
178    fn into_channel(self) -> fidl::Channel {
179        self.client.into_channel()
180    }
181
182    fn as_channel(&self) -> &fidl::Channel {
183        self.client.as_channel()
184    }
185}
186
187#[cfg(target_os = "fuchsia")]
188impl DeviceProxy_SynchronousProxy {
189    pub fn new(channel: fidl::Channel) -> Self {
190        let protocol_name = <DeviceProxy_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
191        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
192    }
193
194    pub fn into_channel(self) -> fidl::Channel {
195        self.client.into_channel()
196    }
197
198    /// Waits until an event arrives and returns it. It is safe for other
199    /// threads to make concurrent requests while waiting for an event.
200    pub fn wait_for_event(
201        &self,
202        deadline: zx::MonotonicInstant,
203    ) -> Result<DeviceProxy_Event, fidl::Error> {
204        DeviceProxy_Event::decode(self.client.wait_for_event(deadline)?)
205    }
206
207    /// Serve the Controller protocol for this device.
208    pub fn r#serve_controller(
209        &self,
210        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
211    ) -> Result<(), fidl::Error> {
212        self.client.send::<DeviceProxyServeControllerRequest>(
213            (req,),
214            0x326c17ad2d3879ee,
215            fidl::encoding::DynamicFlags::empty(),
216        )
217    }
218
219    /// Serve the device's FIDL protocol.
220    pub fn r#serve_device(
221        &self,
222        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
223    ) -> Result<(), fidl::Error> {
224        self.client.send::<DeviceProxyServeDeviceRequest>(
225            (req,),
226            0x645dae2573613288,
227            fidl::encoding::DynamicFlags::empty(),
228        )
229    }
230}
231
232#[cfg(target_os = "fuchsia")]
233impl From<DeviceProxy_SynchronousProxy> for zx::Handle {
234    fn from(value: DeviceProxy_SynchronousProxy) -> Self {
235        value.into_channel().into()
236    }
237}
238
239#[cfg(target_os = "fuchsia")]
240impl From<fidl::Channel> for DeviceProxy_SynchronousProxy {
241    fn from(value: fidl::Channel) -> Self {
242        Self::new(value)
243    }
244}
245
246#[cfg(target_os = "fuchsia")]
247impl fidl::endpoints::FromClient for DeviceProxy_SynchronousProxy {
248    type Protocol = DeviceProxy_Marker;
249
250    fn from_client(value: fidl::endpoints::ClientEnd<DeviceProxy_Marker>) -> Self {
251        Self::new(value.into_channel())
252    }
253}
254
255#[derive(Debug, Clone)]
256pub struct DeviceProxy_Proxy {
257    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
258}
259
260impl fidl::endpoints::Proxy for DeviceProxy_Proxy {
261    type Protocol = DeviceProxy_Marker;
262
263    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
264        Self::new(inner)
265    }
266
267    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
268        self.client.into_channel().map_err(|client| Self { client })
269    }
270
271    fn as_channel(&self) -> &::fidl::AsyncChannel {
272        self.client.as_channel()
273    }
274}
275
276impl DeviceProxy_Proxy {
277    /// Create a new Proxy for fuchsia.netemul.network/DeviceProxy.
278    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
279        let protocol_name = <DeviceProxy_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
280        Self { client: fidl::client::Client::new(channel, protocol_name) }
281    }
282
283    /// Get a Stream of events from the remote end of the protocol.
284    ///
285    /// # Panics
286    ///
287    /// Panics if the event stream was already taken.
288    pub fn take_event_stream(&self) -> DeviceProxy_EventStream {
289        DeviceProxy_EventStream { event_receiver: self.client.take_event_receiver() }
290    }
291
292    /// Serve the Controller protocol for this device.
293    pub fn r#serve_controller(
294        &self,
295        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
296    ) -> Result<(), fidl::Error> {
297        DeviceProxy_ProxyInterface::r#serve_controller(self, req)
298    }
299
300    /// Serve the device's FIDL protocol.
301    pub fn r#serve_device(
302        &self,
303        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
304    ) -> Result<(), fidl::Error> {
305        DeviceProxy_ProxyInterface::r#serve_device(self, req)
306    }
307}
308
309impl DeviceProxy_ProxyInterface for DeviceProxy_Proxy {
310    fn r#serve_controller(
311        &self,
312        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
313    ) -> Result<(), fidl::Error> {
314        self.client.send::<DeviceProxyServeControllerRequest>(
315            (req,),
316            0x326c17ad2d3879ee,
317            fidl::encoding::DynamicFlags::empty(),
318        )
319    }
320
321    fn r#serve_device(
322        &self,
323        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
324    ) -> Result<(), fidl::Error> {
325        self.client.send::<DeviceProxyServeDeviceRequest>(
326            (req,),
327            0x645dae2573613288,
328            fidl::encoding::DynamicFlags::empty(),
329        )
330    }
331}
332
333pub struct DeviceProxy_EventStream {
334    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
335}
336
337impl std::marker::Unpin for DeviceProxy_EventStream {}
338
339impl futures::stream::FusedStream for DeviceProxy_EventStream {
340    fn is_terminated(&self) -> bool {
341        self.event_receiver.is_terminated()
342    }
343}
344
345impl futures::Stream for DeviceProxy_EventStream {
346    type Item = Result<DeviceProxy_Event, fidl::Error>;
347
348    fn poll_next(
349        mut self: std::pin::Pin<&mut Self>,
350        cx: &mut std::task::Context<'_>,
351    ) -> std::task::Poll<Option<Self::Item>> {
352        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
353            &mut self.event_receiver,
354            cx
355        )?) {
356            Some(buf) => std::task::Poll::Ready(Some(DeviceProxy_Event::decode(buf))),
357            None => std::task::Poll::Ready(None),
358        }
359    }
360}
361
362#[derive(Debug)]
363pub enum DeviceProxy_Event {}
364
365impl DeviceProxy_Event {
366    /// Decodes a message buffer as a [`DeviceProxy_Event`].
367    fn decode(
368        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
369    ) -> Result<DeviceProxy_Event, fidl::Error> {
370        let (bytes, _handles) = buf.split_mut();
371        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
372        debug_assert_eq!(tx_header.tx_id, 0);
373        match tx_header.ordinal {
374            _ => Err(fidl::Error::UnknownOrdinal {
375                ordinal: tx_header.ordinal,
376                protocol_name: <DeviceProxy_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
377            }),
378        }
379    }
380}
381
382/// A Stream of incoming requests for fuchsia.netemul.network/DeviceProxy.
383pub struct DeviceProxy_RequestStream {
384    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
385    is_terminated: bool,
386}
387
388impl std::marker::Unpin for DeviceProxy_RequestStream {}
389
390impl futures::stream::FusedStream for DeviceProxy_RequestStream {
391    fn is_terminated(&self) -> bool {
392        self.is_terminated
393    }
394}
395
396impl fidl::endpoints::RequestStream for DeviceProxy_RequestStream {
397    type Protocol = DeviceProxy_Marker;
398    type ControlHandle = DeviceProxy_ControlHandle;
399
400    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
401        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
402    }
403
404    fn control_handle(&self) -> Self::ControlHandle {
405        DeviceProxy_ControlHandle { inner: self.inner.clone() }
406    }
407
408    fn into_inner(
409        self,
410    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
411    {
412        (self.inner, self.is_terminated)
413    }
414
415    fn from_inner(
416        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
417        is_terminated: bool,
418    ) -> Self {
419        Self { inner, is_terminated }
420    }
421}
422
423impl futures::Stream for DeviceProxy_RequestStream {
424    type Item = Result<DeviceProxy_Request, fidl::Error>;
425
426    fn poll_next(
427        mut self: std::pin::Pin<&mut Self>,
428        cx: &mut std::task::Context<'_>,
429    ) -> std::task::Poll<Option<Self::Item>> {
430        let this = &mut *self;
431        if this.inner.check_shutdown(cx) {
432            this.is_terminated = true;
433            return std::task::Poll::Ready(None);
434        }
435        if this.is_terminated {
436            panic!("polled DeviceProxy_RequestStream after completion");
437        }
438        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
439            |bytes, handles| {
440                match this.inner.channel().read_etc(cx, bytes, handles) {
441                    std::task::Poll::Ready(Ok(())) => {}
442                    std::task::Poll::Pending => return std::task::Poll::Pending,
443                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
444                        this.is_terminated = true;
445                        return std::task::Poll::Ready(None);
446                    }
447                    std::task::Poll::Ready(Err(e)) => {
448                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
449                            e.into(),
450                        ))))
451                    }
452                }
453
454                // A message has been received from the channel
455                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
456
457                std::task::Poll::Ready(Some(match header.ordinal {
458                    0x326c17ad2d3879ee => {
459                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
460                        let mut req = fidl::new_empty!(
461                            DeviceProxyServeControllerRequest,
462                            fidl::encoding::DefaultFuchsiaResourceDialect
463                        );
464                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceProxyServeControllerRequest>(&header, _body_bytes, handles, &mut req)?;
465                        let control_handle =
466                            DeviceProxy_ControlHandle { inner: this.inner.clone() };
467                        Ok(DeviceProxy_Request::ServeController { req: req.req, control_handle })
468                    }
469                    0x645dae2573613288 => {
470                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
471                        let mut req = fidl::new_empty!(
472                            DeviceProxyServeDeviceRequest,
473                            fidl::encoding::DefaultFuchsiaResourceDialect
474                        );
475                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceProxyServeDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
476                        let control_handle =
477                            DeviceProxy_ControlHandle { inner: this.inner.clone() };
478                        Ok(DeviceProxy_Request::ServeDevice { req: req.req, control_handle })
479                    }
480                    _ => Err(fidl::Error::UnknownOrdinal {
481                        ordinal: header.ordinal,
482                        protocol_name:
483                            <DeviceProxy_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
484                    }),
485                }))
486            },
487        )
488    }
489}
490
491/// Simple interface to serve devices over fidl.
492#[derive(Debug)]
493pub enum DeviceProxy_Request {
494    /// Serve the Controller protocol for this device.
495    ServeController {
496        req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
497        control_handle: DeviceProxy_ControlHandle,
498    },
499    /// Serve the device's FIDL protocol.
500    ServeDevice {
501        req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
502        control_handle: DeviceProxy_ControlHandle,
503    },
504}
505
506impl DeviceProxy_Request {
507    #[allow(irrefutable_let_patterns)]
508    pub fn into_serve_controller(
509        self,
510    ) -> Option<(
511        fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
512        DeviceProxy_ControlHandle,
513    )> {
514        if let DeviceProxy_Request::ServeController { req, control_handle } = self {
515            Some((req, control_handle))
516        } else {
517            None
518        }
519    }
520
521    #[allow(irrefutable_let_patterns)]
522    pub fn into_serve_device(
523        self,
524    ) -> Option<(
525        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
526        DeviceProxy_ControlHandle,
527    )> {
528        if let DeviceProxy_Request::ServeDevice { req, control_handle } = self {
529            Some((req, control_handle))
530        } else {
531            None
532        }
533    }
534
535    /// Name of the method defined in FIDL
536    pub fn method_name(&self) -> &'static str {
537        match *self {
538            DeviceProxy_Request::ServeController { .. } => "serve_controller",
539            DeviceProxy_Request::ServeDevice { .. } => "serve_device",
540        }
541    }
542}
543
544#[derive(Debug, Clone)]
545pub struct DeviceProxy_ControlHandle {
546    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
547}
548
549impl fidl::endpoints::ControlHandle for DeviceProxy_ControlHandle {
550    fn shutdown(&self) {
551        self.inner.shutdown()
552    }
553    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
554        self.inner.shutdown_with_epitaph(status)
555    }
556
557    fn is_closed(&self) -> bool {
558        self.inner.channel().is_closed()
559    }
560    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
561        self.inner.channel().on_closed()
562    }
563
564    #[cfg(target_os = "fuchsia")]
565    fn signal_peer(
566        &self,
567        clear_mask: zx::Signals,
568        set_mask: zx::Signals,
569    ) -> Result<(), zx_status::Status> {
570        use fidl::Peered;
571        self.inner.channel().signal_peer(clear_mask, set_mask)
572    }
573}
574
575impl DeviceProxy_ControlHandle {}
576
577#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
578pub struct EndpointMarker;
579
580impl fidl::endpoints::ProtocolMarker for EndpointMarker {
581    type Proxy = EndpointProxy;
582    type RequestStream = EndpointRequestStream;
583    #[cfg(target_os = "fuchsia")]
584    type SynchronousProxy = EndpointSynchronousProxy;
585
586    const DEBUG_NAME: &'static str = "(anonymous) Endpoint";
587}
588
589pub trait EndpointProxyInterface: Send + Sync {
590    type GetConfigResponseFut: std::future::Future<Output = Result<EndpointConfig, fidl::Error>>
591        + Send;
592    fn r#get_config(&self) -> Self::GetConfigResponseFut;
593    type GetNameResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
594    fn r#get_name(&self) -> Self::GetNameResponseFut;
595    type SetLinkUpResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
596    fn r#set_link_up(&self, up: bool) -> Self::SetLinkUpResponseFut;
597    fn r#get_port(
598        &self,
599        port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
600    ) -> Result<(), fidl::Error>;
601    fn r#get_proxy_(
602        &self,
603        proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
604    ) -> Result<(), fidl::Error>;
605}
606#[derive(Debug)]
607#[cfg(target_os = "fuchsia")]
608pub struct EndpointSynchronousProxy {
609    client: fidl::client::sync::Client,
610}
611
612#[cfg(target_os = "fuchsia")]
613impl fidl::endpoints::SynchronousProxy for EndpointSynchronousProxy {
614    type Proxy = EndpointProxy;
615    type Protocol = EndpointMarker;
616
617    fn from_channel(inner: fidl::Channel) -> Self {
618        Self::new(inner)
619    }
620
621    fn into_channel(self) -> fidl::Channel {
622        self.client.into_channel()
623    }
624
625    fn as_channel(&self) -> &fidl::Channel {
626        self.client.as_channel()
627    }
628}
629
630#[cfg(target_os = "fuchsia")]
631impl EndpointSynchronousProxy {
632    pub fn new(channel: fidl::Channel) -> Self {
633        let protocol_name = <EndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
634        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
635    }
636
637    pub fn into_channel(self) -> fidl::Channel {
638        self.client.into_channel()
639    }
640
641    /// Waits until an event arrives and returns it. It is safe for other
642    /// threads to make concurrent requests while waiting for an event.
643    pub fn wait_for_event(
644        &self,
645        deadline: zx::MonotonicInstant,
646    ) -> Result<EndpointEvent, fidl::Error> {
647        EndpointEvent::decode(self.client.wait_for_event(deadline)?)
648    }
649
650    pub fn r#get_config(
651        &self,
652        ___deadline: zx::MonotonicInstant,
653    ) -> Result<EndpointConfig, fidl::Error> {
654        let _response =
655            self.client.send_query::<fidl::encoding::EmptyPayload, EndpointGetConfigResponse>(
656                (),
657                0x3589f54aa3748539,
658                fidl::encoding::DynamicFlags::empty(),
659                ___deadline,
660            )?;
661        Ok(_response.config)
662    }
663
664    /// Gets endpoint name.
665    pub fn r#get_name(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
666        let _response =
667            self.client.send_query::<fidl::encoding::EmptyPayload, EndpointGetNameResponse>(
668                (),
669                0x7d69650823557aab,
670                fidl::encoding::DynamicFlags::empty(),
671                ___deadline,
672            )?;
673        Ok(_response.name)
674    }
675
676    /// Sends link up or down signal
677    pub fn r#set_link_up(
678        &self,
679        mut up: bool,
680        ___deadline: zx::MonotonicInstant,
681    ) -> Result<(), fidl::Error> {
682        let _response =
683            self.client.send_query::<EndpointSetLinkUpRequest, fidl::encoding::EmptyPayload>(
684                (up,),
685                0x4dde77de68d02e11,
686                fidl::encoding::DynamicFlags::empty(),
687                ___deadline,
688            )?;
689        Ok(_response)
690    }
691
692    /// Connects to the underlying device port.
693    pub fn r#get_port(
694        &self,
695        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
696    ) -> Result<(), fidl::Error> {
697        self.client.send::<EndpointGetPortRequest>(
698            (port,),
699            0x68151e034eccc958,
700            fidl::encoding::DynamicFlags::empty(),
701        )
702    }
703
704    /// Gets a proxy to open requests with zircon ethernet device.
705    pub fn r#get_proxy_(
706        &self,
707        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
708    ) -> Result<(), fidl::Error> {
709        self.client.send::<EndpointGetProxyRequest>(
710            (proxy,),
711            0x476e5a57c4288ee9,
712            fidl::encoding::DynamicFlags::empty(),
713        )
714    }
715}
716
717#[cfg(target_os = "fuchsia")]
718impl From<EndpointSynchronousProxy> for zx::Handle {
719    fn from(value: EndpointSynchronousProxy) -> Self {
720        value.into_channel().into()
721    }
722}
723
724#[cfg(target_os = "fuchsia")]
725impl From<fidl::Channel> for EndpointSynchronousProxy {
726    fn from(value: fidl::Channel) -> Self {
727        Self::new(value)
728    }
729}
730
731#[cfg(target_os = "fuchsia")]
732impl fidl::endpoints::FromClient for EndpointSynchronousProxy {
733    type Protocol = EndpointMarker;
734
735    fn from_client(value: fidl::endpoints::ClientEnd<EndpointMarker>) -> Self {
736        Self::new(value.into_channel())
737    }
738}
739
740#[derive(Debug, Clone)]
741pub struct EndpointProxy {
742    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
743}
744
745impl fidl::endpoints::Proxy for EndpointProxy {
746    type Protocol = EndpointMarker;
747
748    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
749        Self::new(inner)
750    }
751
752    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
753        self.client.into_channel().map_err(|client| Self { client })
754    }
755
756    fn as_channel(&self) -> &::fidl::AsyncChannel {
757        self.client.as_channel()
758    }
759}
760
761impl EndpointProxy {
762    /// Create a new Proxy for fuchsia.netemul.network/Endpoint.
763    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
764        let protocol_name = <EndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
765        Self { client: fidl::client::Client::new(channel, protocol_name) }
766    }
767
768    /// Get a Stream of events from the remote end of the protocol.
769    ///
770    /// # Panics
771    ///
772    /// Panics if the event stream was already taken.
773    pub fn take_event_stream(&self) -> EndpointEventStream {
774        EndpointEventStream { event_receiver: self.client.take_event_receiver() }
775    }
776
777    pub fn r#get_config(
778        &self,
779    ) -> fidl::client::QueryResponseFut<EndpointConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
780    {
781        EndpointProxyInterface::r#get_config(self)
782    }
783
784    /// Gets endpoint name.
785    pub fn r#get_name(
786        &self,
787    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
788        EndpointProxyInterface::r#get_name(self)
789    }
790
791    /// Sends link up or down signal
792    pub fn r#set_link_up(
793        &self,
794        mut up: bool,
795    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
796        EndpointProxyInterface::r#set_link_up(self, up)
797    }
798
799    /// Connects to the underlying device port.
800    pub fn r#get_port(
801        &self,
802        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
803    ) -> Result<(), fidl::Error> {
804        EndpointProxyInterface::r#get_port(self, port)
805    }
806
807    /// Gets a proxy to open requests with zircon ethernet device.
808    pub fn r#get_proxy_(
809        &self,
810        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
811    ) -> Result<(), fidl::Error> {
812        EndpointProxyInterface::r#get_proxy_(self, proxy)
813    }
814}
815
816impl EndpointProxyInterface for EndpointProxy {
817    type GetConfigResponseFut = fidl::client::QueryResponseFut<
818        EndpointConfig,
819        fidl::encoding::DefaultFuchsiaResourceDialect,
820    >;
821    fn r#get_config(&self) -> Self::GetConfigResponseFut {
822        fn _decode(
823            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
824        ) -> Result<EndpointConfig, fidl::Error> {
825            let _response = fidl::client::decode_transaction_body::<
826                EndpointGetConfigResponse,
827                fidl::encoding::DefaultFuchsiaResourceDialect,
828                0x3589f54aa3748539,
829            >(_buf?)?;
830            Ok(_response.config)
831        }
832        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, EndpointConfig>(
833            (),
834            0x3589f54aa3748539,
835            fidl::encoding::DynamicFlags::empty(),
836            _decode,
837        )
838    }
839
840    type GetNameResponseFut =
841        fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect>;
842    fn r#get_name(&self) -> Self::GetNameResponseFut {
843        fn _decode(
844            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
845        ) -> Result<String, fidl::Error> {
846            let _response = fidl::client::decode_transaction_body::<
847                EndpointGetNameResponse,
848                fidl::encoding::DefaultFuchsiaResourceDialect,
849                0x7d69650823557aab,
850            >(_buf?)?;
851            Ok(_response.name)
852        }
853        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, String>(
854            (),
855            0x7d69650823557aab,
856            fidl::encoding::DynamicFlags::empty(),
857            _decode,
858        )
859    }
860
861    type SetLinkUpResponseFut =
862        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
863    fn r#set_link_up(&self, mut up: bool) -> Self::SetLinkUpResponseFut {
864        fn _decode(
865            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
866        ) -> Result<(), fidl::Error> {
867            let _response = fidl::client::decode_transaction_body::<
868                fidl::encoding::EmptyPayload,
869                fidl::encoding::DefaultFuchsiaResourceDialect,
870                0x4dde77de68d02e11,
871            >(_buf?)?;
872            Ok(_response)
873        }
874        self.client.send_query_and_decode::<EndpointSetLinkUpRequest, ()>(
875            (up,),
876            0x4dde77de68d02e11,
877            fidl::encoding::DynamicFlags::empty(),
878            _decode,
879        )
880    }
881
882    fn r#get_port(
883        &self,
884        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
885    ) -> Result<(), fidl::Error> {
886        self.client.send::<EndpointGetPortRequest>(
887            (port,),
888            0x68151e034eccc958,
889            fidl::encoding::DynamicFlags::empty(),
890        )
891    }
892
893    fn r#get_proxy_(
894        &self,
895        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
896    ) -> Result<(), fidl::Error> {
897        self.client.send::<EndpointGetProxyRequest>(
898            (proxy,),
899            0x476e5a57c4288ee9,
900            fidl::encoding::DynamicFlags::empty(),
901        )
902    }
903}
904
905pub struct EndpointEventStream {
906    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
907}
908
909impl std::marker::Unpin for EndpointEventStream {}
910
911impl futures::stream::FusedStream for EndpointEventStream {
912    fn is_terminated(&self) -> bool {
913        self.event_receiver.is_terminated()
914    }
915}
916
917impl futures::Stream for EndpointEventStream {
918    type Item = Result<EndpointEvent, fidl::Error>;
919
920    fn poll_next(
921        mut self: std::pin::Pin<&mut Self>,
922        cx: &mut std::task::Context<'_>,
923    ) -> std::task::Poll<Option<Self::Item>> {
924        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
925            &mut self.event_receiver,
926            cx
927        )?) {
928            Some(buf) => std::task::Poll::Ready(Some(EndpointEvent::decode(buf))),
929            None => std::task::Poll::Ready(None),
930        }
931    }
932}
933
934#[derive(Debug)]
935pub enum EndpointEvent {}
936
937impl EndpointEvent {
938    /// Decodes a message buffer as a [`EndpointEvent`].
939    fn decode(
940        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
941    ) -> Result<EndpointEvent, fidl::Error> {
942        let (bytes, _handles) = buf.split_mut();
943        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
944        debug_assert_eq!(tx_header.tx_id, 0);
945        match tx_header.ordinal {
946            _ => Err(fidl::Error::UnknownOrdinal {
947                ordinal: tx_header.ordinal,
948                protocol_name: <EndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
949            }),
950        }
951    }
952}
953
954/// A Stream of incoming requests for fuchsia.netemul.network/Endpoint.
955pub struct EndpointRequestStream {
956    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
957    is_terminated: bool,
958}
959
960impl std::marker::Unpin for EndpointRequestStream {}
961
962impl futures::stream::FusedStream for EndpointRequestStream {
963    fn is_terminated(&self) -> bool {
964        self.is_terminated
965    }
966}
967
968impl fidl::endpoints::RequestStream for EndpointRequestStream {
969    type Protocol = EndpointMarker;
970    type ControlHandle = EndpointControlHandle;
971
972    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
973        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
974    }
975
976    fn control_handle(&self) -> Self::ControlHandle {
977        EndpointControlHandle { inner: self.inner.clone() }
978    }
979
980    fn into_inner(
981        self,
982    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
983    {
984        (self.inner, self.is_terminated)
985    }
986
987    fn from_inner(
988        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
989        is_terminated: bool,
990    ) -> Self {
991        Self { inner, is_terminated }
992    }
993}
994
995impl futures::Stream for EndpointRequestStream {
996    type Item = Result<EndpointRequest, fidl::Error>;
997
998    fn poll_next(
999        mut self: std::pin::Pin<&mut Self>,
1000        cx: &mut std::task::Context<'_>,
1001    ) -> std::task::Poll<Option<Self::Item>> {
1002        let this = &mut *self;
1003        if this.inner.check_shutdown(cx) {
1004            this.is_terminated = true;
1005            return std::task::Poll::Ready(None);
1006        }
1007        if this.is_terminated {
1008            panic!("polled EndpointRequestStream after completion");
1009        }
1010        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1011            |bytes, handles| {
1012                match this.inner.channel().read_etc(cx, bytes, handles) {
1013                    std::task::Poll::Ready(Ok(())) => {}
1014                    std::task::Poll::Pending => return std::task::Poll::Pending,
1015                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1016                        this.is_terminated = true;
1017                        return std::task::Poll::Ready(None);
1018                    }
1019                    std::task::Poll::Ready(Err(e)) => {
1020                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1021                            e.into(),
1022                        ))))
1023                    }
1024                }
1025
1026                // A message has been received from the channel
1027                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1028
1029                std::task::Poll::Ready(Some(match header.ordinal {
1030                    0x3589f54aa3748539 => {
1031                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1032                        let mut req = fidl::new_empty!(
1033                            fidl::encoding::EmptyPayload,
1034                            fidl::encoding::DefaultFuchsiaResourceDialect
1035                        );
1036                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1037                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
1038                        Ok(EndpointRequest::GetConfig {
1039                            responder: EndpointGetConfigResponder {
1040                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1041                                tx_id: header.tx_id,
1042                            },
1043                        })
1044                    }
1045                    0x7d69650823557aab => {
1046                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1047                        let mut req = fidl::new_empty!(
1048                            fidl::encoding::EmptyPayload,
1049                            fidl::encoding::DefaultFuchsiaResourceDialect
1050                        );
1051                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1052                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
1053                        Ok(EndpointRequest::GetName {
1054                            responder: EndpointGetNameResponder {
1055                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1056                                tx_id: header.tx_id,
1057                            },
1058                        })
1059                    }
1060                    0x4dde77de68d02e11 => {
1061                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1062                        let mut req = fidl::new_empty!(
1063                            EndpointSetLinkUpRequest,
1064                            fidl::encoding::DefaultFuchsiaResourceDialect
1065                        );
1066                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointSetLinkUpRequest>(&header, _body_bytes, handles, &mut req)?;
1067                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
1068                        Ok(EndpointRequest::SetLinkUp {
1069                            up: req.up,
1070
1071                            responder: EndpointSetLinkUpResponder {
1072                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1073                                tx_id: header.tx_id,
1074                            },
1075                        })
1076                    }
1077                    0x68151e034eccc958 => {
1078                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1079                        let mut req = fidl::new_empty!(
1080                            EndpointGetPortRequest,
1081                            fidl::encoding::DefaultFuchsiaResourceDialect
1082                        );
1083                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointGetPortRequest>(&header, _body_bytes, handles, &mut req)?;
1084                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
1085                        Ok(EndpointRequest::GetPort { port: req.port, control_handle })
1086                    }
1087                    0x476e5a57c4288ee9 => {
1088                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1089                        let mut req = fidl::new_empty!(
1090                            EndpointGetProxyRequest,
1091                            fidl::encoding::DefaultFuchsiaResourceDialect
1092                        );
1093                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointGetProxyRequest>(&header, _body_bytes, handles, &mut req)?;
1094                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
1095                        Ok(EndpointRequest::GetProxy_ { proxy: req.proxy, control_handle })
1096                    }
1097                    _ => Err(fidl::Error::UnknownOrdinal {
1098                        ordinal: header.ordinal,
1099                        protocol_name:
1100                            <EndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1101                    }),
1102                }))
1103            },
1104        )
1105    }
1106}
1107
1108/// Virtual ethernet endpoint.
1109#[derive(Debug)]
1110pub enum EndpointRequest {
1111    GetConfig {
1112        responder: EndpointGetConfigResponder,
1113    },
1114    /// Gets endpoint name.
1115    GetName {
1116        responder: EndpointGetNameResponder,
1117    },
1118    /// Sends link up or down signal
1119    SetLinkUp {
1120        up: bool,
1121        responder: EndpointSetLinkUpResponder,
1122    },
1123    /// Connects to the underlying device port.
1124    GetPort {
1125        port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
1126        control_handle: EndpointControlHandle,
1127    },
1128    /// Gets a proxy to open requests with zircon ethernet device.
1129    GetProxy_ {
1130        proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
1131        control_handle: EndpointControlHandle,
1132    },
1133}
1134
1135impl EndpointRequest {
1136    #[allow(irrefutable_let_patterns)]
1137    pub fn into_get_config(self) -> Option<(EndpointGetConfigResponder)> {
1138        if let EndpointRequest::GetConfig { responder } = self {
1139            Some((responder))
1140        } else {
1141            None
1142        }
1143    }
1144
1145    #[allow(irrefutable_let_patterns)]
1146    pub fn into_get_name(self) -> Option<(EndpointGetNameResponder)> {
1147        if let EndpointRequest::GetName { responder } = self {
1148            Some((responder))
1149        } else {
1150            None
1151        }
1152    }
1153
1154    #[allow(irrefutable_let_patterns)]
1155    pub fn into_set_link_up(self) -> Option<(bool, EndpointSetLinkUpResponder)> {
1156        if let EndpointRequest::SetLinkUp { up, responder } = self {
1157            Some((up, responder))
1158        } else {
1159            None
1160        }
1161    }
1162
1163    #[allow(irrefutable_let_patterns)]
1164    pub fn into_get_port(
1165        self,
1166    ) -> Option<(
1167        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
1168        EndpointControlHandle,
1169    )> {
1170        if let EndpointRequest::GetPort { port, control_handle } = self {
1171            Some((port, control_handle))
1172        } else {
1173            None
1174        }
1175    }
1176
1177    #[allow(irrefutable_let_patterns)]
1178    pub fn into_get_proxy_(
1179        self,
1180    ) -> Option<(fidl::endpoints::ServerEnd<DeviceProxy_Marker>, EndpointControlHandle)> {
1181        if let EndpointRequest::GetProxy_ { proxy, control_handle } = self {
1182            Some((proxy, control_handle))
1183        } else {
1184            None
1185        }
1186    }
1187
1188    /// Name of the method defined in FIDL
1189    pub fn method_name(&self) -> &'static str {
1190        match *self {
1191            EndpointRequest::GetConfig { .. } => "get_config",
1192            EndpointRequest::GetName { .. } => "get_name",
1193            EndpointRequest::SetLinkUp { .. } => "set_link_up",
1194            EndpointRequest::GetPort { .. } => "get_port",
1195            EndpointRequest::GetProxy_ { .. } => "get_proxy_",
1196        }
1197    }
1198}
1199
1200#[derive(Debug, Clone)]
1201pub struct EndpointControlHandle {
1202    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1203}
1204
1205impl fidl::endpoints::ControlHandle for EndpointControlHandle {
1206    fn shutdown(&self) {
1207        self.inner.shutdown()
1208    }
1209    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1210        self.inner.shutdown_with_epitaph(status)
1211    }
1212
1213    fn is_closed(&self) -> bool {
1214        self.inner.channel().is_closed()
1215    }
1216    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1217        self.inner.channel().on_closed()
1218    }
1219
1220    #[cfg(target_os = "fuchsia")]
1221    fn signal_peer(
1222        &self,
1223        clear_mask: zx::Signals,
1224        set_mask: zx::Signals,
1225    ) -> Result<(), zx_status::Status> {
1226        use fidl::Peered;
1227        self.inner.channel().signal_peer(clear_mask, set_mask)
1228    }
1229}
1230
1231impl EndpointControlHandle {}
1232
1233#[must_use = "FIDL methods require a response to be sent"]
1234#[derive(Debug)]
1235pub struct EndpointGetConfigResponder {
1236    control_handle: std::mem::ManuallyDrop<EndpointControlHandle>,
1237    tx_id: u32,
1238}
1239
1240/// Set the the channel to be shutdown (see [`EndpointControlHandle::shutdown`])
1241/// if the responder is dropped without sending a response, so that the client
1242/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1243impl std::ops::Drop for EndpointGetConfigResponder {
1244    fn drop(&mut self) {
1245        self.control_handle.shutdown();
1246        // Safety: drops once, never accessed again
1247        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1248    }
1249}
1250
1251impl fidl::endpoints::Responder for EndpointGetConfigResponder {
1252    type ControlHandle = EndpointControlHandle;
1253
1254    fn control_handle(&self) -> &EndpointControlHandle {
1255        &self.control_handle
1256    }
1257
1258    fn drop_without_shutdown(mut self) {
1259        // Safety: drops once, never accessed again due to mem::forget
1260        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1261        // Prevent Drop from running (which would shut down the channel)
1262        std::mem::forget(self);
1263    }
1264}
1265
1266impl EndpointGetConfigResponder {
1267    /// Sends a response to the FIDL transaction.
1268    ///
1269    /// Sets the channel to shutdown if an error occurs.
1270    pub fn send(self, mut config: &EndpointConfig) -> Result<(), fidl::Error> {
1271        let _result = self.send_raw(config);
1272        if _result.is_err() {
1273            self.control_handle.shutdown();
1274        }
1275        self.drop_without_shutdown();
1276        _result
1277    }
1278
1279    /// Similar to "send" but does not shutdown the channel if an error occurs.
1280    pub fn send_no_shutdown_on_err(self, mut config: &EndpointConfig) -> Result<(), fidl::Error> {
1281        let _result = self.send_raw(config);
1282        self.drop_without_shutdown();
1283        _result
1284    }
1285
1286    fn send_raw(&self, mut config: &EndpointConfig) -> Result<(), fidl::Error> {
1287        self.control_handle.inner.send::<EndpointGetConfigResponse>(
1288            (config,),
1289            self.tx_id,
1290            0x3589f54aa3748539,
1291            fidl::encoding::DynamicFlags::empty(),
1292        )
1293    }
1294}
1295
1296#[must_use = "FIDL methods require a response to be sent"]
1297#[derive(Debug)]
1298pub struct EndpointGetNameResponder {
1299    control_handle: std::mem::ManuallyDrop<EndpointControlHandle>,
1300    tx_id: u32,
1301}
1302
1303/// Set the the channel to be shutdown (see [`EndpointControlHandle::shutdown`])
1304/// if the responder is dropped without sending a response, so that the client
1305/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1306impl std::ops::Drop for EndpointGetNameResponder {
1307    fn drop(&mut self) {
1308        self.control_handle.shutdown();
1309        // Safety: drops once, never accessed again
1310        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1311    }
1312}
1313
1314impl fidl::endpoints::Responder for EndpointGetNameResponder {
1315    type ControlHandle = EndpointControlHandle;
1316
1317    fn control_handle(&self) -> &EndpointControlHandle {
1318        &self.control_handle
1319    }
1320
1321    fn drop_without_shutdown(mut self) {
1322        // Safety: drops once, never accessed again due to mem::forget
1323        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1324        // Prevent Drop from running (which would shut down the channel)
1325        std::mem::forget(self);
1326    }
1327}
1328
1329impl EndpointGetNameResponder {
1330    /// Sends a response to the FIDL transaction.
1331    ///
1332    /// Sets the channel to shutdown if an error occurs.
1333    pub fn send(self, mut name: &str) -> Result<(), fidl::Error> {
1334        let _result = self.send_raw(name);
1335        if _result.is_err() {
1336            self.control_handle.shutdown();
1337        }
1338        self.drop_without_shutdown();
1339        _result
1340    }
1341
1342    /// Similar to "send" but does not shutdown the channel if an error occurs.
1343    pub fn send_no_shutdown_on_err(self, mut name: &str) -> Result<(), fidl::Error> {
1344        let _result = self.send_raw(name);
1345        self.drop_without_shutdown();
1346        _result
1347    }
1348
1349    fn send_raw(&self, mut name: &str) -> Result<(), fidl::Error> {
1350        self.control_handle.inner.send::<EndpointGetNameResponse>(
1351            (name,),
1352            self.tx_id,
1353            0x7d69650823557aab,
1354            fidl::encoding::DynamicFlags::empty(),
1355        )
1356    }
1357}
1358
1359#[must_use = "FIDL methods require a response to be sent"]
1360#[derive(Debug)]
1361pub struct EndpointSetLinkUpResponder {
1362    control_handle: std::mem::ManuallyDrop<EndpointControlHandle>,
1363    tx_id: u32,
1364}
1365
1366/// Set the the channel to be shutdown (see [`EndpointControlHandle::shutdown`])
1367/// if the responder is dropped without sending a response, so that the client
1368/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1369impl std::ops::Drop for EndpointSetLinkUpResponder {
1370    fn drop(&mut self) {
1371        self.control_handle.shutdown();
1372        // Safety: drops once, never accessed again
1373        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1374    }
1375}
1376
1377impl fidl::endpoints::Responder for EndpointSetLinkUpResponder {
1378    type ControlHandle = EndpointControlHandle;
1379
1380    fn control_handle(&self) -> &EndpointControlHandle {
1381        &self.control_handle
1382    }
1383
1384    fn drop_without_shutdown(mut self) {
1385        // Safety: drops once, never accessed again due to mem::forget
1386        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1387        // Prevent Drop from running (which would shut down the channel)
1388        std::mem::forget(self);
1389    }
1390}
1391
1392impl EndpointSetLinkUpResponder {
1393    /// Sends a response to the FIDL transaction.
1394    ///
1395    /// Sets the channel to shutdown if an error occurs.
1396    pub fn send(self) -> Result<(), fidl::Error> {
1397        let _result = self.send_raw();
1398        if _result.is_err() {
1399            self.control_handle.shutdown();
1400        }
1401        self.drop_without_shutdown();
1402        _result
1403    }
1404
1405    /// Similar to "send" but does not shutdown the channel if an error occurs.
1406    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1407        let _result = self.send_raw();
1408        self.drop_without_shutdown();
1409        _result
1410    }
1411
1412    fn send_raw(&self) -> Result<(), fidl::Error> {
1413        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1414            (),
1415            self.tx_id,
1416            0x4dde77de68d02e11,
1417            fidl::encoding::DynamicFlags::empty(),
1418        )
1419    }
1420}
1421
1422#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1423pub struct EndpointManagerMarker;
1424
1425impl fidl::endpoints::ProtocolMarker for EndpointManagerMarker {
1426    type Proxy = EndpointManagerProxy;
1427    type RequestStream = EndpointManagerRequestStream;
1428    #[cfg(target_os = "fuchsia")]
1429    type SynchronousProxy = EndpointManagerSynchronousProxy;
1430
1431    const DEBUG_NAME: &'static str = "(anonymous) EndpointManager";
1432}
1433
1434pub trait EndpointManagerProxyInterface: Send + Sync {
1435    type ListEndpointsResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
1436        + Send;
1437    fn r#list_endpoints(&self) -> Self::ListEndpointsResponseFut;
1438    type CreateEndpointResponseFut: std::future::Future<
1439            Output = Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error>,
1440        > + Send;
1441    fn r#create_endpoint(
1442        &self,
1443        name: &str,
1444        config: &EndpointConfig,
1445    ) -> Self::CreateEndpointResponseFut;
1446    type GetEndpointResponseFut: std::future::Future<
1447            Output = Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error>,
1448        > + Send;
1449    fn r#get_endpoint(&self, name: &str) -> Self::GetEndpointResponseFut;
1450}
1451#[derive(Debug)]
1452#[cfg(target_os = "fuchsia")]
1453pub struct EndpointManagerSynchronousProxy {
1454    client: fidl::client::sync::Client,
1455}
1456
1457#[cfg(target_os = "fuchsia")]
1458impl fidl::endpoints::SynchronousProxy for EndpointManagerSynchronousProxy {
1459    type Proxy = EndpointManagerProxy;
1460    type Protocol = EndpointManagerMarker;
1461
1462    fn from_channel(inner: fidl::Channel) -> Self {
1463        Self::new(inner)
1464    }
1465
1466    fn into_channel(self) -> fidl::Channel {
1467        self.client.into_channel()
1468    }
1469
1470    fn as_channel(&self) -> &fidl::Channel {
1471        self.client.as_channel()
1472    }
1473}
1474
1475#[cfg(target_os = "fuchsia")]
1476impl EndpointManagerSynchronousProxy {
1477    pub fn new(channel: fidl::Channel) -> Self {
1478        let protocol_name = <EndpointManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1479        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1480    }
1481
1482    pub fn into_channel(self) -> fidl::Channel {
1483        self.client.into_channel()
1484    }
1485
1486    /// Waits until an event arrives and returns it. It is safe for other
1487    /// threads to make concurrent requests while waiting for an event.
1488    pub fn wait_for_event(
1489        &self,
1490        deadline: zx::MonotonicInstant,
1491    ) -> Result<EndpointManagerEvent, fidl::Error> {
1492        EndpointManagerEvent::decode(self.client.wait_for_event(deadline)?)
1493    }
1494
1495    /// Lists endpoints by name.
1496    pub fn r#list_endpoints(
1497        &self,
1498        ___deadline: zx::MonotonicInstant,
1499    ) -> Result<Vec<String>, fidl::Error> {
1500        let _response = self
1501            .client
1502            .send_query::<fidl::encoding::EmptyPayload, EndpointManagerListEndpointsResponse>(
1503                (),
1504                0x78c83d9454e3d228,
1505                fidl::encoding::DynamicFlags::empty(),
1506                ___deadline,
1507            )?;
1508        Ok(_response.endp)
1509    }
1510
1511    /// Creates endpoint with given name and config.
1512    pub fn r#create_endpoint(
1513        &self,
1514        mut name: &str,
1515        mut config: &EndpointConfig,
1516        ___deadline: zx::MonotonicInstant,
1517    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error> {
1518        let _response = self.client.send_query::<
1519            EndpointManagerCreateEndpointRequest,
1520            EndpointManagerCreateEndpointResponse,
1521        >(
1522            (name, config,),
1523            0x7defe4cd5e4e7d7c,
1524            fidl::encoding::DynamicFlags::empty(),
1525            ___deadline,
1526        )?;
1527        Ok((_response.status, _response.endpoint))
1528    }
1529
1530    /// Gets a handle to an endpoint.
1531    pub fn r#get_endpoint(
1532        &self,
1533        mut name: &str,
1534        ___deadline: zx::MonotonicInstant,
1535    ) -> Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error> {
1536        let _response = self
1537            .client
1538            .send_query::<EndpointManagerGetEndpointRequest, EndpointManagerGetEndpointResponse>(
1539                (name,),
1540                0x437e956b7b860751,
1541                fidl::encoding::DynamicFlags::empty(),
1542                ___deadline,
1543            )?;
1544        Ok(_response.endpoint)
1545    }
1546}
1547
1548#[cfg(target_os = "fuchsia")]
1549impl From<EndpointManagerSynchronousProxy> for zx::Handle {
1550    fn from(value: EndpointManagerSynchronousProxy) -> Self {
1551        value.into_channel().into()
1552    }
1553}
1554
1555#[cfg(target_os = "fuchsia")]
1556impl From<fidl::Channel> for EndpointManagerSynchronousProxy {
1557    fn from(value: fidl::Channel) -> Self {
1558        Self::new(value)
1559    }
1560}
1561
1562#[cfg(target_os = "fuchsia")]
1563impl fidl::endpoints::FromClient for EndpointManagerSynchronousProxy {
1564    type Protocol = EndpointManagerMarker;
1565
1566    fn from_client(value: fidl::endpoints::ClientEnd<EndpointManagerMarker>) -> Self {
1567        Self::new(value.into_channel())
1568    }
1569}
1570
1571#[derive(Debug, Clone)]
1572pub struct EndpointManagerProxy {
1573    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1574}
1575
1576impl fidl::endpoints::Proxy for EndpointManagerProxy {
1577    type Protocol = EndpointManagerMarker;
1578
1579    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1580        Self::new(inner)
1581    }
1582
1583    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1584        self.client.into_channel().map_err(|client| Self { client })
1585    }
1586
1587    fn as_channel(&self) -> &::fidl::AsyncChannel {
1588        self.client.as_channel()
1589    }
1590}
1591
1592impl EndpointManagerProxy {
1593    /// Create a new Proxy for fuchsia.netemul.network/EndpointManager.
1594    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1595        let protocol_name = <EndpointManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1596        Self { client: fidl::client::Client::new(channel, protocol_name) }
1597    }
1598
1599    /// Get a Stream of events from the remote end of the protocol.
1600    ///
1601    /// # Panics
1602    ///
1603    /// Panics if the event stream was already taken.
1604    pub fn take_event_stream(&self) -> EndpointManagerEventStream {
1605        EndpointManagerEventStream { event_receiver: self.client.take_event_receiver() }
1606    }
1607
1608    /// Lists endpoints by name.
1609    pub fn r#list_endpoints(
1610        &self,
1611    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
1612    {
1613        EndpointManagerProxyInterface::r#list_endpoints(self)
1614    }
1615
1616    /// Creates endpoint with given name and config.
1617    pub fn r#create_endpoint(
1618        &self,
1619        mut name: &str,
1620        mut config: &EndpointConfig,
1621    ) -> fidl::client::QueryResponseFut<
1622        (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
1623        fidl::encoding::DefaultFuchsiaResourceDialect,
1624    > {
1625        EndpointManagerProxyInterface::r#create_endpoint(self, name, config)
1626    }
1627
1628    /// Gets a handle to an endpoint.
1629    pub fn r#get_endpoint(
1630        &self,
1631        mut name: &str,
1632    ) -> fidl::client::QueryResponseFut<
1633        Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
1634        fidl::encoding::DefaultFuchsiaResourceDialect,
1635    > {
1636        EndpointManagerProxyInterface::r#get_endpoint(self, name)
1637    }
1638}
1639
1640impl EndpointManagerProxyInterface for EndpointManagerProxy {
1641    type ListEndpointsResponseFut =
1642        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
1643    fn r#list_endpoints(&self) -> Self::ListEndpointsResponseFut {
1644        fn _decode(
1645            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1646        ) -> Result<Vec<String>, fidl::Error> {
1647            let _response = fidl::client::decode_transaction_body::<
1648                EndpointManagerListEndpointsResponse,
1649                fidl::encoding::DefaultFuchsiaResourceDialect,
1650                0x78c83d9454e3d228,
1651            >(_buf?)?;
1652            Ok(_response.endp)
1653        }
1654        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
1655            (),
1656            0x78c83d9454e3d228,
1657            fidl::encoding::DynamicFlags::empty(),
1658            _decode,
1659        )
1660    }
1661
1662    type CreateEndpointResponseFut = fidl::client::QueryResponseFut<
1663        (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
1664        fidl::encoding::DefaultFuchsiaResourceDialect,
1665    >;
1666    fn r#create_endpoint(
1667        &self,
1668        mut name: &str,
1669        mut config: &EndpointConfig,
1670    ) -> Self::CreateEndpointResponseFut {
1671        fn _decode(
1672            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1673        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error>
1674        {
1675            let _response = fidl::client::decode_transaction_body::<
1676                EndpointManagerCreateEndpointResponse,
1677                fidl::encoding::DefaultFuchsiaResourceDialect,
1678                0x7defe4cd5e4e7d7c,
1679            >(_buf?)?;
1680            Ok((_response.status, _response.endpoint))
1681        }
1682        self.client.send_query_and_decode::<
1683            EndpointManagerCreateEndpointRequest,
1684            (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
1685        >(
1686            (name, config,),
1687            0x7defe4cd5e4e7d7c,
1688            fidl::encoding::DynamicFlags::empty(),
1689            _decode,
1690        )
1691    }
1692
1693    type GetEndpointResponseFut = fidl::client::QueryResponseFut<
1694        Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
1695        fidl::encoding::DefaultFuchsiaResourceDialect,
1696    >;
1697    fn r#get_endpoint(&self, mut name: &str) -> Self::GetEndpointResponseFut {
1698        fn _decode(
1699            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1700        ) -> Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error> {
1701            let _response = fidl::client::decode_transaction_body::<
1702                EndpointManagerGetEndpointResponse,
1703                fidl::encoding::DefaultFuchsiaResourceDialect,
1704                0x437e956b7b860751,
1705            >(_buf?)?;
1706            Ok(_response.endpoint)
1707        }
1708        self.client.send_query_and_decode::<
1709            EndpointManagerGetEndpointRequest,
1710            Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
1711        >(
1712            (name,),
1713            0x437e956b7b860751,
1714            fidl::encoding::DynamicFlags::empty(),
1715            _decode,
1716        )
1717    }
1718}
1719
1720pub struct EndpointManagerEventStream {
1721    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1722}
1723
1724impl std::marker::Unpin for EndpointManagerEventStream {}
1725
1726impl futures::stream::FusedStream for EndpointManagerEventStream {
1727    fn is_terminated(&self) -> bool {
1728        self.event_receiver.is_terminated()
1729    }
1730}
1731
1732impl futures::Stream for EndpointManagerEventStream {
1733    type Item = Result<EndpointManagerEvent, fidl::Error>;
1734
1735    fn poll_next(
1736        mut self: std::pin::Pin<&mut Self>,
1737        cx: &mut std::task::Context<'_>,
1738    ) -> std::task::Poll<Option<Self::Item>> {
1739        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1740            &mut self.event_receiver,
1741            cx
1742        )?) {
1743            Some(buf) => std::task::Poll::Ready(Some(EndpointManagerEvent::decode(buf))),
1744            None => std::task::Poll::Ready(None),
1745        }
1746    }
1747}
1748
1749#[derive(Debug)]
1750pub enum EndpointManagerEvent {}
1751
1752impl EndpointManagerEvent {
1753    /// Decodes a message buffer as a [`EndpointManagerEvent`].
1754    fn decode(
1755        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1756    ) -> Result<EndpointManagerEvent, fidl::Error> {
1757        let (bytes, _handles) = buf.split_mut();
1758        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1759        debug_assert_eq!(tx_header.tx_id, 0);
1760        match tx_header.ordinal {
1761            _ => Err(fidl::Error::UnknownOrdinal {
1762                ordinal: tx_header.ordinal,
1763                protocol_name:
1764                    <EndpointManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1765            }),
1766        }
1767    }
1768}
1769
1770/// A Stream of incoming requests for fuchsia.netemul.network/EndpointManager.
1771pub struct EndpointManagerRequestStream {
1772    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1773    is_terminated: bool,
1774}
1775
1776impl std::marker::Unpin for EndpointManagerRequestStream {}
1777
1778impl futures::stream::FusedStream for EndpointManagerRequestStream {
1779    fn is_terminated(&self) -> bool {
1780        self.is_terminated
1781    }
1782}
1783
1784impl fidl::endpoints::RequestStream for EndpointManagerRequestStream {
1785    type Protocol = EndpointManagerMarker;
1786    type ControlHandle = EndpointManagerControlHandle;
1787
1788    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1789        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1790    }
1791
1792    fn control_handle(&self) -> Self::ControlHandle {
1793        EndpointManagerControlHandle { inner: self.inner.clone() }
1794    }
1795
1796    fn into_inner(
1797        self,
1798    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1799    {
1800        (self.inner, self.is_terminated)
1801    }
1802
1803    fn from_inner(
1804        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1805        is_terminated: bool,
1806    ) -> Self {
1807        Self { inner, is_terminated }
1808    }
1809}
1810
1811impl futures::Stream for EndpointManagerRequestStream {
1812    type Item = Result<EndpointManagerRequest, fidl::Error>;
1813
1814    fn poll_next(
1815        mut self: std::pin::Pin<&mut Self>,
1816        cx: &mut std::task::Context<'_>,
1817    ) -> std::task::Poll<Option<Self::Item>> {
1818        let this = &mut *self;
1819        if this.inner.check_shutdown(cx) {
1820            this.is_terminated = true;
1821            return std::task::Poll::Ready(None);
1822        }
1823        if this.is_terminated {
1824            panic!("polled EndpointManagerRequestStream after completion");
1825        }
1826        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1827            |bytes, handles| {
1828                match this.inner.channel().read_etc(cx, bytes, handles) {
1829                    std::task::Poll::Ready(Ok(())) => {}
1830                    std::task::Poll::Pending => return std::task::Poll::Pending,
1831                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1832                        this.is_terminated = true;
1833                        return std::task::Poll::Ready(None);
1834                    }
1835                    std::task::Poll::Ready(Err(e)) => {
1836                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1837                            e.into(),
1838                        ))))
1839                    }
1840                }
1841
1842                // A message has been received from the channel
1843                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1844
1845                std::task::Poll::Ready(Some(match header.ordinal {
1846                    0x78c83d9454e3d228 => {
1847                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1848                        let mut req = fidl::new_empty!(
1849                            fidl::encoding::EmptyPayload,
1850                            fidl::encoding::DefaultFuchsiaResourceDialect
1851                        );
1852                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1853                        let control_handle =
1854                            EndpointManagerControlHandle { inner: this.inner.clone() };
1855                        Ok(EndpointManagerRequest::ListEndpoints {
1856                            responder: EndpointManagerListEndpointsResponder {
1857                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1858                                tx_id: header.tx_id,
1859                            },
1860                        })
1861                    }
1862                    0x7defe4cd5e4e7d7c => {
1863                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1864                        let mut req = fidl::new_empty!(
1865                            EndpointManagerCreateEndpointRequest,
1866                            fidl::encoding::DefaultFuchsiaResourceDialect
1867                        );
1868                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointManagerCreateEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
1869                        let control_handle =
1870                            EndpointManagerControlHandle { inner: this.inner.clone() };
1871                        Ok(EndpointManagerRequest::CreateEndpoint {
1872                            name: req.name,
1873                            config: req.config,
1874
1875                            responder: EndpointManagerCreateEndpointResponder {
1876                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1877                                tx_id: header.tx_id,
1878                            },
1879                        })
1880                    }
1881                    0x437e956b7b860751 => {
1882                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1883                        let mut req = fidl::new_empty!(
1884                            EndpointManagerGetEndpointRequest,
1885                            fidl::encoding::DefaultFuchsiaResourceDialect
1886                        );
1887                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointManagerGetEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
1888                        let control_handle =
1889                            EndpointManagerControlHandle { inner: this.inner.clone() };
1890                        Ok(EndpointManagerRequest::GetEndpoint {
1891                            name: req.name,
1892
1893                            responder: EndpointManagerGetEndpointResponder {
1894                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1895                                tx_id: header.tx_id,
1896                            },
1897                        })
1898                    }
1899                    _ => Err(fidl::Error::UnknownOrdinal {
1900                        ordinal: header.ordinal,
1901                        protocol_name:
1902                            <EndpointManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1903                    }),
1904                }))
1905            },
1906        )
1907    }
1908}
1909
1910/// Manages virtual endpoints.
1911#[derive(Debug)]
1912pub enum EndpointManagerRequest {
1913    /// Lists endpoints by name.
1914    ListEndpoints { responder: EndpointManagerListEndpointsResponder },
1915    /// Creates endpoint with given name and config.
1916    CreateEndpoint {
1917        name: String,
1918        config: EndpointConfig,
1919        responder: EndpointManagerCreateEndpointResponder,
1920    },
1921    /// Gets a handle to an endpoint.
1922    GetEndpoint { name: String, responder: EndpointManagerGetEndpointResponder },
1923}
1924
1925impl EndpointManagerRequest {
1926    #[allow(irrefutable_let_patterns)]
1927    pub fn into_list_endpoints(self) -> Option<(EndpointManagerListEndpointsResponder)> {
1928        if let EndpointManagerRequest::ListEndpoints { responder } = self {
1929            Some((responder))
1930        } else {
1931            None
1932        }
1933    }
1934
1935    #[allow(irrefutable_let_patterns)]
1936    pub fn into_create_endpoint(
1937        self,
1938    ) -> Option<(String, EndpointConfig, EndpointManagerCreateEndpointResponder)> {
1939        if let EndpointManagerRequest::CreateEndpoint { name, config, responder } = self {
1940            Some((name, config, responder))
1941        } else {
1942            None
1943        }
1944    }
1945
1946    #[allow(irrefutable_let_patterns)]
1947    pub fn into_get_endpoint(self) -> Option<(String, EndpointManagerGetEndpointResponder)> {
1948        if let EndpointManagerRequest::GetEndpoint { name, responder } = self {
1949            Some((name, responder))
1950        } else {
1951            None
1952        }
1953    }
1954
1955    /// Name of the method defined in FIDL
1956    pub fn method_name(&self) -> &'static str {
1957        match *self {
1958            EndpointManagerRequest::ListEndpoints { .. } => "list_endpoints",
1959            EndpointManagerRequest::CreateEndpoint { .. } => "create_endpoint",
1960            EndpointManagerRequest::GetEndpoint { .. } => "get_endpoint",
1961        }
1962    }
1963}
1964
1965#[derive(Debug, Clone)]
1966pub struct EndpointManagerControlHandle {
1967    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1968}
1969
1970impl fidl::endpoints::ControlHandle for EndpointManagerControlHandle {
1971    fn shutdown(&self) {
1972        self.inner.shutdown()
1973    }
1974    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1975        self.inner.shutdown_with_epitaph(status)
1976    }
1977
1978    fn is_closed(&self) -> bool {
1979        self.inner.channel().is_closed()
1980    }
1981    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1982        self.inner.channel().on_closed()
1983    }
1984
1985    #[cfg(target_os = "fuchsia")]
1986    fn signal_peer(
1987        &self,
1988        clear_mask: zx::Signals,
1989        set_mask: zx::Signals,
1990    ) -> Result<(), zx_status::Status> {
1991        use fidl::Peered;
1992        self.inner.channel().signal_peer(clear_mask, set_mask)
1993    }
1994}
1995
1996impl EndpointManagerControlHandle {}
1997
1998#[must_use = "FIDL methods require a response to be sent"]
1999#[derive(Debug)]
2000pub struct EndpointManagerListEndpointsResponder {
2001    control_handle: std::mem::ManuallyDrop<EndpointManagerControlHandle>,
2002    tx_id: u32,
2003}
2004
2005/// Set the the channel to be shutdown (see [`EndpointManagerControlHandle::shutdown`])
2006/// if the responder is dropped without sending a response, so that the client
2007/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2008impl std::ops::Drop for EndpointManagerListEndpointsResponder {
2009    fn drop(&mut self) {
2010        self.control_handle.shutdown();
2011        // Safety: drops once, never accessed again
2012        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2013    }
2014}
2015
2016impl fidl::endpoints::Responder for EndpointManagerListEndpointsResponder {
2017    type ControlHandle = EndpointManagerControlHandle;
2018
2019    fn control_handle(&self) -> &EndpointManagerControlHandle {
2020        &self.control_handle
2021    }
2022
2023    fn drop_without_shutdown(mut self) {
2024        // Safety: drops once, never accessed again due to mem::forget
2025        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2026        // Prevent Drop from running (which would shut down the channel)
2027        std::mem::forget(self);
2028    }
2029}
2030
2031impl EndpointManagerListEndpointsResponder {
2032    /// Sends a response to the FIDL transaction.
2033    ///
2034    /// Sets the channel to shutdown if an error occurs.
2035    pub fn send(self, mut endp: &[String]) -> Result<(), fidl::Error> {
2036        let _result = self.send_raw(endp);
2037        if _result.is_err() {
2038            self.control_handle.shutdown();
2039        }
2040        self.drop_without_shutdown();
2041        _result
2042    }
2043
2044    /// Similar to "send" but does not shutdown the channel if an error occurs.
2045    pub fn send_no_shutdown_on_err(self, mut endp: &[String]) -> Result<(), fidl::Error> {
2046        let _result = self.send_raw(endp);
2047        self.drop_without_shutdown();
2048        _result
2049    }
2050
2051    fn send_raw(&self, mut endp: &[String]) -> Result<(), fidl::Error> {
2052        self.control_handle.inner.send::<EndpointManagerListEndpointsResponse>(
2053            (endp,),
2054            self.tx_id,
2055            0x78c83d9454e3d228,
2056            fidl::encoding::DynamicFlags::empty(),
2057        )
2058    }
2059}
2060
2061#[must_use = "FIDL methods require a response to be sent"]
2062#[derive(Debug)]
2063pub struct EndpointManagerCreateEndpointResponder {
2064    control_handle: std::mem::ManuallyDrop<EndpointManagerControlHandle>,
2065    tx_id: u32,
2066}
2067
2068/// Set the the channel to be shutdown (see [`EndpointManagerControlHandle::shutdown`])
2069/// if the responder is dropped without sending a response, so that the client
2070/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2071impl std::ops::Drop for EndpointManagerCreateEndpointResponder {
2072    fn drop(&mut self) {
2073        self.control_handle.shutdown();
2074        // Safety: drops once, never accessed again
2075        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2076    }
2077}
2078
2079impl fidl::endpoints::Responder for EndpointManagerCreateEndpointResponder {
2080    type ControlHandle = EndpointManagerControlHandle;
2081
2082    fn control_handle(&self) -> &EndpointManagerControlHandle {
2083        &self.control_handle
2084    }
2085
2086    fn drop_without_shutdown(mut self) {
2087        // Safety: drops once, never accessed again due to mem::forget
2088        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2089        // Prevent Drop from running (which would shut down the channel)
2090        std::mem::forget(self);
2091    }
2092}
2093
2094impl EndpointManagerCreateEndpointResponder {
2095    /// Sends a response to the FIDL transaction.
2096    ///
2097    /// Sets the channel to shutdown if an error occurs.
2098    pub fn send(
2099        self,
2100        mut status: i32,
2101        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2102    ) -> Result<(), fidl::Error> {
2103        let _result = self.send_raw(status, endpoint);
2104        if _result.is_err() {
2105            self.control_handle.shutdown();
2106        }
2107        self.drop_without_shutdown();
2108        _result
2109    }
2110
2111    /// Similar to "send" but does not shutdown the channel if an error occurs.
2112    pub fn send_no_shutdown_on_err(
2113        self,
2114        mut status: i32,
2115        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2116    ) -> Result<(), fidl::Error> {
2117        let _result = self.send_raw(status, endpoint);
2118        self.drop_without_shutdown();
2119        _result
2120    }
2121
2122    fn send_raw(
2123        &self,
2124        mut status: i32,
2125        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2126    ) -> Result<(), fidl::Error> {
2127        self.control_handle.inner.send::<EndpointManagerCreateEndpointResponse>(
2128            (status, endpoint),
2129            self.tx_id,
2130            0x7defe4cd5e4e7d7c,
2131            fidl::encoding::DynamicFlags::empty(),
2132        )
2133    }
2134}
2135
2136#[must_use = "FIDL methods require a response to be sent"]
2137#[derive(Debug)]
2138pub struct EndpointManagerGetEndpointResponder {
2139    control_handle: std::mem::ManuallyDrop<EndpointManagerControlHandle>,
2140    tx_id: u32,
2141}
2142
2143/// Set the the channel to be shutdown (see [`EndpointManagerControlHandle::shutdown`])
2144/// if the responder is dropped without sending a response, so that the client
2145/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2146impl std::ops::Drop for EndpointManagerGetEndpointResponder {
2147    fn drop(&mut self) {
2148        self.control_handle.shutdown();
2149        // Safety: drops once, never accessed again
2150        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2151    }
2152}
2153
2154impl fidl::endpoints::Responder for EndpointManagerGetEndpointResponder {
2155    type ControlHandle = EndpointManagerControlHandle;
2156
2157    fn control_handle(&self) -> &EndpointManagerControlHandle {
2158        &self.control_handle
2159    }
2160
2161    fn drop_without_shutdown(mut self) {
2162        // Safety: drops once, never accessed again due to mem::forget
2163        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2164        // Prevent Drop from running (which would shut down the channel)
2165        std::mem::forget(self);
2166    }
2167}
2168
2169impl EndpointManagerGetEndpointResponder {
2170    /// Sends a response to the FIDL transaction.
2171    ///
2172    /// Sets the channel to shutdown if an error occurs.
2173    pub fn send(
2174        self,
2175        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2176    ) -> Result<(), fidl::Error> {
2177        let _result = self.send_raw(endpoint);
2178        if _result.is_err() {
2179            self.control_handle.shutdown();
2180        }
2181        self.drop_without_shutdown();
2182        _result
2183    }
2184
2185    /// Similar to "send" but does not shutdown the channel if an error occurs.
2186    pub fn send_no_shutdown_on_err(
2187        self,
2188        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2189    ) -> Result<(), fidl::Error> {
2190        let _result = self.send_raw(endpoint);
2191        self.drop_without_shutdown();
2192        _result
2193    }
2194
2195    fn send_raw(
2196        &self,
2197        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
2198    ) -> Result<(), fidl::Error> {
2199        self.control_handle.inner.send::<EndpointManagerGetEndpointResponse>(
2200            (endpoint,),
2201            self.tx_id,
2202            0x437e956b7b860751,
2203            fidl::encoding::DynamicFlags::empty(),
2204        )
2205    }
2206}
2207
2208#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
2209pub struct FakeEndpointMarker;
2210
2211impl fidl::endpoints::ProtocolMarker for FakeEndpointMarker {
2212    type Proxy = FakeEndpointProxy;
2213    type RequestStream = FakeEndpointRequestStream;
2214    #[cfg(target_os = "fuchsia")]
2215    type SynchronousProxy = FakeEndpointSynchronousProxy;
2216
2217    const DEBUG_NAME: &'static str = "(anonymous) FakeEndpoint";
2218}
2219
2220pub trait FakeEndpointProxyInterface: Send + Sync {
2221    type WriteResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
2222    fn r#write(&self, data: &[u8]) -> Self::WriteResponseFut;
2223    type ReadResponseFut: std::future::Future<Output = Result<(Vec<u8>, u64), fidl::Error>> + Send;
2224    fn r#read(&self) -> Self::ReadResponseFut;
2225}
2226#[derive(Debug)]
2227#[cfg(target_os = "fuchsia")]
2228pub struct FakeEndpointSynchronousProxy {
2229    client: fidl::client::sync::Client,
2230}
2231
2232#[cfg(target_os = "fuchsia")]
2233impl fidl::endpoints::SynchronousProxy for FakeEndpointSynchronousProxy {
2234    type Proxy = FakeEndpointProxy;
2235    type Protocol = FakeEndpointMarker;
2236
2237    fn from_channel(inner: fidl::Channel) -> Self {
2238        Self::new(inner)
2239    }
2240
2241    fn into_channel(self) -> fidl::Channel {
2242        self.client.into_channel()
2243    }
2244
2245    fn as_channel(&self) -> &fidl::Channel {
2246        self.client.as_channel()
2247    }
2248}
2249
2250#[cfg(target_os = "fuchsia")]
2251impl FakeEndpointSynchronousProxy {
2252    pub fn new(channel: fidl::Channel) -> Self {
2253        let protocol_name = <FakeEndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2254        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
2255    }
2256
2257    pub fn into_channel(self) -> fidl::Channel {
2258        self.client.into_channel()
2259    }
2260
2261    /// Waits until an event arrives and returns it. It is safe for other
2262    /// threads to make concurrent requests while waiting for an event.
2263    pub fn wait_for_event(
2264        &self,
2265        deadline: zx::MonotonicInstant,
2266    ) -> Result<FakeEndpointEvent, fidl::Error> {
2267        FakeEndpointEvent::decode(self.client.wait_for_event(deadline)?)
2268    }
2269
2270    /// Writes a frame to the network.
2271    pub fn r#write(
2272        &self,
2273        mut data: &[u8],
2274        ___deadline: zx::MonotonicInstant,
2275    ) -> Result<(), fidl::Error> {
2276        let _response =
2277            self.client.send_query::<FakeEndpointWriteRequest, fidl::encoding::EmptyPayload>(
2278                (data,),
2279                0x2c54af94338c523b,
2280                fidl::encoding::DynamicFlags::empty(),
2281                ___deadline,
2282            )?;
2283        Ok(_response)
2284    }
2285
2286    /// Reads a single frame from the network.
2287    ///
2288    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
2289    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
2290    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
2291    ///
2292    /// Issuing a second `Read` request when the first one is still pending will cause the channel
2293    /// to be closed with `ZX_ERR_BAD_STATE`.
2294    pub fn r#read(&self, ___deadline: zx::MonotonicInstant) -> Result<(Vec<u8>, u64), fidl::Error> {
2295        let _response =
2296            self.client.send_query::<fidl::encoding::EmptyPayload, FakeEndpointReadResponse>(
2297                (),
2298                0x58e2d032a8f36234,
2299                fidl::encoding::DynamicFlags::empty(),
2300                ___deadline,
2301            )?;
2302        Ok((_response.data, _response.dropped_frames))
2303    }
2304}
2305
2306#[cfg(target_os = "fuchsia")]
2307impl From<FakeEndpointSynchronousProxy> for zx::Handle {
2308    fn from(value: FakeEndpointSynchronousProxy) -> Self {
2309        value.into_channel().into()
2310    }
2311}
2312
2313#[cfg(target_os = "fuchsia")]
2314impl From<fidl::Channel> for FakeEndpointSynchronousProxy {
2315    fn from(value: fidl::Channel) -> Self {
2316        Self::new(value)
2317    }
2318}
2319
2320#[cfg(target_os = "fuchsia")]
2321impl fidl::endpoints::FromClient for FakeEndpointSynchronousProxy {
2322    type Protocol = FakeEndpointMarker;
2323
2324    fn from_client(value: fidl::endpoints::ClientEnd<FakeEndpointMarker>) -> Self {
2325        Self::new(value.into_channel())
2326    }
2327}
2328
2329#[derive(Debug, Clone)]
2330pub struct FakeEndpointProxy {
2331    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
2332}
2333
2334impl fidl::endpoints::Proxy for FakeEndpointProxy {
2335    type Protocol = FakeEndpointMarker;
2336
2337    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
2338        Self::new(inner)
2339    }
2340
2341    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
2342        self.client.into_channel().map_err(|client| Self { client })
2343    }
2344
2345    fn as_channel(&self) -> &::fidl::AsyncChannel {
2346        self.client.as_channel()
2347    }
2348}
2349
2350impl FakeEndpointProxy {
2351    /// Create a new Proxy for fuchsia.netemul.network/FakeEndpoint.
2352    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
2353        let protocol_name = <FakeEndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2354        Self { client: fidl::client::Client::new(channel, protocol_name) }
2355    }
2356
2357    /// Get a Stream of events from the remote end of the protocol.
2358    ///
2359    /// # Panics
2360    ///
2361    /// Panics if the event stream was already taken.
2362    pub fn take_event_stream(&self) -> FakeEndpointEventStream {
2363        FakeEndpointEventStream { event_receiver: self.client.take_event_receiver() }
2364    }
2365
2366    /// Writes a frame to the network.
2367    pub fn r#write(
2368        &self,
2369        mut data: &[u8],
2370    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
2371        FakeEndpointProxyInterface::r#write(self, data)
2372    }
2373
2374    /// Reads a single frame from the network.
2375    ///
2376    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
2377    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
2378    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
2379    ///
2380    /// Issuing a second `Read` request when the first one is still pending will cause the channel
2381    /// to be closed with `ZX_ERR_BAD_STATE`.
2382    pub fn r#read(
2383        &self,
2384    ) -> fidl::client::QueryResponseFut<(Vec<u8>, u64), fidl::encoding::DefaultFuchsiaResourceDialect>
2385    {
2386        FakeEndpointProxyInterface::r#read(self)
2387    }
2388}
2389
2390impl FakeEndpointProxyInterface for FakeEndpointProxy {
2391    type WriteResponseFut =
2392        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2393    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
2394        fn _decode(
2395            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2396        ) -> Result<(), fidl::Error> {
2397            let _response = fidl::client::decode_transaction_body::<
2398                fidl::encoding::EmptyPayload,
2399                fidl::encoding::DefaultFuchsiaResourceDialect,
2400                0x2c54af94338c523b,
2401            >(_buf?)?;
2402            Ok(_response)
2403        }
2404        self.client.send_query_and_decode::<FakeEndpointWriteRequest, ()>(
2405            (data,),
2406            0x2c54af94338c523b,
2407            fidl::encoding::DynamicFlags::empty(),
2408            _decode,
2409        )
2410    }
2411
2412    type ReadResponseFut = fidl::client::QueryResponseFut<
2413        (Vec<u8>, u64),
2414        fidl::encoding::DefaultFuchsiaResourceDialect,
2415    >;
2416    fn r#read(&self) -> Self::ReadResponseFut {
2417        fn _decode(
2418            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2419        ) -> Result<(Vec<u8>, u64), fidl::Error> {
2420            let _response = fidl::client::decode_transaction_body::<
2421                FakeEndpointReadResponse,
2422                fidl::encoding::DefaultFuchsiaResourceDialect,
2423                0x58e2d032a8f36234,
2424            >(_buf?)?;
2425            Ok((_response.data, _response.dropped_frames))
2426        }
2427        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (Vec<u8>, u64)>(
2428            (),
2429            0x58e2d032a8f36234,
2430            fidl::encoding::DynamicFlags::empty(),
2431            _decode,
2432        )
2433    }
2434}
2435
2436pub struct FakeEndpointEventStream {
2437    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2438}
2439
2440impl std::marker::Unpin for FakeEndpointEventStream {}
2441
2442impl futures::stream::FusedStream for FakeEndpointEventStream {
2443    fn is_terminated(&self) -> bool {
2444        self.event_receiver.is_terminated()
2445    }
2446}
2447
2448impl futures::Stream for FakeEndpointEventStream {
2449    type Item = Result<FakeEndpointEvent, fidl::Error>;
2450
2451    fn poll_next(
2452        mut self: std::pin::Pin<&mut Self>,
2453        cx: &mut std::task::Context<'_>,
2454    ) -> std::task::Poll<Option<Self::Item>> {
2455        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2456            &mut self.event_receiver,
2457            cx
2458        )?) {
2459            Some(buf) => std::task::Poll::Ready(Some(FakeEndpointEvent::decode(buf))),
2460            None => std::task::Poll::Ready(None),
2461        }
2462    }
2463}
2464
2465#[derive(Debug)]
2466pub enum FakeEndpointEvent {}
2467
2468impl FakeEndpointEvent {
2469    /// Decodes a message buffer as a [`FakeEndpointEvent`].
2470    fn decode(
2471        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2472    ) -> Result<FakeEndpointEvent, fidl::Error> {
2473        let (bytes, _handles) = buf.split_mut();
2474        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2475        debug_assert_eq!(tx_header.tx_id, 0);
2476        match tx_header.ordinal {
2477            _ => Err(fidl::Error::UnknownOrdinal {
2478                ordinal: tx_header.ordinal,
2479                protocol_name: <FakeEndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2480            }),
2481        }
2482    }
2483}
2484
2485/// A Stream of incoming requests for fuchsia.netemul.network/FakeEndpoint.
2486pub struct FakeEndpointRequestStream {
2487    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2488    is_terminated: bool,
2489}
2490
2491impl std::marker::Unpin for FakeEndpointRequestStream {}
2492
2493impl futures::stream::FusedStream for FakeEndpointRequestStream {
2494    fn is_terminated(&self) -> bool {
2495        self.is_terminated
2496    }
2497}
2498
2499impl fidl::endpoints::RequestStream for FakeEndpointRequestStream {
2500    type Protocol = FakeEndpointMarker;
2501    type ControlHandle = FakeEndpointControlHandle;
2502
2503    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2504        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2505    }
2506
2507    fn control_handle(&self) -> Self::ControlHandle {
2508        FakeEndpointControlHandle { inner: self.inner.clone() }
2509    }
2510
2511    fn into_inner(
2512        self,
2513    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2514    {
2515        (self.inner, self.is_terminated)
2516    }
2517
2518    fn from_inner(
2519        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2520        is_terminated: bool,
2521    ) -> Self {
2522        Self { inner, is_terminated }
2523    }
2524}
2525
2526impl futures::Stream for FakeEndpointRequestStream {
2527    type Item = Result<FakeEndpointRequest, fidl::Error>;
2528
2529    fn poll_next(
2530        mut self: std::pin::Pin<&mut Self>,
2531        cx: &mut std::task::Context<'_>,
2532    ) -> std::task::Poll<Option<Self::Item>> {
2533        let this = &mut *self;
2534        if this.inner.check_shutdown(cx) {
2535            this.is_terminated = true;
2536            return std::task::Poll::Ready(None);
2537        }
2538        if this.is_terminated {
2539            panic!("polled FakeEndpointRequestStream after completion");
2540        }
2541        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2542            |bytes, handles| {
2543                match this.inner.channel().read_etc(cx, bytes, handles) {
2544                    std::task::Poll::Ready(Ok(())) => {}
2545                    std::task::Poll::Pending => return std::task::Poll::Pending,
2546                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2547                        this.is_terminated = true;
2548                        return std::task::Poll::Ready(None);
2549                    }
2550                    std::task::Poll::Ready(Err(e)) => {
2551                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2552                            e.into(),
2553                        ))))
2554                    }
2555                }
2556
2557                // A message has been received from the channel
2558                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2559
2560                std::task::Poll::Ready(Some(match header.ordinal {
2561                    0x2c54af94338c523b => {
2562                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2563                        let mut req = fidl::new_empty!(
2564                            FakeEndpointWriteRequest,
2565                            fidl::encoding::DefaultFuchsiaResourceDialect
2566                        );
2567                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FakeEndpointWriteRequest>(&header, _body_bytes, handles, &mut req)?;
2568                        let control_handle =
2569                            FakeEndpointControlHandle { inner: this.inner.clone() };
2570                        Ok(FakeEndpointRequest::Write {
2571                            data: req.data,
2572
2573                            responder: FakeEndpointWriteResponder {
2574                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2575                                tx_id: header.tx_id,
2576                            },
2577                        })
2578                    }
2579                    0x58e2d032a8f36234 => {
2580                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2581                        let mut req = fidl::new_empty!(
2582                            fidl::encoding::EmptyPayload,
2583                            fidl::encoding::DefaultFuchsiaResourceDialect
2584                        );
2585                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
2586                        let control_handle =
2587                            FakeEndpointControlHandle { inner: this.inner.clone() };
2588                        Ok(FakeEndpointRequest::Read {
2589                            responder: FakeEndpointReadResponder {
2590                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2591                                tx_id: header.tx_id,
2592                            },
2593                        })
2594                    }
2595                    _ => Err(fidl::Error::UnknownOrdinal {
2596                        ordinal: header.ordinal,
2597                        protocol_name:
2598                            <FakeEndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2599                    }),
2600                }))
2601            },
2602        )
2603    }
2604}
2605
2606/// Fake endpoint can be added to a network to snoop or inject packets.
2607#[derive(Debug)]
2608pub enum FakeEndpointRequest {
2609    /// Writes a frame to the network.
2610    Write { data: Vec<u8>, responder: FakeEndpointWriteResponder },
2611    /// Reads a single frame from the network.
2612    ///
2613    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
2614    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
2615    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
2616    ///
2617    /// Issuing a second `Read` request when the first one is still pending will cause the channel
2618    /// to be closed with `ZX_ERR_BAD_STATE`.
2619    Read { responder: FakeEndpointReadResponder },
2620}
2621
2622impl FakeEndpointRequest {
2623    #[allow(irrefutable_let_patterns)]
2624    pub fn into_write(self) -> Option<(Vec<u8>, FakeEndpointWriteResponder)> {
2625        if let FakeEndpointRequest::Write { data, responder } = self {
2626            Some((data, responder))
2627        } else {
2628            None
2629        }
2630    }
2631
2632    #[allow(irrefutable_let_patterns)]
2633    pub fn into_read(self) -> Option<(FakeEndpointReadResponder)> {
2634        if let FakeEndpointRequest::Read { responder } = self {
2635            Some((responder))
2636        } else {
2637            None
2638        }
2639    }
2640
2641    /// Name of the method defined in FIDL
2642    pub fn method_name(&self) -> &'static str {
2643        match *self {
2644            FakeEndpointRequest::Write { .. } => "write",
2645            FakeEndpointRequest::Read { .. } => "read",
2646        }
2647    }
2648}
2649
2650#[derive(Debug, Clone)]
2651pub struct FakeEndpointControlHandle {
2652    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2653}
2654
2655impl fidl::endpoints::ControlHandle for FakeEndpointControlHandle {
2656    fn shutdown(&self) {
2657        self.inner.shutdown()
2658    }
2659    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2660        self.inner.shutdown_with_epitaph(status)
2661    }
2662
2663    fn is_closed(&self) -> bool {
2664        self.inner.channel().is_closed()
2665    }
2666    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2667        self.inner.channel().on_closed()
2668    }
2669
2670    #[cfg(target_os = "fuchsia")]
2671    fn signal_peer(
2672        &self,
2673        clear_mask: zx::Signals,
2674        set_mask: zx::Signals,
2675    ) -> Result<(), zx_status::Status> {
2676        use fidl::Peered;
2677        self.inner.channel().signal_peer(clear_mask, set_mask)
2678    }
2679}
2680
2681impl FakeEndpointControlHandle {}
2682
2683#[must_use = "FIDL methods require a response to be sent"]
2684#[derive(Debug)]
2685pub struct FakeEndpointWriteResponder {
2686    control_handle: std::mem::ManuallyDrop<FakeEndpointControlHandle>,
2687    tx_id: u32,
2688}
2689
2690/// Set the the channel to be shutdown (see [`FakeEndpointControlHandle::shutdown`])
2691/// if the responder is dropped without sending a response, so that the client
2692/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2693impl std::ops::Drop for FakeEndpointWriteResponder {
2694    fn drop(&mut self) {
2695        self.control_handle.shutdown();
2696        // Safety: drops once, never accessed again
2697        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2698    }
2699}
2700
2701impl fidl::endpoints::Responder for FakeEndpointWriteResponder {
2702    type ControlHandle = FakeEndpointControlHandle;
2703
2704    fn control_handle(&self) -> &FakeEndpointControlHandle {
2705        &self.control_handle
2706    }
2707
2708    fn drop_without_shutdown(mut self) {
2709        // Safety: drops once, never accessed again due to mem::forget
2710        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2711        // Prevent Drop from running (which would shut down the channel)
2712        std::mem::forget(self);
2713    }
2714}
2715
2716impl FakeEndpointWriteResponder {
2717    /// Sends a response to the FIDL transaction.
2718    ///
2719    /// Sets the channel to shutdown if an error occurs.
2720    pub fn send(self) -> Result<(), fidl::Error> {
2721        let _result = self.send_raw();
2722        if _result.is_err() {
2723            self.control_handle.shutdown();
2724        }
2725        self.drop_without_shutdown();
2726        _result
2727    }
2728
2729    /// Similar to "send" but does not shutdown the channel if an error occurs.
2730    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
2731        let _result = self.send_raw();
2732        self.drop_without_shutdown();
2733        _result
2734    }
2735
2736    fn send_raw(&self) -> Result<(), fidl::Error> {
2737        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
2738            (),
2739            self.tx_id,
2740            0x2c54af94338c523b,
2741            fidl::encoding::DynamicFlags::empty(),
2742        )
2743    }
2744}
2745
2746#[must_use = "FIDL methods require a response to be sent"]
2747#[derive(Debug)]
2748pub struct FakeEndpointReadResponder {
2749    control_handle: std::mem::ManuallyDrop<FakeEndpointControlHandle>,
2750    tx_id: u32,
2751}
2752
2753/// Set the the channel to be shutdown (see [`FakeEndpointControlHandle::shutdown`])
2754/// if the responder is dropped without sending a response, so that the client
2755/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2756impl std::ops::Drop for FakeEndpointReadResponder {
2757    fn drop(&mut self) {
2758        self.control_handle.shutdown();
2759        // Safety: drops once, never accessed again
2760        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2761    }
2762}
2763
2764impl fidl::endpoints::Responder for FakeEndpointReadResponder {
2765    type ControlHandle = FakeEndpointControlHandle;
2766
2767    fn control_handle(&self) -> &FakeEndpointControlHandle {
2768        &self.control_handle
2769    }
2770
2771    fn drop_without_shutdown(mut self) {
2772        // Safety: drops once, never accessed again due to mem::forget
2773        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2774        // Prevent Drop from running (which would shut down the channel)
2775        std::mem::forget(self);
2776    }
2777}
2778
2779impl FakeEndpointReadResponder {
2780    /// Sends a response to the FIDL transaction.
2781    ///
2782    /// Sets the channel to shutdown if an error occurs.
2783    pub fn send(self, mut data: &[u8], mut dropped_frames: u64) -> Result<(), fidl::Error> {
2784        let _result = self.send_raw(data, dropped_frames);
2785        if _result.is_err() {
2786            self.control_handle.shutdown();
2787        }
2788        self.drop_without_shutdown();
2789        _result
2790    }
2791
2792    /// Similar to "send" but does not shutdown the channel if an error occurs.
2793    pub fn send_no_shutdown_on_err(
2794        self,
2795        mut data: &[u8],
2796        mut dropped_frames: u64,
2797    ) -> Result<(), fidl::Error> {
2798        let _result = self.send_raw(data, dropped_frames);
2799        self.drop_without_shutdown();
2800        _result
2801    }
2802
2803    fn send_raw(&self, mut data: &[u8], mut dropped_frames: u64) -> Result<(), fidl::Error> {
2804        self.control_handle.inner.send::<FakeEndpointReadResponse>(
2805            (data, dropped_frames),
2806            self.tx_id,
2807            0x58e2d032a8f36234,
2808            fidl::encoding::DynamicFlags::empty(),
2809        )
2810    }
2811}
2812
2813#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
2814pub struct NetworkMarker;
2815
2816impl fidl::endpoints::ProtocolMarker for NetworkMarker {
2817    type Proxy = NetworkProxy;
2818    type RequestStream = NetworkRequestStream;
2819    #[cfg(target_os = "fuchsia")]
2820    type SynchronousProxy = NetworkSynchronousProxy;
2821
2822    const DEBUG_NAME: &'static str = "(anonymous) Network";
2823}
2824
2825pub trait NetworkProxyInterface: Send + Sync {
2826    fn r#add_port(
2827        &self,
2828        port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
2829        interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
2830    ) -> Result<(), fidl::Error>;
2831    type GetConfigResponseFut: std::future::Future<Output = Result<NetworkConfig, fidl::Error>>
2832        + Send;
2833    fn r#get_config(&self) -> Self::GetConfigResponseFut;
2834    type GetNameResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
2835    fn r#get_name(&self) -> Self::GetNameResponseFut;
2836    type SetConfigResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
2837    fn r#set_config(&self, config: &NetworkConfig) -> Self::SetConfigResponseFut;
2838    type AttachEndpointResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
2839    fn r#attach_endpoint(&self, name: &str) -> Self::AttachEndpointResponseFut;
2840    type RemoveEndpointResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
2841    fn r#remove_endpoint(&self, name: &str) -> Self::RemoveEndpointResponseFut;
2842    fn r#create_fake_endpoint(
2843        &self,
2844        ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
2845    ) -> Result<(), fidl::Error>;
2846    type StartCaptureResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
2847    fn r#start_capture(&self, name: &str) -> Self::StartCaptureResponseFut;
2848    type StopCaptureResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
2849    fn r#stop_capture(&self) -> Self::StopCaptureResponseFut;
2850}
2851#[derive(Debug)]
2852#[cfg(target_os = "fuchsia")]
2853pub struct NetworkSynchronousProxy {
2854    client: fidl::client::sync::Client,
2855}
2856
2857#[cfg(target_os = "fuchsia")]
2858impl fidl::endpoints::SynchronousProxy for NetworkSynchronousProxy {
2859    type Proxy = NetworkProxy;
2860    type Protocol = NetworkMarker;
2861
2862    fn from_channel(inner: fidl::Channel) -> Self {
2863        Self::new(inner)
2864    }
2865
2866    fn into_channel(self) -> fidl::Channel {
2867        self.client.into_channel()
2868    }
2869
2870    fn as_channel(&self) -> &fidl::Channel {
2871        self.client.as_channel()
2872    }
2873}
2874
2875#[cfg(target_os = "fuchsia")]
2876impl NetworkSynchronousProxy {
2877    pub fn new(channel: fidl::Channel) -> Self {
2878        let protocol_name = <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2879        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
2880    }
2881
2882    pub fn into_channel(self) -> fidl::Channel {
2883        self.client.into_channel()
2884    }
2885
2886    /// Waits until an event arrives and returns it. It is safe for other
2887    /// threads to make concurrent requests while waiting for an event.
2888    pub fn wait_for_event(
2889        &self,
2890        deadline: zx::MonotonicInstant,
2891    ) -> Result<NetworkEvent, fidl::Error> {
2892        NetworkEvent::decode(self.client.wait_for_event(deadline)?)
2893    }
2894
2895    /// Adds a port to the network.
2896    ///
2897    /// + request `port` port to be added.
2898    /// + request `interface` provides control over the interface.
2899    pub fn r#add_port(
2900        &self,
2901        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
2902        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
2903    ) -> Result<(), fidl::Error> {
2904        self.client.send::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(
2905            (port, interface),
2906            0x7ad6a60c931a3f4e,
2907            fidl::encoding::DynamicFlags::empty(),
2908        )
2909    }
2910
2911    /// Gets network configuration.
2912    pub fn r#get_config(
2913        &self,
2914        ___deadline: zx::MonotonicInstant,
2915    ) -> Result<NetworkConfig, fidl::Error> {
2916        let _response =
2917            self.client.send_query::<fidl::encoding::EmptyPayload, NetworkGetConfigResponse>(
2918                (),
2919                0x8dc04557e2ab069,
2920                fidl::encoding::DynamicFlags::empty(),
2921                ___deadline,
2922            )?;
2923        Ok(_response.config)
2924    }
2925
2926    /// Gets network name.
2927    pub fn r#get_name(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
2928        let _response =
2929            self.client.send_query::<fidl::encoding::EmptyPayload, NetworkGetNameResponse>(
2930                (),
2931                0x57b7701d1ffeedb1,
2932                fidl::encoding::DynamicFlags::empty(),
2933                ___deadline,
2934            )?;
2935        Ok(_response.name)
2936    }
2937
2938    /// Updates network configuration.
2939    pub fn r#set_config(
2940        &self,
2941        mut config: &NetworkConfig,
2942        ___deadline: zx::MonotonicInstant,
2943    ) -> Result<i32, fidl::Error> {
2944        let _response =
2945            self.client.send_query::<NetworkSetConfigRequest, NetworkSetConfigResponse>(
2946                (config,),
2947                0x18a490ee9d4bfa16,
2948                fidl::encoding::DynamicFlags::empty(),
2949                ___deadline,
2950            )?;
2951        Ok(_response.status)
2952    }
2953
2954    /// Attaches endpoint with given name to network.
2955    pub fn r#attach_endpoint(
2956        &self,
2957        mut name: &str,
2958        ___deadline: zx::MonotonicInstant,
2959    ) -> Result<i32, fidl::Error> {
2960        let _response =
2961            self.client.send_query::<NetworkAttachEndpointRequest, NetworkAttachEndpointResponse>(
2962                (name,),
2963                0x6e8ff8e9ea1b9a98,
2964                fidl::encoding::DynamicFlags::empty(),
2965                ___deadline,
2966            )?;
2967        Ok(_response.status)
2968    }
2969
2970    /// Removes endpoint with given name from network.
2971    pub fn r#remove_endpoint(
2972        &self,
2973        mut name: &str,
2974        ___deadline: zx::MonotonicInstant,
2975    ) -> Result<i32, fidl::Error> {
2976        let _response =
2977            self.client.send_query::<NetworkRemoveEndpointRequest, NetworkRemoveEndpointResponse>(
2978                (name,),
2979                0x298eaac56bfcdd25,
2980                fidl::encoding::DynamicFlags::empty(),
2981                ___deadline,
2982            )?;
2983        Ok(_response.status)
2984    }
2985
2986    /// Injects a fake endpoint.
2987    pub fn r#create_fake_endpoint(
2988        &self,
2989        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
2990    ) -> Result<(), fidl::Error> {
2991        self.client.send::<NetworkCreateFakeEndpointRequest>(
2992            (ep,),
2993            0x3eb8f71b45e1e1f3,
2994            fidl::encoding::DynamicFlags::empty(),
2995        )
2996    }
2997
2998    /// Starts capturing packet in this network.
2999    ///
3000    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
3001    ///
3002    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
3003    /// in this network.
3004    pub fn r#start_capture(
3005        &self,
3006        mut name: &str,
3007        ___deadline: zx::MonotonicInstant,
3008    ) -> Result<i32, fidl::Error> {
3009        let _response =
3010            self.client.send_query::<NetworkStartCaptureRequest, NetworkStartCaptureResponse>(
3011                (name,),
3012                0x3ca44940622932c,
3013                fidl::encoding::DynamicFlags::empty(),
3014                ___deadline,
3015            )?;
3016        Ok(_response.status)
3017    }
3018
3019    /// Stops capturing packets. This function is guaranteed to succeed.
3020    ///
3021    /// The packet capture will be stored in the file at the path chosen when
3022    /// capturing started. The packet capture will stop automatically once the
3023    /// network is destroyed regardless of whether this method is called.
3024    pub fn r#stop_capture(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
3025        let _response =
3026            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
3027                (),
3028                0x1d7827adad109468,
3029                fidl::encoding::DynamicFlags::empty(),
3030                ___deadline,
3031            )?;
3032        Ok(_response)
3033    }
3034}
3035
3036#[cfg(target_os = "fuchsia")]
3037impl From<NetworkSynchronousProxy> for zx::Handle {
3038    fn from(value: NetworkSynchronousProxy) -> Self {
3039        value.into_channel().into()
3040    }
3041}
3042
3043#[cfg(target_os = "fuchsia")]
3044impl From<fidl::Channel> for NetworkSynchronousProxy {
3045    fn from(value: fidl::Channel) -> Self {
3046        Self::new(value)
3047    }
3048}
3049
3050#[cfg(target_os = "fuchsia")]
3051impl fidl::endpoints::FromClient for NetworkSynchronousProxy {
3052    type Protocol = NetworkMarker;
3053
3054    fn from_client(value: fidl::endpoints::ClientEnd<NetworkMarker>) -> Self {
3055        Self::new(value.into_channel())
3056    }
3057}
3058
3059#[derive(Debug, Clone)]
3060pub struct NetworkProxy {
3061    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
3062}
3063
3064impl fidl::endpoints::Proxy for NetworkProxy {
3065    type Protocol = NetworkMarker;
3066
3067    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
3068        Self::new(inner)
3069    }
3070
3071    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
3072        self.client.into_channel().map_err(|client| Self { client })
3073    }
3074
3075    fn as_channel(&self) -> &::fidl::AsyncChannel {
3076        self.client.as_channel()
3077    }
3078}
3079
3080impl NetworkProxy {
3081    /// Create a new Proxy for fuchsia.netemul.network/Network.
3082    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
3083        let protocol_name = <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
3084        Self { client: fidl::client::Client::new(channel, protocol_name) }
3085    }
3086
3087    /// Get a Stream of events from the remote end of the protocol.
3088    ///
3089    /// # Panics
3090    ///
3091    /// Panics if the event stream was already taken.
3092    pub fn take_event_stream(&self) -> NetworkEventStream {
3093        NetworkEventStream { event_receiver: self.client.take_event_receiver() }
3094    }
3095
3096    /// Adds a port to the network.
3097    ///
3098    /// + request `port` port to be added.
3099    /// + request `interface` provides control over the interface.
3100    pub fn r#add_port(
3101        &self,
3102        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
3103        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
3104    ) -> Result<(), fidl::Error> {
3105        NetworkProxyInterface::r#add_port(self, port, interface)
3106    }
3107
3108    /// Gets network configuration.
3109    pub fn r#get_config(
3110        &self,
3111    ) -> fidl::client::QueryResponseFut<NetworkConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
3112    {
3113        NetworkProxyInterface::r#get_config(self)
3114    }
3115
3116    /// Gets network name.
3117    pub fn r#get_name(
3118        &self,
3119    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
3120        NetworkProxyInterface::r#get_name(self)
3121    }
3122
3123    /// Updates network configuration.
3124    pub fn r#set_config(
3125        &self,
3126        mut config: &NetworkConfig,
3127    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
3128        NetworkProxyInterface::r#set_config(self, config)
3129    }
3130
3131    /// Attaches endpoint with given name to network.
3132    pub fn r#attach_endpoint(
3133        &self,
3134        mut name: &str,
3135    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
3136        NetworkProxyInterface::r#attach_endpoint(self, name)
3137    }
3138
3139    /// Removes endpoint with given name from network.
3140    pub fn r#remove_endpoint(
3141        &self,
3142        mut name: &str,
3143    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
3144        NetworkProxyInterface::r#remove_endpoint(self, name)
3145    }
3146
3147    /// Injects a fake endpoint.
3148    pub fn r#create_fake_endpoint(
3149        &self,
3150        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
3151    ) -> Result<(), fidl::Error> {
3152        NetworkProxyInterface::r#create_fake_endpoint(self, ep)
3153    }
3154
3155    /// Starts capturing packet in this network.
3156    ///
3157    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
3158    ///
3159    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
3160    /// in this network.
3161    pub fn r#start_capture(
3162        &self,
3163        mut name: &str,
3164    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
3165        NetworkProxyInterface::r#start_capture(self, name)
3166    }
3167
3168    /// Stops capturing packets. This function is guaranteed to succeed.
3169    ///
3170    /// The packet capture will be stored in the file at the path chosen when
3171    /// capturing started. The packet capture will stop automatically once the
3172    /// network is destroyed regardless of whether this method is called.
3173    pub fn r#stop_capture(
3174        &self,
3175    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
3176        NetworkProxyInterface::r#stop_capture(self)
3177    }
3178}
3179
3180impl NetworkProxyInterface for NetworkProxy {
3181    fn r#add_port(
3182        &self,
3183        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
3184        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
3185    ) -> Result<(), fidl::Error> {
3186        self.client.send::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(
3187            (port, interface),
3188            0x7ad6a60c931a3f4e,
3189            fidl::encoding::DynamicFlags::empty(),
3190        )
3191    }
3192
3193    type GetConfigResponseFut = fidl::client::QueryResponseFut<
3194        NetworkConfig,
3195        fidl::encoding::DefaultFuchsiaResourceDialect,
3196    >;
3197    fn r#get_config(&self) -> Self::GetConfigResponseFut {
3198        fn _decode(
3199            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3200        ) -> Result<NetworkConfig, fidl::Error> {
3201            let _response = fidl::client::decode_transaction_body::<
3202                NetworkGetConfigResponse,
3203                fidl::encoding::DefaultFuchsiaResourceDialect,
3204                0x8dc04557e2ab069,
3205            >(_buf?)?;
3206            Ok(_response.config)
3207        }
3208        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NetworkConfig>(
3209            (),
3210            0x8dc04557e2ab069,
3211            fidl::encoding::DynamicFlags::empty(),
3212            _decode,
3213        )
3214    }
3215
3216    type GetNameResponseFut =
3217        fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect>;
3218    fn r#get_name(&self) -> Self::GetNameResponseFut {
3219        fn _decode(
3220            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3221        ) -> Result<String, fidl::Error> {
3222            let _response = fidl::client::decode_transaction_body::<
3223                NetworkGetNameResponse,
3224                fidl::encoding::DefaultFuchsiaResourceDialect,
3225                0x57b7701d1ffeedb1,
3226            >(_buf?)?;
3227            Ok(_response.name)
3228        }
3229        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, String>(
3230            (),
3231            0x57b7701d1ffeedb1,
3232            fidl::encoding::DynamicFlags::empty(),
3233            _decode,
3234        )
3235    }
3236
3237    type SetConfigResponseFut =
3238        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
3239    fn r#set_config(&self, mut config: &NetworkConfig) -> Self::SetConfigResponseFut {
3240        fn _decode(
3241            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3242        ) -> Result<i32, fidl::Error> {
3243            let _response = fidl::client::decode_transaction_body::<
3244                NetworkSetConfigResponse,
3245                fidl::encoding::DefaultFuchsiaResourceDialect,
3246                0x18a490ee9d4bfa16,
3247            >(_buf?)?;
3248            Ok(_response.status)
3249        }
3250        self.client.send_query_and_decode::<NetworkSetConfigRequest, i32>(
3251            (config,),
3252            0x18a490ee9d4bfa16,
3253            fidl::encoding::DynamicFlags::empty(),
3254            _decode,
3255        )
3256    }
3257
3258    type AttachEndpointResponseFut =
3259        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
3260    fn r#attach_endpoint(&self, mut name: &str) -> Self::AttachEndpointResponseFut {
3261        fn _decode(
3262            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3263        ) -> Result<i32, fidl::Error> {
3264            let _response = fidl::client::decode_transaction_body::<
3265                NetworkAttachEndpointResponse,
3266                fidl::encoding::DefaultFuchsiaResourceDialect,
3267                0x6e8ff8e9ea1b9a98,
3268            >(_buf?)?;
3269            Ok(_response.status)
3270        }
3271        self.client.send_query_and_decode::<NetworkAttachEndpointRequest, i32>(
3272            (name,),
3273            0x6e8ff8e9ea1b9a98,
3274            fidl::encoding::DynamicFlags::empty(),
3275            _decode,
3276        )
3277    }
3278
3279    type RemoveEndpointResponseFut =
3280        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
3281    fn r#remove_endpoint(&self, mut name: &str) -> Self::RemoveEndpointResponseFut {
3282        fn _decode(
3283            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3284        ) -> Result<i32, fidl::Error> {
3285            let _response = fidl::client::decode_transaction_body::<
3286                NetworkRemoveEndpointResponse,
3287                fidl::encoding::DefaultFuchsiaResourceDialect,
3288                0x298eaac56bfcdd25,
3289            >(_buf?)?;
3290            Ok(_response.status)
3291        }
3292        self.client.send_query_and_decode::<NetworkRemoveEndpointRequest, i32>(
3293            (name,),
3294            0x298eaac56bfcdd25,
3295            fidl::encoding::DynamicFlags::empty(),
3296            _decode,
3297        )
3298    }
3299
3300    fn r#create_fake_endpoint(
3301        &self,
3302        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
3303    ) -> Result<(), fidl::Error> {
3304        self.client.send::<NetworkCreateFakeEndpointRequest>(
3305            (ep,),
3306            0x3eb8f71b45e1e1f3,
3307            fidl::encoding::DynamicFlags::empty(),
3308        )
3309    }
3310
3311    type StartCaptureResponseFut =
3312        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
3313    fn r#start_capture(&self, mut name: &str) -> Self::StartCaptureResponseFut {
3314        fn _decode(
3315            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3316        ) -> Result<i32, fidl::Error> {
3317            let _response = fidl::client::decode_transaction_body::<
3318                NetworkStartCaptureResponse,
3319                fidl::encoding::DefaultFuchsiaResourceDialect,
3320                0x3ca44940622932c,
3321            >(_buf?)?;
3322            Ok(_response.status)
3323        }
3324        self.client.send_query_and_decode::<NetworkStartCaptureRequest, i32>(
3325            (name,),
3326            0x3ca44940622932c,
3327            fidl::encoding::DynamicFlags::empty(),
3328            _decode,
3329        )
3330    }
3331
3332    type StopCaptureResponseFut =
3333        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
3334    fn r#stop_capture(&self) -> Self::StopCaptureResponseFut {
3335        fn _decode(
3336            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3337        ) -> Result<(), fidl::Error> {
3338            let _response = fidl::client::decode_transaction_body::<
3339                fidl::encoding::EmptyPayload,
3340                fidl::encoding::DefaultFuchsiaResourceDialect,
3341                0x1d7827adad109468,
3342            >(_buf?)?;
3343            Ok(_response)
3344        }
3345        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
3346            (),
3347            0x1d7827adad109468,
3348            fidl::encoding::DynamicFlags::empty(),
3349            _decode,
3350        )
3351    }
3352}
3353
3354pub struct NetworkEventStream {
3355    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
3356}
3357
3358impl std::marker::Unpin for NetworkEventStream {}
3359
3360impl futures::stream::FusedStream for NetworkEventStream {
3361    fn is_terminated(&self) -> bool {
3362        self.event_receiver.is_terminated()
3363    }
3364}
3365
3366impl futures::Stream for NetworkEventStream {
3367    type Item = Result<NetworkEvent, fidl::Error>;
3368
3369    fn poll_next(
3370        mut self: std::pin::Pin<&mut Self>,
3371        cx: &mut std::task::Context<'_>,
3372    ) -> std::task::Poll<Option<Self::Item>> {
3373        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
3374            &mut self.event_receiver,
3375            cx
3376        )?) {
3377            Some(buf) => std::task::Poll::Ready(Some(NetworkEvent::decode(buf))),
3378            None => std::task::Poll::Ready(None),
3379        }
3380    }
3381}
3382
3383#[derive(Debug)]
3384pub enum NetworkEvent {
3385    OnRemoved { reason: fidl_fuchsia_net_virtualization::NetworkRemovalReason },
3386}
3387
3388impl NetworkEvent {
3389    #[allow(irrefutable_let_patterns)]
3390    pub fn into_on_removed(self) -> Option<fidl_fuchsia_net_virtualization::NetworkRemovalReason> {
3391        if let NetworkEvent::OnRemoved { reason } = self {
3392            Some((reason))
3393        } else {
3394            None
3395        }
3396    }
3397
3398    /// Decodes a message buffer as a [`NetworkEvent`].
3399    fn decode(
3400        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
3401    ) -> Result<NetworkEvent, fidl::Error> {
3402        let (bytes, _handles) = buf.split_mut();
3403        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
3404        debug_assert_eq!(tx_header.tx_id, 0);
3405        match tx_header.ordinal {
3406            0xfe80656d1e5ec4a => {
3407                let mut out = fidl::new_empty!(
3408                    fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest,
3409                    fidl::encoding::DefaultFuchsiaResourceDialect
3410                );
3411                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
3412                Ok((NetworkEvent::OnRemoved { reason: out.reason }))
3413            }
3414            _ => Err(fidl::Error::UnknownOrdinal {
3415                ordinal: tx_header.ordinal,
3416                protocol_name: <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3417            }),
3418        }
3419    }
3420}
3421
3422/// A Stream of incoming requests for fuchsia.netemul.network/Network.
3423pub struct NetworkRequestStream {
3424    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3425    is_terminated: bool,
3426}
3427
3428impl std::marker::Unpin for NetworkRequestStream {}
3429
3430impl futures::stream::FusedStream for NetworkRequestStream {
3431    fn is_terminated(&self) -> bool {
3432        self.is_terminated
3433    }
3434}
3435
3436impl fidl::endpoints::RequestStream for NetworkRequestStream {
3437    type Protocol = NetworkMarker;
3438    type ControlHandle = NetworkControlHandle;
3439
3440    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
3441        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
3442    }
3443
3444    fn control_handle(&self) -> Self::ControlHandle {
3445        NetworkControlHandle { inner: self.inner.clone() }
3446    }
3447
3448    fn into_inner(
3449        self,
3450    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
3451    {
3452        (self.inner, self.is_terminated)
3453    }
3454
3455    fn from_inner(
3456        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3457        is_terminated: bool,
3458    ) -> Self {
3459        Self { inner, is_terminated }
3460    }
3461}
3462
3463impl futures::Stream for NetworkRequestStream {
3464    type Item = Result<NetworkRequest, fidl::Error>;
3465
3466    fn poll_next(
3467        mut self: std::pin::Pin<&mut Self>,
3468        cx: &mut std::task::Context<'_>,
3469    ) -> std::task::Poll<Option<Self::Item>> {
3470        let this = &mut *self;
3471        if this.inner.check_shutdown(cx) {
3472            this.is_terminated = true;
3473            return std::task::Poll::Ready(None);
3474        }
3475        if this.is_terminated {
3476            panic!("polled NetworkRequestStream after completion");
3477        }
3478        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
3479            |bytes, handles| {
3480                match this.inner.channel().read_etc(cx, bytes, handles) {
3481                    std::task::Poll::Ready(Ok(())) => {}
3482                    std::task::Poll::Pending => return std::task::Poll::Pending,
3483                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
3484                        this.is_terminated = true;
3485                        return std::task::Poll::Ready(None);
3486                    }
3487                    std::task::Poll::Ready(Err(e)) => {
3488                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
3489                            e.into(),
3490                        ))))
3491                    }
3492                }
3493
3494                // A message has been received from the channel
3495                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
3496
3497                std::task::Poll::Ready(Some(match header.ordinal {
3498                    0x7ad6a60c931a3f4e => {
3499                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3500                        let mut req = fidl::new_empty!(
3501                            fidl_fuchsia_net_virtualization::NetworkAddPortRequest,
3502                            fidl::encoding::DefaultFuchsiaResourceDialect
3503                        );
3504                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(&header, _body_bytes, handles, &mut req)?;
3505                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3506                        Ok(NetworkRequest::AddPort {
3507                            port: req.port,
3508                            interface: req.interface,
3509
3510                            control_handle,
3511                        })
3512                    }
3513                    0x8dc04557e2ab069 => {
3514                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3515                        let mut req = fidl::new_empty!(
3516                            fidl::encoding::EmptyPayload,
3517                            fidl::encoding::DefaultFuchsiaResourceDialect
3518                        );
3519                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
3520                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3521                        Ok(NetworkRequest::GetConfig {
3522                            responder: NetworkGetConfigResponder {
3523                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3524                                tx_id: header.tx_id,
3525                            },
3526                        })
3527                    }
3528                    0x57b7701d1ffeedb1 => {
3529                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3530                        let mut req = fidl::new_empty!(
3531                            fidl::encoding::EmptyPayload,
3532                            fidl::encoding::DefaultFuchsiaResourceDialect
3533                        );
3534                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
3535                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3536                        Ok(NetworkRequest::GetName {
3537                            responder: NetworkGetNameResponder {
3538                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3539                                tx_id: header.tx_id,
3540                            },
3541                        })
3542                    }
3543                    0x18a490ee9d4bfa16 => {
3544                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3545                        let mut req = fidl::new_empty!(
3546                            NetworkSetConfigRequest,
3547                            fidl::encoding::DefaultFuchsiaResourceDialect
3548                        );
3549                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkSetConfigRequest>(&header, _body_bytes, handles, &mut req)?;
3550                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3551                        Ok(NetworkRequest::SetConfig {
3552                            config: req.config,
3553
3554                            responder: NetworkSetConfigResponder {
3555                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3556                                tx_id: header.tx_id,
3557                            },
3558                        })
3559                    }
3560                    0x6e8ff8e9ea1b9a98 => {
3561                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3562                        let mut req = fidl::new_empty!(
3563                            NetworkAttachEndpointRequest,
3564                            fidl::encoding::DefaultFuchsiaResourceDialect
3565                        );
3566                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkAttachEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
3567                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3568                        Ok(NetworkRequest::AttachEndpoint {
3569                            name: req.name,
3570
3571                            responder: NetworkAttachEndpointResponder {
3572                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3573                                tx_id: header.tx_id,
3574                            },
3575                        })
3576                    }
3577                    0x298eaac56bfcdd25 => {
3578                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3579                        let mut req = fidl::new_empty!(
3580                            NetworkRemoveEndpointRequest,
3581                            fidl::encoding::DefaultFuchsiaResourceDialect
3582                        );
3583                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRemoveEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
3584                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3585                        Ok(NetworkRequest::RemoveEndpoint {
3586                            name: req.name,
3587
3588                            responder: NetworkRemoveEndpointResponder {
3589                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3590                                tx_id: header.tx_id,
3591                            },
3592                        })
3593                    }
3594                    0x3eb8f71b45e1e1f3 => {
3595                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3596                        let mut req = fidl::new_empty!(
3597                            NetworkCreateFakeEndpointRequest,
3598                            fidl::encoding::DefaultFuchsiaResourceDialect
3599                        );
3600                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkCreateFakeEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
3601                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3602                        Ok(NetworkRequest::CreateFakeEndpoint { ep: req.ep, control_handle })
3603                    }
3604                    0x3ca44940622932c => {
3605                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3606                        let mut req = fidl::new_empty!(
3607                            NetworkStartCaptureRequest,
3608                            fidl::encoding::DefaultFuchsiaResourceDialect
3609                        );
3610                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkStartCaptureRequest>(&header, _body_bytes, handles, &mut req)?;
3611                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3612                        Ok(NetworkRequest::StartCapture {
3613                            name: req.name,
3614
3615                            responder: NetworkStartCaptureResponder {
3616                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3617                                tx_id: header.tx_id,
3618                            },
3619                        })
3620                    }
3621                    0x1d7827adad109468 => {
3622                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3623                        let mut req = fidl::new_empty!(
3624                            fidl::encoding::EmptyPayload,
3625                            fidl::encoding::DefaultFuchsiaResourceDialect
3626                        );
3627                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
3628                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
3629                        Ok(NetworkRequest::StopCapture {
3630                            responder: NetworkStopCaptureResponder {
3631                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3632                                tx_id: header.tx_id,
3633                            },
3634                        })
3635                    }
3636                    _ => Err(fidl::Error::UnknownOrdinal {
3637                        ordinal: header.ordinal,
3638                        protocol_name:
3639                            <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3640                    }),
3641                }))
3642            },
3643        )
3644    }
3645}
3646
3647/// Virtual network.
3648#[derive(Debug)]
3649pub enum NetworkRequest {
3650    /// Adds a port to the network.
3651    ///
3652    /// + request `port` port to be added.
3653    /// + request `interface` provides control over the interface.
3654    AddPort {
3655        port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
3656        interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
3657        control_handle: NetworkControlHandle,
3658    },
3659    /// Gets network configuration.
3660    GetConfig { responder: NetworkGetConfigResponder },
3661    /// Gets network name.
3662    GetName { responder: NetworkGetNameResponder },
3663    /// Updates network configuration.
3664    SetConfig { config: NetworkConfig, responder: NetworkSetConfigResponder },
3665    /// Attaches endpoint with given name to network.
3666    AttachEndpoint { name: String, responder: NetworkAttachEndpointResponder },
3667    /// Removes endpoint with given name from network.
3668    RemoveEndpoint { name: String, responder: NetworkRemoveEndpointResponder },
3669    /// Injects a fake endpoint.
3670    CreateFakeEndpoint {
3671        ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
3672        control_handle: NetworkControlHandle,
3673    },
3674    /// Starts capturing packet in this network.
3675    ///
3676    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
3677    ///
3678    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
3679    /// in this network.
3680    StartCapture { name: String, responder: NetworkStartCaptureResponder },
3681    /// Stops capturing packets. This function is guaranteed to succeed.
3682    ///
3683    /// The packet capture will be stored in the file at the path chosen when
3684    /// capturing started. The packet capture will stop automatically once the
3685    /// network is destroyed regardless of whether this method is called.
3686    StopCapture { responder: NetworkStopCaptureResponder },
3687}
3688
3689impl NetworkRequest {
3690    #[allow(irrefutable_let_patterns)]
3691    pub fn into_add_port(
3692        self,
3693    ) -> Option<(
3694        fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
3695        fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
3696        NetworkControlHandle,
3697    )> {
3698        if let NetworkRequest::AddPort { port, interface, control_handle } = self {
3699            Some((port, interface, control_handle))
3700        } else {
3701            None
3702        }
3703    }
3704
3705    #[allow(irrefutable_let_patterns)]
3706    pub fn into_get_config(self) -> Option<(NetworkGetConfigResponder)> {
3707        if let NetworkRequest::GetConfig { responder } = self {
3708            Some((responder))
3709        } else {
3710            None
3711        }
3712    }
3713
3714    #[allow(irrefutable_let_patterns)]
3715    pub fn into_get_name(self) -> Option<(NetworkGetNameResponder)> {
3716        if let NetworkRequest::GetName { responder } = self {
3717            Some((responder))
3718        } else {
3719            None
3720        }
3721    }
3722
3723    #[allow(irrefutable_let_patterns)]
3724    pub fn into_set_config(self) -> Option<(NetworkConfig, NetworkSetConfigResponder)> {
3725        if let NetworkRequest::SetConfig { config, responder } = self {
3726            Some((config, responder))
3727        } else {
3728            None
3729        }
3730    }
3731
3732    #[allow(irrefutable_let_patterns)]
3733    pub fn into_attach_endpoint(self) -> Option<(String, NetworkAttachEndpointResponder)> {
3734        if let NetworkRequest::AttachEndpoint { name, responder } = self {
3735            Some((name, responder))
3736        } else {
3737            None
3738        }
3739    }
3740
3741    #[allow(irrefutable_let_patterns)]
3742    pub fn into_remove_endpoint(self) -> Option<(String, NetworkRemoveEndpointResponder)> {
3743        if let NetworkRequest::RemoveEndpoint { name, responder } = self {
3744            Some((name, responder))
3745        } else {
3746            None
3747        }
3748    }
3749
3750    #[allow(irrefutable_let_patterns)]
3751    pub fn into_create_fake_endpoint(
3752        self,
3753    ) -> Option<(fidl::endpoints::ServerEnd<FakeEndpointMarker>, NetworkControlHandle)> {
3754        if let NetworkRequest::CreateFakeEndpoint { ep, control_handle } = self {
3755            Some((ep, control_handle))
3756        } else {
3757            None
3758        }
3759    }
3760
3761    #[allow(irrefutable_let_patterns)]
3762    pub fn into_start_capture(self) -> Option<(String, NetworkStartCaptureResponder)> {
3763        if let NetworkRequest::StartCapture { name, responder } = self {
3764            Some((name, responder))
3765        } else {
3766            None
3767        }
3768    }
3769
3770    #[allow(irrefutable_let_patterns)]
3771    pub fn into_stop_capture(self) -> Option<(NetworkStopCaptureResponder)> {
3772        if let NetworkRequest::StopCapture { responder } = self {
3773            Some((responder))
3774        } else {
3775            None
3776        }
3777    }
3778
3779    /// Name of the method defined in FIDL
3780    pub fn method_name(&self) -> &'static str {
3781        match *self {
3782            NetworkRequest::AddPort { .. } => "add_port",
3783            NetworkRequest::GetConfig { .. } => "get_config",
3784            NetworkRequest::GetName { .. } => "get_name",
3785            NetworkRequest::SetConfig { .. } => "set_config",
3786            NetworkRequest::AttachEndpoint { .. } => "attach_endpoint",
3787            NetworkRequest::RemoveEndpoint { .. } => "remove_endpoint",
3788            NetworkRequest::CreateFakeEndpoint { .. } => "create_fake_endpoint",
3789            NetworkRequest::StartCapture { .. } => "start_capture",
3790            NetworkRequest::StopCapture { .. } => "stop_capture",
3791        }
3792    }
3793}
3794
3795#[derive(Debug, Clone)]
3796pub struct NetworkControlHandle {
3797    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3798}
3799
3800impl fidl::endpoints::ControlHandle for NetworkControlHandle {
3801    fn shutdown(&self) {
3802        self.inner.shutdown()
3803    }
3804    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3805        self.inner.shutdown_with_epitaph(status)
3806    }
3807
3808    fn is_closed(&self) -> bool {
3809        self.inner.channel().is_closed()
3810    }
3811    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3812        self.inner.channel().on_closed()
3813    }
3814
3815    #[cfg(target_os = "fuchsia")]
3816    fn signal_peer(
3817        &self,
3818        clear_mask: zx::Signals,
3819        set_mask: zx::Signals,
3820    ) -> Result<(), zx_status::Status> {
3821        use fidl::Peered;
3822        self.inner.channel().signal_peer(clear_mask, set_mask)
3823    }
3824}
3825
3826impl NetworkControlHandle {
3827    pub fn send_on_removed(
3828        &self,
3829        mut reason: fidl_fuchsia_net_virtualization::NetworkRemovalReason,
3830    ) -> Result<(), fidl::Error> {
3831        self.inner.send::<fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest>(
3832            (reason,),
3833            0,
3834            0xfe80656d1e5ec4a,
3835            fidl::encoding::DynamicFlags::empty(),
3836        )
3837    }
3838}
3839
3840#[must_use = "FIDL methods require a response to be sent"]
3841#[derive(Debug)]
3842pub struct NetworkGetConfigResponder {
3843    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
3844    tx_id: u32,
3845}
3846
3847/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
3848/// if the responder is dropped without sending a response, so that the client
3849/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3850impl std::ops::Drop for NetworkGetConfigResponder {
3851    fn drop(&mut self) {
3852        self.control_handle.shutdown();
3853        // Safety: drops once, never accessed again
3854        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3855    }
3856}
3857
3858impl fidl::endpoints::Responder for NetworkGetConfigResponder {
3859    type ControlHandle = NetworkControlHandle;
3860
3861    fn control_handle(&self) -> &NetworkControlHandle {
3862        &self.control_handle
3863    }
3864
3865    fn drop_without_shutdown(mut self) {
3866        // Safety: drops once, never accessed again due to mem::forget
3867        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3868        // Prevent Drop from running (which would shut down the channel)
3869        std::mem::forget(self);
3870    }
3871}
3872
3873impl NetworkGetConfigResponder {
3874    /// Sends a response to the FIDL transaction.
3875    ///
3876    /// Sets the channel to shutdown if an error occurs.
3877    pub fn send(self, mut config: &NetworkConfig) -> Result<(), fidl::Error> {
3878        let _result = self.send_raw(config);
3879        if _result.is_err() {
3880            self.control_handle.shutdown();
3881        }
3882        self.drop_without_shutdown();
3883        _result
3884    }
3885
3886    /// Similar to "send" but does not shutdown the channel if an error occurs.
3887    pub fn send_no_shutdown_on_err(self, mut config: &NetworkConfig) -> Result<(), fidl::Error> {
3888        let _result = self.send_raw(config);
3889        self.drop_without_shutdown();
3890        _result
3891    }
3892
3893    fn send_raw(&self, mut config: &NetworkConfig) -> Result<(), fidl::Error> {
3894        self.control_handle.inner.send::<NetworkGetConfigResponse>(
3895            (config,),
3896            self.tx_id,
3897            0x8dc04557e2ab069,
3898            fidl::encoding::DynamicFlags::empty(),
3899        )
3900    }
3901}
3902
3903#[must_use = "FIDL methods require a response to be sent"]
3904#[derive(Debug)]
3905pub struct NetworkGetNameResponder {
3906    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
3907    tx_id: u32,
3908}
3909
3910/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
3911/// if the responder is dropped without sending a response, so that the client
3912/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3913impl std::ops::Drop for NetworkGetNameResponder {
3914    fn drop(&mut self) {
3915        self.control_handle.shutdown();
3916        // Safety: drops once, never accessed again
3917        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3918    }
3919}
3920
3921impl fidl::endpoints::Responder for NetworkGetNameResponder {
3922    type ControlHandle = NetworkControlHandle;
3923
3924    fn control_handle(&self) -> &NetworkControlHandle {
3925        &self.control_handle
3926    }
3927
3928    fn drop_without_shutdown(mut self) {
3929        // Safety: drops once, never accessed again due to mem::forget
3930        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3931        // Prevent Drop from running (which would shut down the channel)
3932        std::mem::forget(self);
3933    }
3934}
3935
3936impl NetworkGetNameResponder {
3937    /// Sends a response to the FIDL transaction.
3938    ///
3939    /// Sets the channel to shutdown if an error occurs.
3940    pub fn send(self, mut name: &str) -> Result<(), fidl::Error> {
3941        let _result = self.send_raw(name);
3942        if _result.is_err() {
3943            self.control_handle.shutdown();
3944        }
3945        self.drop_without_shutdown();
3946        _result
3947    }
3948
3949    /// Similar to "send" but does not shutdown the channel if an error occurs.
3950    pub fn send_no_shutdown_on_err(self, mut name: &str) -> Result<(), fidl::Error> {
3951        let _result = self.send_raw(name);
3952        self.drop_without_shutdown();
3953        _result
3954    }
3955
3956    fn send_raw(&self, mut name: &str) -> Result<(), fidl::Error> {
3957        self.control_handle.inner.send::<NetworkGetNameResponse>(
3958            (name,),
3959            self.tx_id,
3960            0x57b7701d1ffeedb1,
3961            fidl::encoding::DynamicFlags::empty(),
3962        )
3963    }
3964}
3965
3966#[must_use = "FIDL methods require a response to be sent"]
3967#[derive(Debug)]
3968pub struct NetworkSetConfigResponder {
3969    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
3970    tx_id: u32,
3971}
3972
3973/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
3974/// if the responder is dropped without sending a response, so that the client
3975/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3976impl std::ops::Drop for NetworkSetConfigResponder {
3977    fn drop(&mut self) {
3978        self.control_handle.shutdown();
3979        // Safety: drops once, never accessed again
3980        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3981    }
3982}
3983
3984impl fidl::endpoints::Responder for NetworkSetConfigResponder {
3985    type ControlHandle = NetworkControlHandle;
3986
3987    fn control_handle(&self) -> &NetworkControlHandle {
3988        &self.control_handle
3989    }
3990
3991    fn drop_without_shutdown(mut self) {
3992        // Safety: drops once, never accessed again due to mem::forget
3993        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3994        // Prevent Drop from running (which would shut down the channel)
3995        std::mem::forget(self);
3996    }
3997}
3998
3999impl NetworkSetConfigResponder {
4000    /// Sends a response to the FIDL transaction.
4001    ///
4002    /// Sets the channel to shutdown if an error occurs.
4003    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
4004        let _result = self.send_raw(status);
4005        if _result.is_err() {
4006            self.control_handle.shutdown();
4007        }
4008        self.drop_without_shutdown();
4009        _result
4010    }
4011
4012    /// Similar to "send" but does not shutdown the channel if an error occurs.
4013    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
4014        let _result = self.send_raw(status);
4015        self.drop_without_shutdown();
4016        _result
4017    }
4018
4019    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
4020        self.control_handle.inner.send::<NetworkSetConfigResponse>(
4021            (status,),
4022            self.tx_id,
4023            0x18a490ee9d4bfa16,
4024            fidl::encoding::DynamicFlags::empty(),
4025        )
4026    }
4027}
4028
4029#[must_use = "FIDL methods require a response to be sent"]
4030#[derive(Debug)]
4031pub struct NetworkAttachEndpointResponder {
4032    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
4033    tx_id: u32,
4034}
4035
4036/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
4037/// if the responder is dropped without sending a response, so that the client
4038/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4039impl std::ops::Drop for NetworkAttachEndpointResponder {
4040    fn drop(&mut self) {
4041        self.control_handle.shutdown();
4042        // Safety: drops once, never accessed again
4043        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4044    }
4045}
4046
4047impl fidl::endpoints::Responder for NetworkAttachEndpointResponder {
4048    type ControlHandle = NetworkControlHandle;
4049
4050    fn control_handle(&self) -> &NetworkControlHandle {
4051        &self.control_handle
4052    }
4053
4054    fn drop_without_shutdown(mut self) {
4055        // Safety: drops once, never accessed again due to mem::forget
4056        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4057        // Prevent Drop from running (which would shut down the channel)
4058        std::mem::forget(self);
4059    }
4060}
4061
4062impl NetworkAttachEndpointResponder {
4063    /// Sends a response to the FIDL transaction.
4064    ///
4065    /// Sets the channel to shutdown if an error occurs.
4066    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
4067        let _result = self.send_raw(status);
4068        if _result.is_err() {
4069            self.control_handle.shutdown();
4070        }
4071        self.drop_without_shutdown();
4072        _result
4073    }
4074
4075    /// Similar to "send" but does not shutdown the channel if an error occurs.
4076    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
4077        let _result = self.send_raw(status);
4078        self.drop_without_shutdown();
4079        _result
4080    }
4081
4082    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
4083        self.control_handle.inner.send::<NetworkAttachEndpointResponse>(
4084            (status,),
4085            self.tx_id,
4086            0x6e8ff8e9ea1b9a98,
4087            fidl::encoding::DynamicFlags::empty(),
4088        )
4089    }
4090}
4091
4092#[must_use = "FIDL methods require a response to be sent"]
4093#[derive(Debug)]
4094pub struct NetworkRemoveEndpointResponder {
4095    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
4096    tx_id: u32,
4097}
4098
4099/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
4100/// if the responder is dropped without sending a response, so that the client
4101/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4102impl std::ops::Drop for NetworkRemoveEndpointResponder {
4103    fn drop(&mut self) {
4104        self.control_handle.shutdown();
4105        // Safety: drops once, never accessed again
4106        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4107    }
4108}
4109
4110impl fidl::endpoints::Responder for NetworkRemoveEndpointResponder {
4111    type ControlHandle = NetworkControlHandle;
4112
4113    fn control_handle(&self) -> &NetworkControlHandle {
4114        &self.control_handle
4115    }
4116
4117    fn drop_without_shutdown(mut self) {
4118        // Safety: drops once, never accessed again due to mem::forget
4119        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4120        // Prevent Drop from running (which would shut down the channel)
4121        std::mem::forget(self);
4122    }
4123}
4124
4125impl NetworkRemoveEndpointResponder {
4126    /// Sends a response to the FIDL transaction.
4127    ///
4128    /// Sets the channel to shutdown if an error occurs.
4129    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
4130        let _result = self.send_raw(status);
4131        if _result.is_err() {
4132            self.control_handle.shutdown();
4133        }
4134        self.drop_without_shutdown();
4135        _result
4136    }
4137
4138    /// Similar to "send" but does not shutdown the channel if an error occurs.
4139    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
4140        let _result = self.send_raw(status);
4141        self.drop_without_shutdown();
4142        _result
4143    }
4144
4145    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
4146        self.control_handle.inner.send::<NetworkRemoveEndpointResponse>(
4147            (status,),
4148            self.tx_id,
4149            0x298eaac56bfcdd25,
4150            fidl::encoding::DynamicFlags::empty(),
4151        )
4152    }
4153}
4154
4155#[must_use = "FIDL methods require a response to be sent"]
4156#[derive(Debug)]
4157pub struct NetworkStartCaptureResponder {
4158    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
4159    tx_id: u32,
4160}
4161
4162/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
4163/// if the responder is dropped without sending a response, so that the client
4164/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4165impl std::ops::Drop for NetworkStartCaptureResponder {
4166    fn drop(&mut self) {
4167        self.control_handle.shutdown();
4168        // Safety: drops once, never accessed again
4169        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4170    }
4171}
4172
4173impl fidl::endpoints::Responder for NetworkStartCaptureResponder {
4174    type ControlHandle = NetworkControlHandle;
4175
4176    fn control_handle(&self) -> &NetworkControlHandle {
4177        &self.control_handle
4178    }
4179
4180    fn drop_without_shutdown(mut self) {
4181        // Safety: drops once, never accessed again due to mem::forget
4182        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4183        // Prevent Drop from running (which would shut down the channel)
4184        std::mem::forget(self);
4185    }
4186}
4187
4188impl NetworkStartCaptureResponder {
4189    /// Sends a response to the FIDL transaction.
4190    ///
4191    /// Sets the channel to shutdown if an error occurs.
4192    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
4193        let _result = self.send_raw(status);
4194        if _result.is_err() {
4195            self.control_handle.shutdown();
4196        }
4197        self.drop_without_shutdown();
4198        _result
4199    }
4200
4201    /// Similar to "send" but does not shutdown the channel if an error occurs.
4202    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
4203        let _result = self.send_raw(status);
4204        self.drop_without_shutdown();
4205        _result
4206    }
4207
4208    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
4209        self.control_handle.inner.send::<NetworkStartCaptureResponse>(
4210            (status,),
4211            self.tx_id,
4212            0x3ca44940622932c,
4213            fidl::encoding::DynamicFlags::empty(),
4214        )
4215    }
4216}
4217
4218#[must_use = "FIDL methods require a response to be sent"]
4219#[derive(Debug)]
4220pub struct NetworkStopCaptureResponder {
4221    control_handle: std::mem::ManuallyDrop<NetworkControlHandle>,
4222    tx_id: u32,
4223}
4224
4225/// Set the the channel to be shutdown (see [`NetworkControlHandle::shutdown`])
4226/// if the responder is dropped without sending a response, so that the client
4227/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4228impl std::ops::Drop for NetworkStopCaptureResponder {
4229    fn drop(&mut self) {
4230        self.control_handle.shutdown();
4231        // Safety: drops once, never accessed again
4232        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4233    }
4234}
4235
4236impl fidl::endpoints::Responder for NetworkStopCaptureResponder {
4237    type ControlHandle = NetworkControlHandle;
4238
4239    fn control_handle(&self) -> &NetworkControlHandle {
4240        &self.control_handle
4241    }
4242
4243    fn drop_without_shutdown(mut self) {
4244        // Safety: drops once, never accessed again due to mem::forget
4245        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4246        // Prevent Drop from running (which would shut down the channel)
4247        std::mem::forget(self);
4248    }
4249}
4250
4251impl NetworkStopCaptureResponder {
4252    /// Sends a response to the FIDL transaction.
4253    ///
4254    /// Sets the channel to shutdown if an error occurs.
4255    pub fn send(self) -> Result<(), fidl::Error> {
4256        let _result = self.send_raw();
4257        if _result.is_err() {
4258            self.control_handle.shutdown();
4259        }
4260        self.drop_without_shutdown();
4261        _result
4262    }
4263
4264    /// Similar to "send" but does not shutdown the channel if an error occurs.
4265    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4266        let _result = self.send_raw();
4267        self.drop_without_shutdown();
4268        _result
4269    }
4270
4271    fn send_raw(&self) -> Result<(), fidl::Error> {
4272        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4273            (),
4274            self.tx_id,
4275            0x1d7827adad109468,
4276            fidl::encoding::DynamicFlags::empty(),
4277        )
4278    }
4279}
4280
4281#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
4282pub struct NetworkContextMarker;
4283
4284impl fidl::endpoints::ProtocolMarker for NetworkContextMarker {
4285    type Proxy = NetworkContextProxy;
4286    type RequestStream = NetworkContextRequestStream;
4287    #[cfg(target_os = "fuchsia")]
4288    type SynchronousProxy = NetworkContextSynchronousProxy;
4289
4290    const DEBUG_NAME: &'static str = "fuchsia.netemul.network.NetworkContext";
4291}
4292impl fidl::endpoints::DiscoverableProtocolMarker for NetworkContextMarker {}
4293
4294pub trait NetworkContextProxyInterface: Send + Sync {
4295    fn r#clone(
4296        &self,
4297        network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
4298    ) -> Result<(), fidl::Error>;
4299    fn r#get_network_manager(
4300        &self,
4301        net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
4302    ) -> Result<(), fidl::Error>;
4303    fn r#get_endpoint_manager(
4304        &self,
4305        endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
4306    ) -> Result<(), fidl::Error>;
4307    type SetupResponseFut: std::future::Future<
4308            Output = Result<
4309                (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
4310                fidl::Error,
4311            >,
4312        > + Send;
4313    fn r#setup(&self, networks: &[NetworkSetup]) -> Self::SetupResponseFut;
4314}
4315#[derive(Debug)]
4316#[cfg(target_os = "fuchsia")]
4317pub struct NetworkContextSynchronousProxy {
4318    client: fidl::client::sync::Client,
4319}
4320
4321#[cfg(target_os = "fuchsia")]
4322impl fidl::endpoints::SynchronousProxy for NetworkContextSynchronousProxy {
4323    type Proxy = NetworkContextProxy;
4324    type Protocol = NetworkContextMarker;
4325
4326    fn from_channel(inner: fidl::Channel) -> Self {
4327        Self::new(inner)
4328    }
4329
4330    fn into_channel(self) -> fidl::Channel {
4331        self.client.into_channel()
4332    }
4333
4334    fn as_channel(&self) -> &fidl::Channel {
4335        self.client.as_channel()
4336    }
4337}
4338
4339#[cfg(target_os = "fuchsia")]
4340impl NetworkContextSynchronousProxy {
4341    pub fn new(channel: fidl::Channel) -> Self {
4342        let protocol_name = <NetworkContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4343        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
4344    }
4345
4346    pub fn into_channel(self) -> fidl::Channel {
4347        self.client.into_channel()
4348    }
4349
4350    /// Waits until an event arrives and returns it. It is safe for other
4351    /// threads to make concurrent requests while waiting for an event.
4352    pub fn wait_for_event(
4353        &self,
4354        deadline: zx::MonotonicInstant,
4355    ) -> Result<NetworkContextEvent, fidl::Error> {
4356        NetworkContextEvent::decode(self.client.wait_for_event(deadline)?)
4357    }
4358
4359    pub fn r#clone(
4360        &self,
4361        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
4362    ) -> Result<(), fidl::Error> {
4363        self.client.send::<NetworkContextCloneRequest>(
4364            (network_context,),
4365            0x1f7eb1b78a2ad2b0,
4366            fidl::encoding::DynamicFlags::empty(),
4367        )
4368    }
4369
4370    pub fn r#get_network_manager(
4371        &self,
4372        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
4373    ) -> Result<(), fidl::Error> {
4374        self.client.send::<NetworkContextGetNetworkManagerRequest>(
4375            (net_manager,),
4376            0x379899a30766afd4,
4377            fidl::encoding::DynamicFlags::empty(),
4378        )
4379    }
4380
4381    pub fn r#get_endpoint_manager(
4382        &self,
4383        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
4384    ) -> Result<(), fidl::Error> {
4385        self.client.send::<NetworkContextGetEndpointManagerRequest>(
4386            (endp_manager,),
4387            0x5e64360363b9bd81,
4388            fidl::encoding::DynamicFlags::empty(),
4389        )
4390    }
4391
4392    /// Creates a collection of networks described by `networks`.
4393    /// `status` is `ZX_OK` for success
4394    /// `setup_handle` is a resource that references and maintains the lifecycle of
4395    ///                the created networks and endpoints.
4396    pub fn r#setup(
4397        &self,
4398        mut networks: &[NetworkSetup],
4399        ___deadline: zx::MonotonicInstant,
4400    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>), fidl::Error> {
4401        let _response =
4402            self.client.send_query::<NetworkContextSetupRequest, NetworkContextSetupResponse>(
4403                (networks,),
4404                0x1680e0b13823fc8c,
4405                fidl::encoding::DynamicFlags::empty(),
4406                ___deadline,
4407            )?;
4408        Ok((_response.status, _response.setup_handle))
4409    }
4410}
4411
4412#[cfg(target_os = "fuchsia")]
4413impl From<NetworkContextSynchronousProxy> for zx::Handle {
4414    fn from(value: NetworkContextSynchronousProxy) -> Self {
4415        value.into_channel().into()
4416    }
4417}
4418
4419#[cfg(target_os = "fuchsia")]
4420impl From<fidl::Channel> for NetworkContextSynchronousProxy {
4421    fn from(value: fidl::Channel) -> Self {
4422        Self::new(value)
4423    }
4424}
4425
4426#[cfg(target_os = "fuchsia")]
4427impl fidl::endpoints::FromClient for NetworkContextSynchronousProxy {
4428    type Protocol = NetworkContextMarker;
4429
4430    fn from_client(value: fidl::endpoints::ClientEnd<NetworkContextMarker>) -> Self {
4431        Self::new(value.into_channel())
4432    }
4433}
4434
4435#[derive(Debug, Clone)]
4436pub struct NetworkContextProxy {
4437    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
4438}
4439
4440impl fidl::endpoints::Proxy for NetworkContextProxy {
4441    type Protocol = NetworkContextMarker;
4442
4443    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
4444        Self::new(inner)
4445    }
4446
4447    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
4448        self.client.into_channel().map_err(|client| Self { client })
4449    }
4450
4451    fn as_channel(&self) -> &::fidl::AsyncChannel {
4452        self.client.as_channel()
4453    }
4454}
4455
4456impl NetworkContextProxy {
4457    /// Create a new Proxy for fuchsia.netemul.network/NetworkContext.
4458    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
4459        let protocol_name = <NetworkContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4460        Self { client: fidl::client::Client::new(channel, protocol_name) }
4461    }
4462
4463    /// Get a Stream of events from the remote end of the protocol.
4464    ///
4465    /// # Panics
4466    ///
4467    /// Panics if the event stream was already taken.
4468    pub fn take_event_stream(&self) -> NetworkContextEventStream {
4469        NetworkContextEventStream { event_receiver: self.client.take_event_receiver() }
4470    }
4471
4472    pub fn r#clone(
4473        &self,
4474        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
4475    ) -> Result<(), fidl::Error> {
4476        NetworkContextProxyInterface::r#clone(self, network_context)
4477    }
4478
4479    pub fn r#get_network_manager(
4480        &self,
4481        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
4482    ) -> Result<(), fidl::Error> {
4483        NetworkContextProxyInterface::r#get_network_manager(self, net_manager)
4484    }
4485
4486    pub fn r#get_endpoint_manager(
4487        &self,
4488        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
4489    ) -> Result<(), fidl::Error> {
4490        NetworkContextProxyInterface::r#get_endpoint_manager(self, endp_manager)
4491    }
4492
4493    /// Creates a collection of networks described by `networks`.
4494    /// `status` is `ZX_OK` for success
4495    /// `setup_handle` is a resource that references and maintains the lifecycle of
4496    ///                the created networks and endpoints.
4497    pub fn r#setup(
4498        &self,
4499        mut networks: &[NetworkSetup],
4500    ) -> fidl::client::QueryResponseFut<
4501        (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
4502        fidl::encoding::DefaultFuchsiaResourceDialect,
4503    > {
4504        NetworkContextProxyInterface::r#setup(self, networks)
4505    }
4506}
4507
4508impl NetworkContextProxyInterface for NetworkContextProxy {
4509    fn r#clone(
4510        &self,
4511        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
4512    ) -> Result<(), fidl::Error> {
4513        self.client.send::<NetworkContextCloneRequest>(
4514            (network_context,),
4515            0x1f7eb1b78a2ad2b0,
4516            fidl::encoding::DynamicFlags::empty(),
4517        )
4518    }
4519
4520    fn r#get_network_manager(
4521        &self,
4522        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
4523    ) -> Result<(), fidl::Error> {
4524        self.client.send::<NetworkContextGetNetworkManagerRequest>(
4525            (net_manager,),
4526            0x379899a30766afd4,
4527            fidl::encoding::DynamicFlags::empty(),
4528        )
4529    }
4530
4531    fn r#get_endpoint_manager(
4532        &self,
4533        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
4534    ) -> Result<(), fidl::Error> {
4535        self.client.send::<NetworkContextGetEndpointManagerRequest>(
4536            (endp_manager,),
4537            0x5e64360363b9bd81,
4538            fidl::encoding::DynamicFlags::empty(),
4539        )
4540    }
4541
4542    type SetupResponseFut = fidl::client::QueryResponseFut<
4543        (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
4544        fidl::encoding::DefaultFuchsiaResourceDialect,
4545    >;
4546    fn r#setup(&self, mut networks: &[NetworkSetup]) -> Self::SetupResponseFut {
4547        fn _decode(
4548            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4549        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>), fidl::Error>
4550        {
4551            let _response = fidl::client::decode_transaction_body::<
4552                NetworkContextSetupResponse,
4553                fidl::encoding::DefaultFuchsiaResourceDialect,
4554                0x1680e0b13823fc8c,
4555            >(_buf?)?;
4556            Ok((_response.status, _response.setup_handle))
4557        }
4558        self.client.send_query_and_decode::<
4559            NetworkContextSetupRequest,
4560            (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
4561        >(
4562            (networks,),
4563            0x1680e0b13823fc8c,
4564            fidl::encoding::DynamicFlags::empty(),
4565            _decode,
4566        )
4567    }
4568}
4569
4570pub struct NetworkContextEventStream {
4571    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
4572}
4573
4574impl std::marker::Unpin for NetworkContextEventStream {}
4575
4576impl futures::stream::FusedStream for NetworkContextEventStream {
4577    fn is_terminated(&self) -> bool {
4578        self.event_receiver.is_terminated()
4579    }
4580}
4581
4582impl futures::Stream for NetworkContextEventStream {
4583    type Item = Result<NetworkContextEvent, fidl::Error>;
4584
4585    fn poll_next(
4586        mut self: std::pin::Pin<&mut Self>,
4587        cx: &mut std::task::Context<'_>,
4588    ) -> std::task::Poll<Option<Self::Item>> {
4589        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
4590            &mut self.event_receiver,
4591            cx
4592        )?) {
4593            Some(buf) => std::task::Poll::Ready(Some(NetworkContextEvent::decode(buf))),
4594            None => std::task::Poll::Ready(None),
4595        }
4596    }
4597}
4598
4599#[derive(Debug)]
4600pub enum NetworkContextEvent {}
4601
4602impl NetworkContextEvent {
4603    /// Decodes a message buffer as a [`NetworkContextEvent`].
4604    fn decode(
4605        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
4606    ) -> Result<NetworkContextEvent, fidl::Error> {
4607        let (bytes, _handles) = buf.split_mut();
4608        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
4609        debug_assert_eq!(tx_header.tx_id, 0);
4610        match tx_header.ordinal {
4611            _ => Err(fidl::Error::UnknownOrdinal {
4612                ordinal: tx_header.ordinal,
4613                protocol_name:
4614                    <NetworkContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
4615            }),
4616        }
4617    }
4618}
4619
4620/// A Stream of incoming requests for fuchsia.netemul.network/NetworkContext.
4621pub struct NetworkContextRequestStream {
4622    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
4623    is_terminated: bool,
4624}
4625
4626impl std::marker::Unpin for NetworkContextRequestStream {}
4627
4628impl futures::stream::FusedStream for NetworkContextRequestStream {
4629    fn is_terminated(&self) -> bool {
4630        self.is_terminated
4631    }
4632}
4633
4634impl fidl::endpoints::RequestStream for NetworkContextRequestStream {
4635    type Protocol = NetworkContextMarker;
4636    type ControlHandle = NetworkContextControlHandle;
4637
4638    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
4639        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
4640    }
4641
4642    fn control_handle(&self) -> Self::ControlHandle {
4643        NetworkContextControlHandle { inner: self.inner.clone() }
4644    }
4645
4646    fn into_inner(
4647        self,
4648    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
4649    {
4650        (self.inner, self.is_terminated)
4651    }
4652
4653    fn from_inner(
4654        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
4655        is_terminated: bool,
4656    ) -> Self {
4657        Self { inner, is_terminated }
4658    }
4659}
4660
4661impl futures::Stream for NetworkContextRequestStream {
4662    type Item = Result<NetworkContextRequest, fidl::Error>;
4663
4664    fn poll_next(
4665        mut self: std::pin::Pin<&mut Self>,
4666        cx: &mut std::task::Context<'_>,
4667    ) -> std::task::Poll<Option<Self::Item>> {
4668        let this = &mut *self;
4669        if this.inner.check_shutdown(cx) {
4670            this.is_terminated = true;
4671            return std::task::Poll::Ready(None);
4672        }
4673        if this.is_terminated {
4674            panic!("polled NetworkContextRequestStream after completion");
4675        }
4676        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
4677            |bytes, handles| {
4678                match this.inner.channel().read_etc(cx, bytes, handles) {
4679                    std::task::Poll::Ready(Ok(())) => {}
4680                    std::task::Poll::Pending => return std::task::Poll::Pending,
4681                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
4682                        this.is_terminated = true;
4683                        return std::task::Poll::Ready(None);
4684                    }
4685                    std::task::Poll::Ready(Err(e)) => {
4686                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
4687                            e.into(),
4688                        ))))
4689                    }
4690                }
4691
4692                // A message has been received from the channel
4693                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
4694
4695                std::task::Poll::Ready(Some(match header.ordinal {
4696                    0x1f7eb1b78a2ad2b0 => {
4697                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
4698                        let mut req = fidl::new_empty!(
4699                            NetworkContextCloneRequest,
4700                            fidl::encoding::DefaultFuchsiaResourceDialect
4701                        );
4702                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextCloneRequest>(&header, _body_bytes, handles, &mut req)?;
4703                        let control_handle =
4704                            NetworkContextControlHandle { inner: this.inner.clone() };
4705                        Ok(NetworkContextRequest::Clone {
4706                            network_context: req.network_context,
4707
4708                            control_handle,
4709                        })
4710                    }
4711                    0x379899a30766afd4 => {
4712                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
4713                        let mut req = fidl::new_empty!(
4714                            NetworkContextGetNetworkManagerRequest,
4715                            fidl::encoding::DefaultFuchsiaResourceDialect
4716                        );
4717                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextGetNetworkManagerRequest>(&header, _body_bytes, handles, &mut req)?;
4718                        let control_handle =
4719                            NetworkContextControlHandle { inner: this.inner.clone() };
4720                        Ok(NetworkContextRequest::GetNetworkManager {
4721                            net_manager: req.net_manager,
4722
4723                            control_handle,
4724                        })
4725                    }
4726                    0x5e64360363b9bd81 => {
4727                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
4728                        let mut req = fidl::new_empty!(
4729                            NetworkContextGetEndpointManagerRequest,
4730                            fidl::encoding::DefaultFuchsiaResourceDialect
4731                        );
4732                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextGetEndpointManagerRequest>(&header, _body_bytes, handles, &mut req)?;
4733                        let control_handle =
4734                            NetworkContextControlHandle { inner: this.inner.clone() };
4735                        Ok(NetworkContextRequest::GetEndpointManager {
4736                            endp_manager: req.endp_manager,
4737
4738                            control_handle,
4739                        })
4740                    }
4741                    0x1680e0b13823fc8c => {
4742                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
4743                        let mut req = fidl::new_empty!(
4744                            NetworkContextSetupRequest,
4745                            fidl::encoding::DefaultFuchsiaResourceDialect
4746                        );
4747                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextSetupRequest>(&header, _body_bytes, handles, &mut req)?;
4748                        let control_handle =
4749                            NetworkContextControlHandle { inner: this.inner.clone() };
4750                        Ok(NetworkContextRequest::Setup {
4751                            networks: req.networks,
4752
4753                            responder: NetworkContextSetupResponder {
4754                                control_handle: std::mem::ManuallyDrop::new(control_handle),
4755                                tx_id: header.tx_id,
4756                            },
4757                        })
4758                    }
4759                    _ => Err(fidl::Error::UnknownOrdinal {
4760                        ordinal: header.ordinal,
4761                        protocol_name:
4762                            <NetworkContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
4763                    }),
4764                }))
4765            },
4766        )
4767    }
4768}
4769
4770/// Main entry point to manage virtual networks and endpoints.
4771///
4772/// Every new connection to NetworkContext provides access to a an isolated
4773/// namespace for networks and endpoints. `Clone` is the only means by which a
4774/// client can acquire a new connection to the same network context.
4775#[derive(Debug)]
4776pub enum NetworkContextRequest {
4777    Clone {
4778        network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
4779        control_handle: NetworkContextControlHandle,
4780    },
4781    GetNetworkManager {
4782        net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
4783        control_handle: NetworkContextControlHandle,
4784    },
4785    GetEndpointManager {
4786        endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
4787        control_handle: NetworkContextControlHandle,
4788    },
4789    /// Creates a collection of networks described by `networks`.
4790    /// `status` is `ZX_OK` for success
4791    /// `setup_handle` is a resource that references and maintains the lifecycle of
4792    ///                the created networks and endpoints.
4793    Setup { networks: Vec<NetworkSetup>, responder: NetworkContextSetupResponder },
4794}
4795
4796impl NetworkContextRequest {
4797    #[allow(irrefutable_let_patterns)]
4798    pub fn into_clone(
4799        self,
4800    ) -> Option<(fidl::endpoints::ServerEnd<NetworkContextMarker>, NetworkContextControlHandle)>
4801    {
4802        if let NetworkContextRequest::Clone { network_context, control_handle } = self {
4803            Some((network_context, control_handle))
4804        } else {
4805            None
4806        }
4807    }
4808
4809    #[allow(irrefutable_let_patterns)]
4810    pub fn into_get_network_manager(
4811        self,
4812    ) -> Option<(fidl::endpoints::ServerEnd<NetworkManagerMarker>, NetworkContextControlHandle)>
4813    {
4814        if let NetworkContextRequest::GetNetworkManager { net_manager, control_handle } = self {
4815            Some((net_manager, control_handle))
4816        } else {
4817            None
4818        }
4819    }
4820
4821    #[allow(irrefutable_let_patterns)]
4822    pub fn into_get_endpoint_manager(
4823        self,
4824    ) -> Option<(fidl::endpoints::ServerEnd<EndpointManagerMarker>, NetworkContextControlHandle)>
4825    {
4826        if let NetworkContextRequest::GetEndpointManager { endp_manager, control_handle } = self {
4827            Some((endp_manager, control_handle))
4828        } else {
4829            None
4830        }
4831    }
4832
4833    #[allow(irrefutable_let_patterns)]
4834    pub fn into_setup(self) -> Option<(Vec<NetworkSetup>, NetworkContextSetupResponder)> {
4835        if let NetworkContextRequest::Setup { networks, responder } = self {
4836            Some((networks, responder))
4837        } else {
4838            None
4839        }
4840    }
4841
4842    /// Name of the method defined in FIDL
4843    pub fn method_name(&self) -> &'static str {
4844        match *self {
4845            NetworkContextRequest::Clone { .. } => "clone",
4846            NetworkContextRequest::GetNetworkManager { .. } => "get_network_manager",
4847            NetworkContextRequest::GetEndpointManager { .. } => "get_endpoint_manager",
4848            NetworkContextRequest::Setup { .. } => "setup",
4849        }
4850    }
4851}
4852
4853#[derive(Debug, Clone)]
4854pub struct NetworkContextControlHandle {
4855    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
4856}
4857
4858impl fidl::endpoints::ControlHandle for NetworkContextControlHandle {
4859    fn shutdown(&self) {
4860        self.inner.shutdown()
4861    }
4862    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
4863        self.inner.shutdown_with_epitaph(status)
4864    }
4865
4866    fn is_closed(&self) -> bool {
4867        self.inner.channel().is_closed()
4868    }
4869    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
4870        self.inner.channel().on_closed()
4871    }
4872
4873    #[cfg(target_os = "fuchsia")]
4874    fn signal_peer(
4875        &self,
4876        clear_mask: zx::Signals,
4877        set_mask: zx::Signals,
4878    ) -> Result<(), zx_status::Status> {
4879        use fidl::Peered;
4880        self.inner.channel().signal_peer(clear_mask, set_mask)
4881    }
4882}
4883
4884impl NetworkContextControlHandle {}
4885
4886#[must_use = "FIDL methods require a response to be sent"]
4887#[derive(Debug)]
4888pub struct NetworkContextSetupResponder {
4889    control_handle: std::mem::ManuallyDrop<NetworkContextControlHandle>,
4890    tx_id: u32,
4891}
4892
4893/// Set the the channel to be shutdown (see [`NetworkContextControlHandle::shutdown`])
4894/// if the responder is dropped without sending a response, so that the client
4895/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4896impl std::ops::Drop for NetworkContextSetupResponder {
4897    fn drop(&mut self) {
4898        self.control_handle.shutdown();
4899        // Safety: drops once, never accessed again
4900        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4901    }
4902}
4903
4904impl fidl::endpoints::Responder for NetworkContextSetupResponder {
4905    type ControlHandle = NetworkContextControlHandle;
4906
4907    fn control_handle(&self) -> &NetworkContextControlHandle {
4908        &self.control_handle
4909    }
4910
4911    fn drop_without_shutdown(mut self) {
4912        // Safety: drops once, never accessed again due to mem::forget
4913        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4914        // Prevent Drop from running (which would shut down the channel)
4915        std::mem::forget(self);
4916    }
4917}
4918
4919impl NetworkContextSetupResponder {
4920    /// Sends a response to the FIDL transaction.
4921    ///
4922    /// Sets the channel to shutdown if an error occurs.
4923    pub fn send(
4924        self,
4925        mut status: i32,
4926        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
4927    ) -> Result<(), fidl::Error> {
4928        let _result = self.send_raw(status, setup_handle);
4929        if _result.is_err() {
4930            self.control_handle.shutdown();
4931        }
4932        self.drop_without_shutdown();
4933        _result
4934    }
4935
4936    /// Similar to "send" but does not shutdown the channel if an error occurs.
4937    pub fn send_no_shutdown_on_err(
4938        self,
4939        mut status: i32,
4940        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
4941    ) -> Result<(), fidl::Error> {
4942        let _result = self.send_raw(status, setup_handle);
4943        self.drop_without_shutdown();
4944        _result
4945    }
4946
4947    fn send_raw(
4948        &self,
4949        mut status: i32,
4950        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
4951    ) -> Result<(), fidl::Error> {
4952        self.control_handle.inner.send::<NetworkContextSetupResponse>(
4953            (status, setup_handle),
4954            self.tx_id,
4955            0x1680e0b13823fc8c,
4956            fidl::encoding::DynamicFlags::empty(),
4957        )
4958    }
4959}
4960
4961#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
4962pub struct NetworkManagerMarker;
4963
4964impl fidl::endpoints::ProtocolMarker for NetworkManagerMarker {
4965    type Proxy = NetworkManagerProxy;
4966    type RequestStream = NetworkManagerRequestStream;
4967    #[cfg(target_os = "fuchsia")]
4968    type SynchronousProxy = NetworkManagerSynchronousProxy;
4969
4970    const DEBUG_NAME: &'static str = "(anonymous) NetworkManager";
4971}
4972
4973pub trait NetworkManagerProxyInterface: Send + Sync {
4974    type ListNetworksResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
4975        + Send;
4976    fn r#list_networks(&self) -> Self::ListNetworksResponseFut;
4977    type CreateNetworkResponseFut: std::future::Future<
4978            Output = Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error>,
4979        > + Send;
4980    fn r#create_network(
4981        &self,
4982        name: &str,
4983        config: &NetworkConfig,
4984    ) -> Self::CreateNetworkResponseFut;
4985    type GetNetworkResponseFut: std::future::Future<
4986            Output = Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error>,
4987        > + Send;
4988    fn r#get_network(&self, name: &str) -> Self::GetNetworkResponseFut;
4989}
4990#[derive(Debug)]
4991#[cfg(target_os = "fuchsia")]
4992pub struct NetworkManagerSynchronousProxy {
4993    client: fidl::client::sync::Client,
4994}
4995
4996#[cfg(target_os = "fuchsia")]
4997impl fidl::endpoints::SynchronousProxy for NetworkManagerSynchronousProxy {
4998    type Proxy = NetworkManagerProxy;
4999    type Protocol = NetworkManagerMarker;
5000
5001    fn from_channel(inner: fidl::Channel) -> Self {
5002        Self::new(inner)
5003    }
5004
5005    fn into_channel(self) -> fidl::Channel {
5006        self.client.into_channel()
5007    }
5008
5009    fn as_channel(&self) -> &fidl::Channel {
5010        self.client.as_channel()
5011    }
5012}
5013
5014#[cfg(target_os = "fuchsia")]
5015impl NetworkManagerSynchronousProxy {
5016    pub fn new(channel: fidl::Channel) -> Self {
5017        let protocol_name = <NetworkManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
5018        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
5019    }
5020
5021    pub fn into_channel(self) -> fidl::Channel {
5022        self.client.into_channel()
5023    }
5024
5025    /// Waits until an event arrives and returns it. It is safe for other
5026    /// threads to make concurrent requests while waiting for an event.
5027    pub fn wait_for_event(
5028        &self,
5029        deadline: zx::MonotonicInstant,
5030    ) -> Result<NetworkManagerEvent, fidl::Error> {
5031        NetworkManagerEvent::decode(self.client.wait_for_event(deadline)?)
5032    }
5033
5034    /// Lists emulated networks by name.
5035    pub fn r#list_networks(
5036        &self,
5037        ___deadline: zx::MonotonicInstant,
5038    ) -> Result<Vec<String>, fidl::Error> {
5039        let _response = self
5040            .client
5041            .send_query::<fidl::encoding::EmptyPayload, NetworkManagerListNetworksResponse>(
5042                (),
5043                0x2488653e0974cc62,
5044                fidl::encoding::DynamicFlags::empty(),
5045                ___deadline,
5046            )?;
5047        Ok(_response.nets)
5048    }
5049
5050    /// Creates a new network with given name and config.
5051    pub fn r#create_network(
5052        &self,
5053        mut name: &str,
5054        mut config: &NetworkConfig,
5055        ___deadline: zx::MonotonicInstant,
5056    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error> {
5057        let _response = self
5058            .client
5059            .send_query::<NetworkManagerCreateNetworkRequest, NetworkManagerCreateNetworkResponse>(
5060                (name, config),
5061                0x6052eb5ac709af,
5062                fidl::encoding::DynamicFlags::empty(),
5063                ___deadline,
5064            )?;
5065        Ok((_response.status, _response.net))
5066    }
5067
5068    /// Gets a handle to a network.
5069    pub fn r#get_network(
5070        &self,
5071        mut name: &str,
5072        ___deadline: zx::MonotonicInstant,
5073    ) -> Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error> {
5074        let _response = self
5075            .client
5076            .send_query::<NetworkManagerGetNetworkRequest, NetworkManagerGetNetworkResponse>(
5077                (name,),
5078                0x59930bf23acc7d9a,
5079                fidl::encoding::DynamicFlags::empty(),
5080                ___deadline,
5081            )?;
5082        Ok(_response.net)
5083    }
5084}
5085
5086#[cfg(target_os = "fuchsia")]
5087impl From<NetworkManagerSynchronousProxy> for zx::Handle {
5088    fn from(value: NetworkManagerSynchronousProxy) -> Self {
5089        value.into_channel().into()
5090    }
5091}
5092
5093#[cfg(target_os = "fuchsia")]
5094impl From<fidl::Channel> for NetworkManagerSynchronousProxy {
5095    fn from(value: fidl::Channel) -> Self {
5096        Self::new(value)
5097    }
5098}
5099
5100#[cfg(target_os = "fuchsia")]
5101impl fidl::endpoints::FromClient for NetworkManagerSynchronousProxy {
5102    type Protocol = NetworkManagerMarker;
5103
5104    fn from_client(value: fidl::endpoints::ClientEnd<NetworkManagerMarker>) -> Self {
5105        Self::new(value.into_channel())
5106    }
5107}
5108
5109#[derive(Debug, Clone)]
5110pub struct NetworkManagerProxy {
5111    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
5112}
5113
5114impl fidl::endpoints::Proxy for NetworkManagerProxy {
5115    type Protocol = NetworkManagerMarker;
5116
5117    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
5118        Self::new(inner)
5119    }
5120
5121    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
5122        self.client.into_channel().map_err(|client| Self { client })
5123    }
5124
5125    fn as_channel(&self) -> &::fidl::AsyncChannel {
5126        self.client.as_channel()
5127    }
5128}
5129
5130impl NetworkManagerProxy {
5131    /// Create a new Proxy for fuchsia.netemul.network/NetworkManager.
5132    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
5133        let protocol_name = <NetworkManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
5134        Self { client: fidl::client::Client::new(channel, protocol_name) }
5135    }
5136
5137    /// Get a Stream of events from the remote end of the protocol.
5138    ///
5139    /// # Panics
5140    ///
5141    /// Panics if the event stream was already taken.
5142    pub fn take_event_stream(&self) -> NetworkManagerEventStream {
5143        NetworkManagerEventStream { event_receiver: self.client.take_event_receiver() }
5144    }
5145
5146    /// Lists emulated networks by name.
5147    pub fn r#list_networks(
5148        &self,
5149    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
5150    {
5151        NetworkManagerProxyInterface::r#list_networks(self)
5152    }
5153
5154    /// Creates a new network with given name and config.
5155    pub fn r#create_network(
5156        &self,
5157        mut name: &str,
5158        mut config: &NetworkConfig,
5159    ) -> fidl::client::QueryResponseFut<
5160        (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
5161        fidl::encoding::DefaultFuchsiaResourceDialect,
5162    > {
5163        NetworkManagerProxyInterface::r#create_network(self, name, config)
5164    }
5165
5166    /// Gets a handle to a network.
5167    pub fn r#get_network(
5168        &self,
5169        mut name: &str,
5170    ) -> fidl::client::QueryResponseFut<
5171        Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5172        fidl::encoding::DefaultFuchsiaResourceDialect,
5173    > {
5174        NetworkManagerProxyInterface::r#get_network(self, name)
5175    }
5176}
5177
5178impl NetworkManagerProxyInterface for NetworkManagerProxy {
5179    type ListNetworksResponseFut =
5180        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
5181    fn r#list_networks(&self) -> Self::ListNetworksResponseFut {
5182        fn _decode(
5183            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5184        ) -> Result<Vec<String>, fidl::Error> {
5185            let _response = fidl::client::decode_transaction_body::<
5186                NetworkManagerListNetworksResponse,
5187                fidl::encoding::DefaultFuchsiaResourceDialect,
5188                0x2488653e0974cc62,
5189            >(_buf?)?;
5190            Ok(_response.nets)
5191        }
5192        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
5193            (),
5194            0x2488653e0974cc62,
5195            fidl::encoding::DynamicFlags::empty(),
5196            _decode,
5197        )
5198    }
5199
5200    type CreateNetworkResponseFut = fidl::client::QueryResponseFut<
5201        (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
5202        fidl::encoding::DefaultFuchsiaResourceDialect,
5203    >;
5204    fn r#create_network(
5205        &self,
5206        mut name: &str,
5207        mut config: &NetworkConfig,
5208    ) -> Self::CreateNetworkResponseFut {
5209        fn _decode(
5210            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5211        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error> {
5212            let _response = fidl::client::decode_transaction_body::<
5213                NetworkManagerCreateNetworkResponse,
5214                fidl::encoding::DefaultFuchsiaResourceDialect,
5215                0x6052eb5ac709af,
5216            >(_buf?)?;
5217            Ok((_response.status, _response.net))
5218        }
5219        self.client.send_query_and_decode::<
5220            NetworkManagerCreateNetworkRequest,
5221            (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
5222        >(
5223            (name, config,),
5224            0x6052eb5ac709af,
5225            fidl::encoding::DynamicFlags::empty(),
5226            _decode,
5227        )
5228    }
5229
5230    type GetNetworkResponseFut = fidl::client::QueryResponseFut<
5231        Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5232        fidl::encoding::DefaultFuchsiaResourceDialect,
5233    >;
5234    fn r#get_network(&self, mut name: &str) -> Self::GetNetworkResponseFut {
5235        fn _decode(
5236            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5237        ) -> Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error> {
5238            let _response = fidl::client::decode_transaction_body::<
5239                NetworkManagerGetNetworkResponse,
5240                fidl::encoding::DefaultFuchsiaResourceDialect,
5241                0x59930bf23acc7d9a,
5242            >(_buf?)?;
5243            Ok(_response.net)
5244        }
5245        self.client.send_query_and_decode::<
5246            NetworkManagerGetNetworkRequest,
5247            Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5248        >(
5249            (name,),
5250            0x59930bf23acc7d9a,
5251            fidl::encoding::DynamicFlags::empty(),
5252            _decode,
5253        )
5254    }
5255}
5256
5257pub struct NetworkManagerEventStream {
5258    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5259}
5260
5261impl std::marker::Unpin for NetworkManagerEventStream {}
5262
5263impl futures::stream::FusedStream for NetworkManagerEventStream {
5264    fn is_terminated(&self) -> bool {
5265        self.event_receiver.is_terminated()
5266    }
5267}
5268
5269impl futures::Stream for NetworkManagerEventStream {
5270    type Item = Result<NetworkManagerEvent, fidl::Error>;
5271
5272    fn poll_next(
5273        mut self: std::pin::Pin<&mut Self>,
5274        cx: &mut std::task::Context<'_>,
5275    ) -> std::task::Poll<Option<Self::Item>> {
5276        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5277            &mut self.event_receiver,
5278            cx
5279        )?) {
5280            Some(buf) => std::task::Poll::Ready(Some(NetworkManagerEvent::decode(buf))),
5281            None => std::task::Poll::Ready(None),
5282        }
5283    }
5284}
5285
5286#[derive(Debug)]
5287pub enum NetworkManagerEvent {}
5288
5289impl NetworkManagerEvent {
5290    /// Decodes a message buffer as a [`NetworkManagerEvent`].
5291    fn decode(
5292        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5293    ) -> Result<NetworkManagerEvent, fidl::Error> {
5294        let (bytes, _handles) = buf.split_mut();
5295        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5296        debug_assert_eq!(tx_header.tx_id, 0);
5297        match tx_header.ordinal {
5298            _ => Err(fidl::Error::UnknownOrdinal {
5299                ordinal: tx_header.ordinal,
5300                protocol_name:
5301                    <NetworkManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5302            }),
5303        }
5304    }
5305}
5306
5307/// A Stream of incoming requests for fuchsia.netemul.network/NetworkManager.
5308pub struct NetworkManagerRequestStream {
5309    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5310    is_terminated: bool,
5311}
5312
5313impl std::marker::Unpin for NetworkManagerRequestStream {}
5314
5315impl futures::stream::FusedStream for NetworkManagerRequestStream {
5316    fn is_terminated(&self) -> bool {
5317        self.is_terminated
5318    }
5319}
5320
5321impl fidl::endpoints::RequestStream for NetworkManagerRequestStream {
5322    type Protocol = NetworkManagerMarker;
5323    type ControlHandle = NetworkManagerControlHandle;
5324
5325    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5326        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5327    }
5328
5329    fn control_handle(&self) -> Self::ControlHandle {
5330        NetworkManagerControlHandle { inner: self.inner.clone() }
5331    }
5332
5333    fn into_inner(
5334        self,
5335    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5336    {
5337        (self.inner, self.is_terminated)
5338    }
5339
5340    fn from_inner(
5341        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5342        is_terminated: bool,
5343    ) -> Self {
5344        Self { inner, is_terminated }
5345    }
5346}
5347
5348impl futures::Stream for NetworkManagerRequestStream {
5349    type Item = Result<NetworkManagerRequest, fidl::Error>;
5350
5351    fn poll_next(
5352        mut self: std::pin::Pin<&mut Self>,
5353        cx: &mut std::task::Context<'_>,
5354    ) -> std::task::Poll<Option<Self::Item>> {
5355        let this = &mut *self;
5356        if this.inner.check_shutdown(cx) {
5357            this.is_terminated = true;
5358            return std::task::Poll::Ready(None);
5359        }
5360        if this.is_terminated {
5361            panic!("polled NetworkManagerRequestStream after completion");
5362        }
5363        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5364            |bytes, handles| {
5365                match this.inner.channel().read_etc(cx, bytes, handles) {
5366                    std::task::Poll::Ready(Ok(())) => {}
5367                    std::task::Poll::Pending => return std::task::Poll::Pending,
5368                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5369                        this.is_terminated = true;
5370                        return std::task::Poll::Ready(None);
5371                    }
5372                    std::task::Poll::Ready(Err(e)) => {
5373                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5374                            e.into(),
5375                        ))))
5376                    }
5377                }
5378
5379                // A message has been received from the channel
5380                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5381
5382                std::task::Poll::Ready(Some(match header.ordinal {
5383                    0x2488653e0974cc62 => {
5384                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5385                        let mut req = fidl::new_empty!(
5386                            fidl::encoding::EmptyPayload,
5387                            fidl::encoding::DefaultFuchsiaResourceDialect
5388                        );
5389                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5390                        let control_handle =
5391                            NetworkManagerControlHandle { inner: this.inner.clone() };
5392                        Ok(NetworkManagerRequest::ListNetworks {
5393                            responder: NetworkManagerListNetworksResponder {
5394                                control_handle: std::mem::ManuallyDrop::new(control_handle),
5395                                tx_id: header.tx_id,
5396                            },
5397                        })
5398                    }
5399                    0x6052eb5ac709af => {
5400                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5401                        let mut req = fidl::new_empty!(
5402                            NetworkManagerCreateNetworkRequest,
5403                            fidl::encoding::DefaultFuchsiaResourceDialect
5404                        );
5405                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkManagerCreateNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
5406                        let control_handle =
5407                            NetworkManagerControlHandle { inner: this.inner.clone() };
5408                        Ok(NetworkManagerRequest::CreateNetwork {
5409                            name: req.name,
5410                            config: req.config,
5411
5412                            responder: NetworkManagerCreateNetworkResponder {
5413                                control_handle: std::mem::ManuallyDrop::new(control_handle),
5414                                tx_id: header.tx_id,
5415                            },
5416                        })
5417                    }
5418                    0x59930bf23acc7d9a => {
5419                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5420                        let mut req = fidl::new_empty!(
5421                            NetworkManagerGetNetworkRequest,
5422                            fidl::encoding::DefaultFuchsiaResourceDialect
5423                        );
5424                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkManagerGetNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
5425                        let control_handle =
5426                            NetworkManagerControlHandle { inner: this.inner.clone() };
5427                        Ok(NetworkManagerRequest::GetNetwork {
5428                            name: req.name,
5429
5430                            responder: NetworkManagerGetNetworkResponder {
5431                                control_handle: std::mem::ManuallyDrop::new(control_handle),
5432                                tx_id: header.tx_id,
5433                            },
5434                        })
5435                    }
5436                    _ => Err(fidl::Error::UnknownOrdinal {
5437                        ordinal: header.ordinal,
5438                        protocol_name:
5439                            <NetworkManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5440                    }),
5441                }))
5442            },
5443        )
5444    }
5445}
5446
5447/// Manages virtual networks.
5448#[derive(Debug)]
5449pub enum NetworkManagerRequest {
5450    /// Lists emulated networks by name.
5451    ListNetworks { responder: NetworkManagerListNetworksResponder },
5452    /// Creates a new network with given name and config.
5453    CreateNetwork {
5454        name: String,
5455        config: NetworkConfig,
5456        responder: NetworkManagerCreateNetworkResponder,
5457    },
5458    /// Gets a handle to a network.
5459    GetNetwork { name: String, responder: NetworkManagerGetNetworkResponder },
5460}
5461
5462impl NetworkManagerRequest {
5463    #[allow(irrefutable_let_patterns)]
5464    pub fn into_list_networks(self) -> Option<(NetworkManagerListNetworksResponder)> {
5465        if let NetworkManagerRequest::ListNetworks { responder } = self {
5466            Some((responder))
5467        } else {
5468            None
5469        }
5470    }
5471
5472    #[allow(irrefutable_let_patterns)]
5473    pub fn into_create_network(
5474        self,
5475    ) -> Option<(String, NetworkConfig, NetworkManagerCreateNetworkResponder)> {
5476        if let NetworkManagerRequest::CreateNetwork { name, config, responder } = self {
5477            Some((name, config, responder))
5478        } else {
5479            None
5480        }
5481    }
5482
5483    #[allow(irrefutable_let_patterns)]
5484    pub fn into_get_network(self) -> Option<(String, NetworkManagerGetNetworkResponder)> {
5485        if let NetworkManagerRequest::GetNetwork { name, responder } = self {
5486            Some((name, responder))
5487        } else {
5488            None
5489        }
5490    }
5491
5492    /// Name of the method defined in FIDL
5493    pub fn method_name(&self) -> &'static str {
5494        match *self {
5495            NetworkManagerRequest::ListNetworks { .. } => "list_networks",
5496            NetworkManagerRequest::CreateNetwork { .. } => "create_network",
5497            NetworkManagerRequest::GetNetwork { .. } => "get_network",
5498        }
5499    }
5500}
5501
5502#[derive(Debug, Clone)]
5503pub struct NetworkManagerControlHandle {
5504    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5505}
5506
5507impl fidl::endpoints::ControlHandle for NetworkManagerControlHandle {
5508    fn shutdown(&self) {
5509        self.inner.shutdown()
5510    }
5511    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
5512        self.inner.shutdown_with_epitaph(status)
5513    }
5514
5515    fn is_closed(&self) -> bool {
5516        self.inner.channel().is_closed()
5517    }
5518    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
5519        self.inner.channel().on_closed()
5520    }
5521
5522    #[cfg(target_os = "fuchsia")]
5523    fn signal_peer(
5524        &self,
5525        clear_mask: zx::Signals,
5526        set_mask: zx::Signals,
5527    ) -> Result<(), zx_status::Status> {
5528        use fidl::Peered;
5529        self.inner.channel().signal_peer(clear_mask, set_mask)
5530    }
5531}
5532
5533impl NetworkManagerControlHandle {}
5534
5535#[must_use = "FIDL methods require a response to be sent"]
5536#[derive(Debug)]
5537pub struct NetworkManagerListNetworksResponder {
5538    control_handle: std::mem::ManuallyDrop<NetworkManagerControlHandle>,
5539    tx_id: u32,
5540}
5541
5542/// Set the the channel to be shutdown (see [`NetworkManagerControlHandle::shutdown`])
5543/// if the responder is dropped without sending a response, so that the client
5544/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5545impl std::ops::Drop for NetworkManagerListNetworksResponder {
5546    fn drop(&mut self) {
5547        self.control_handle.shutdown();
5548        // Safety: drops once, never accessed again
5549        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5550    }
5551}
5552
5553impl fidl::endpoints::Responder for NetworkManagerListNetworksResponder {
5554    type ControlHandle = NetworkManagerControlHandle;
5555
5556    fn control_handle(&self) -> &NetworkManagerControlHandle {
5557        &self.control_handle
5558    }
5559
5560    fn drop_without_shutdown(mut self) {
5561        // Safety: drops once, never accessed again due to mem::forget
5562        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5563        // Prevent Drop from running (which would shut down the channel)
5564        std::mem::forget(self);
5565    }
5566}
5567
5568impl NetworkManagerListNetworksResponder {
5569    /// Sends a response to the FIDL transaction.
5570    ///
5571    /// Sets the channel to shutdown if an error occurs.
5572    pub fn send(self, mut nets: &[String]) -> Result<(), fidl::Error> {
5573        let _result = self.send_raw(nets);
5574        if _result.is_err() {
5575            self.control_handle.shutdown();
5576        }
5577        self.drop_without_shutdown();
5578        _result
5579    }
5580
5581    /// Similar to "send" but does not shutdown the channel if an error occurs.
5582    pub fn send_no_shutdown_on_err(self, mut nets: &[String]) -> Result<(), fidl::Error> {
5583        let _result = self.send_raw(nets);
5584        self.drop_without_shutdown();
5585        _result
5586    }
5587
5588    fn send_raw(&self, mut nets: &[String]) -> Result<(), fidl::Error> {
5589        self.control_handle.inner.send::<NetworkManagerListNetworksResponse>(
5590            (nets,),
5591            self.tx_id,
5592            0x2488653e0974cc62,
5593            fidl::encoding::DynamicFlags::empty(),
5594        )
5595    }
5596}
5597
5598#[must_use = "FIDL methods require a response to be sent"]
5599#[derive(Debug)]
5600pub struct NetworkManagerCreateNetworkResponder {
5601    control_handle: std::mem::ManuallyDrop<NetworkManagerControlHandle>,
5602    tx_id: u32,
5603}
5604
5605/// Set the the channel to be shutdown (see [`NetworkManagerControlHandle::shutdown`])
5606/// if the responder is dropped without sending a response, so that the client
5607/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5608impl std::ops::Drop for NetworkManagerCreateNetworkResponder {
5609    fn drop(&mut self) {
5610        self.control_handle.shutdown();
5611        // Safety: drops once, never accessed again
5612        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5613    }
5614}
5615
5616impl fidl::endpoints::Responder for NetworkManagerCreateNetworkResponder {
5617    type ControlHandle = NetworkManagerControlHandle;
5618
5619    fn control_handle(&self) -> &NetworkManagerControlHandle {
5620        &self.control_handle
5621    }
5622
5623    fn drop_without_shutdown(mut self) {
5624        // Safety: drops once, never accessed again due to mem::forget
5625        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5626        // Prevent Drop from running (which would shut down the channel)
5627        std::mem::forget(self);
5628    }
5629}
5630
5631impl NetworkManagerCreateNetworkResponder {
5632    /// Sends a response to the FIDL transaction.
5633    ///
5634    /// Sets the channel to shutdown if an error occurs.
5635    pub fn send(
5636        self,
5637        mut status: i32,
5638        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5639    ) -> Result<(), fidl::Error> {
5640        let _result = self.send_raw(status, net);
5641        if _result.is_err() {
5642            self.control_handle.shutdown();
5643        }
5644        self.drop_without_shutdown();
5645        _result
5646    }
5647
5648    /// Similar to "send" but does not shutdown the channel if an error occurs.
5649    pub fn send_no_shutdown_on_err(
5650        self,
5651        mut status: i32,
5652        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5653    ) -> Result<(), fidl::Error> {
5654        let _result = self.send_raw(status, net);
5655        self.drop_without_shutdown();
5656        _result
5657    }
5658
5659    fn send_raw(
5660        &self,
5661        mut status: i32,
5662        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5663    ) -> Result<(), fidl::Error> {
5664        self.control_handle.inner.send::<NetworkManagerCreateNetworkResponse>(
5665            (status, net),
5666            self.tx_id,
5667            0x6052eb5ac709af,
5668            fidl::encoding::DynamicFlags::empty(),
5669        )
5670    }
5671}
5672
5673#[must_use = "FIDL methods require a response to be sent"]
5674#[derive(Debug)]
5675pub struct NetworkManagerGetNetworkResponder {
5676    control_handle: std::mem::ManuallyDrop<NetworkManagerControlHandle>,
5677    tx_id: u32,
5678}
5679
5680/// Set the the channel to be shutdown (see [`NetworkManagerControlHandle::shutdown`])
5681/// if the responder is dropped without sending a response, so that the client
5682/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5683impl std::ops::Drop for NetworkManagerGetNetworkResponder {
5684    fn drop(&mut self) {
5685        self.control_handle.shutdown();
5686        // Safety: drops once, never accessed again
5687        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5688    }
5689}
5690
5691impl fidl::endpoints::Responder for NetworkManagerGetNetworkResponder {
5692    type ControlHandle = NetworkManagerControlHandle;
5693
5694    fn control_handle(&self) -> &NetworkManagerControlHandle {
5695        &self.control_handle
5696    }
5697
5698    fn drop_without_shutdown(mut self) {
5699        // Safety: drops once, never accessed again due to mem::forget
5700        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5701        // Prevent Drop from running (which would shut down the channel)
5702        std::mem::forget(self);
5703    }
5704}
5705
5706impl NetworkManagerGetNetworkResponder {
5707    /// Sends a response to the FIDL transaction.
5708    ///
5709    /// Sets the channel to shutdown if an error occurs.
5710    pub fn send(
5711        self,
5712        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5713    ) -> Result<(), fidl::Error> {
5714        let _result = self.send_raw(net);
5715        if _result.is_err() {
5716            self.control_handle.shutdown();
5717        }
5718        self.drop_without_shutdown();
5719        _result
5720    }
5721
5722    /// Similar to "send" but does not shutdown the channel if an error occurs.
5723    pub fn send_no_shutdown_on_err(
5724        self,
5725        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5726    ) -> Result<(), fidl::Error> {
5727        let _result = self.send_raw(net);
5728        self.drop_without_shutdown();
5729        _result
5730    }
5731
5732    fn send_raw(
5733        &self,
5734        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
5735    ) -> Result<(), fidl::Error> {
5736        self.control_handle.inner.send::<NetworkManagerGetNetworkResponse>(
5737            (net,),
5738            self.tx_id,
5739            0x59930bf23acc7d9a,
5740            fidl::encoding::DynamicFlags::empty(),
5741        )
5742    }
5743}
5744
5745#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
5746pub struct SetupHandleMarker;
5747
5748impl fidl::endpoints::ProtocolMarker for SetupHandleMarker {
5749    type Proxy = SetupHandleProxy;
5750    type RequestStream = SetupHandleRequestStream;
5751    #[cfg(target_os = "fuchsia")]
5752    type SynchronousProxy = SetupHandleSynchronousProxy;
5753
5754    const DEBUG_NAME: &'static str = "(anonymous) SetupHandle";
5755}
5756
5757pub trait SetupHandleProxyInterface: Send + Sync {}
5758#[derive(Debug)]
5759#[cfg(target_os = "fuchsia")]
5760pub struct SetupHandleSynchronousProxy {
5761    client: fidl::client::sync::Client,
5762}
5763
5764#[cfg(target_os = "fuchsia")]
5765impl fidl::endpoints::SynchronousProxy for SetupHandleSynchronousProxy {
5766    type Proxy = SetupHandleProxy;
5767    type Protocol = SetupHandleMarker;
5768
5769    fn from_channel(inner: fidl::Channel) -> Self {
5770        Self::new(inner)
5771    }
5772
5773    fn into_channel(self) -> fidl::Channel {
5774        self.client.into_channel()
5775    }
5776
5777    fn as_channel(&self) -> &fidl::Channel {
5778        self.client.as_channel()
5779    }
5780}
5781
5782#[cfg(target_os = "fuchsia")]
5783impl SetupHandleSynchronousProxy {
5784    pub fn new(channel: fidl::Channel) -> Self {
5785        let protocol_name = <SetupHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
5786        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
5787    }
5788
5789    pub fn into_channel(self) -> fidl::Channel {
5790        self.client.into_channel()
5791    }
5792
5793    /// Waits until an event arrives and returns it. It is safe for other
5794    /// threads to make concurrent requests while waiting for an event.
5795    pub fn wait_for_event(
5796        &self,
5797        deadline: zx::MonotonicInstant,
5798    ) -> Result<SetupHandleEvent, fidl::Error> {
5799        SetupHandleEvent::decode(self.client.wait_for_event(deadline)?)
5800    }
5801}
5802
5803#[cfg(target_os = "fuchsia")]
5804impl From<SetupHandleSynchronousProxy> for zx::Handle {
5805    fn from(value: SetupHandleSynchronousProxy) -> Self {
5806        value.into_channel().into()
5807    }
5808}
5809
5810#[cfg(target_os = "fuchsia")]
5811impl From<fidl::Channel> for SetupHandleSynchronousProxy {
5812    fn from(value: fidl::Channel) -> Self {
5813        Self::new(value)
5814    }
5815}
5816
5817#[cfg(target_os = "fuchsia")]
5818impl fidl::endpoints::FromClient for SetupHandleSynchronousProxy {
5819    type Protocol = SetupHandleMarker;
5820
5821    fn from_client(value: fidl::endpoints::ClientEnd<SetupHandleMarker>) -> Self {
5822        Self::new(value.into_channel())
5823    }
5824}
5825
5826#[derive(Debug, Clone)]
5827pub struct SetupHandleProxy {
5828    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
5829}
5830
5831impl fidl::endpoints::Proxy for SetupHandleProxy {
5832    type Protocol = SetupHandleMarker;
5833
5834    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
5835        Self::new(inner)
5836    }
5837
5838    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
5839        self.client.into_channel().map_err(|client| Self { client })
5840    }
5841
5842    fn as_channel(&self) -> &::fidl::AsyncChannel {
5843        self.client.as_channel()
5844    }
5845}
5846
5847impl SetupHandleProxy {
5848    /// Create a new Proxy for fuchsia.netemul.network/SetupHandle.
5849    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
5850        let protocol_name = <SetupHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
5851        Self { client: fidl::client::Client::new(channel, protocol_name) }
5852    }
5853
5854    /// Get a Stream of events from the remote end of the protocol.
5855    ///
5856    /// # Panics
5857    ///
5858    /// Panics if the event stream was already taken.
5859    pub fn take_event_stream(&self) -> SetupHandleEventStream {
5860        SetupHandleEventStream { event_receiver: self.client.take_event_receiver() }
5861    }
5862}
5863
5864impl SetupHandleProxyInterface for SetupHandleProxy {}
5865
5866pub struct SetupHandleEventStream {
5867    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5868}
5869
5870impl std::marker::Unpin for SetupHandleEventStream {}
5871
5872impl futures::stream::FusedStream for SetupHandleEventStream {
5873    fn is_terminated(&self) -> bool {
5874        self.event_receiver.is_terminated()
5875    }
5876}
5877
5878impl futures::Stream for SetupHandleEventStream {
5879    type Item = Result<SetupHandleEvent, fidl::Error>;
5880
5881    fn poll_next(
5882        mut self: std::pin::Pin<&mut Self>,
5883        cx: &mut std::task::Context<'_>,
5884    ) -> std::task::Poll<Option<Self::Item>> {
5885        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5886            &mut self.event_receiver,
5887            cx
5888        )?) {
5889            Some(buf) => std::task::Poll::Ready(Some(SetupHandleEvent::decode(buf))),
5890            None => std::task::Poll::Ready(None),
5891        }
5892    }
5893}
5894
5895#[derive(Debug)]
5896pub enum SetupHandleEvent {}
5897
5898impl SetupHandleEvent {
5899    /// Decodes a message buffer as a [`SetupHandleEvent`].
5900    fn decode(
5901        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5902    ) -> Result<SetupHandleEvent, fidl::Error> {
5903        let (bytes, _handles) = buf.split_mut();
5904        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5905        debug_assert_eq!(tx_header.tx_id, 0);
5906        match tx_header.ordinal {
5907            _ => Err(fidl::Error::UnknownOrdinal {
5908                ordinal: tx_header.ordinal,
5909                protocol_name: <SetupHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5910            }),
5911        }
5912    }
5913}
5914
5915/// A Stream of incoming requests for fuchsia.netemul.network/SetupHandle.
5916pub struct SetupHandleRequestStream {
5917    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5918    is_terminated: bool,
5919}
5920
5921impl std::marker::Unpin for SetupHandleRequestStream {}
5922
5923impl futures::stream::FusedStream for SetupHandleRequestStream {
5924    fn is_terminated(&self) -> bool {
5925        self.is_terminated
5926    }
5927}
5928
5929impl fidl::endpoints::RequestStream for SetupHandleRequestStream {
5930    type Protocol = SetupHandleMarker;
5931    type ControlHandle = SetupHandleControlHandle;
5932
5933    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5934        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5935    }
5936
5937    fn control_handle(&self) -> Self::ControlHandle {
5938        SetupHandleControlHandle { inner: self.inner.clone() }
5939    }
5940
5941    fn into_inner(
5942        self,
5943    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5944    {
5945        (self.inner, self.is_terminated)
5946    }
5947
5948    fn from_inner(
5949        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5950        is_terminated: bool,
5951    ) -> Self {
5952        Self { inner, is_terminated }
5953    }
5954}
5955
5956impl futures::Stream for SetupHandleRequestStream {
5957    type Item = Result<SetupHandleRequest, fidl::Error>;
5958
5959    fn poll_next(
5960        mut self: std::pin::Pin<&mut Self>,
5961        cx: &mut std::task::Context<'_>,
5962    ) -> std::task::Poll<Option<Self::Item>> {
5963        let this = &mut *self;
5964        if this.inner.check_shutdown(cx) {
5965            this.is_terminated = true;
5966            return std::task::Poll::Ready(None);
5967        }
5968        if this.is_terminated {
5969            panic!("polled SetupHandleRequestStream after completion");
5970        }
5971        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5972            |bytes, handles| {
5973                match this.inner.channel().read_etc(cx, bytes, handles) {
5974                    std::task::Poll::Ready(Ok(())) => {}
5975                    std::task::Poll::Pending => return std::task::Poll::Pending,
5976                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5977                        this.is_terminated = true;
5978                        return std::task::Poll::Ready(None);
5979                    }
5980                    std::task::Poll::Ready(Err(e)) => {
5981                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5982                            e.into(),
5983                        ))))
5984                    }
5985                }
5986
5987                // A message has been received from the channel
5988                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5989
5990                std::task::Poll::Ready(Some(match header.ordinal {
5991                    _ => Err(fidl::Error::UnknownOrdinal {
5992                        ordinal: header.ordinal,
5993                        protocol_name:
5994                            <SetupHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5995                    }),
5996                }))
5997            },
5998        )
5999    }
6000}
6001
6002/// Handle returned when using NetworkContext.Setup for quick network configuration.
6003/// Networks and endpoints created by Setup are tied to the lifecycle of the SetupHandle's channel.
6004#[derive(Debug)]
6005pub enum SetupHandleRequest {}
6006
6007impl SetupHandleRequest {
6008    /// Name of the method defined in FIDL
6009    pub fn method_name(&self) -> &'static str {
6010        match *self {}
6011    }
6012}
6013
6014#[derive(Debug, Clone)]
6015pub struct SetupHandleControlHandle {
6016    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6017}
6018
6019impl fidl::endpoints::ControlHandle for SetupHandleControlHandle {
6020    fn shutdown(&self) {
6021        self.inner.shutdown()
6022    }
6023    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
6024        self.inner.shutdown_with_epitaph(status)
6025    }
6026
6027    fn is_closed(&self) -> bool {
6028        self.inner.channel().is_closed()
6029    }
6030    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
6031        self.inner.channel().on_closed()
6032    }
6033
6034    #[cfg(target_os = "fuchsia")]
6035    fn signal_peer(
6036        &self,
6037        clear_mask: zx::Signals,
6038        set_mask: zx::Signals,
6039    ) -> Result<(), zx_status::Status> {
6040        use fidl::Peered;
6041        self.inner.channel().signal_peer(clear_mask, set_mask)
6042    }
6043}
6044
6045impl SetupHandleControlHandle {}
6046
6047mod internal {
6048    use super::*;
6049
6050    impl fidl::encoding::ResourceTypeMarker for DeviceProxyServeControllerRequest {
6051        type Borrowed<'a> = &'a mut Self;
6052        fn take_or_borrow<'a>(
6053            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6054        ) -> Self::Borrowed<'a> {
6055            value
6056        }
6057    }
6058
6059    unsafe impl fidl::encoding::TypeMarker for DeviceProxyServeControllerRequest {
6060        type Owned = Self;
6061
6062        #[inline(always)]
6063        fn inline_align(_context: fidl::encoding::Context) -> usize {
6064            4
6065        }
6066
6067        #[inline(always)]
6068        fn inline_size(_context: fidl::encoding::Context) -> usize {
6069            4
6070        }
6071    }
6072
6073    unsafe impl
6074        fidl::encoding::Encode<
6075            DeviceProxyServeControllerRequest,
6076            fidl::encoding::DefaultFuchsiaResourceDialect,
6077        > for &mut DeviceProxyServeControllerRequest
6078    {
6079        #[inline]
6080        unsafe fn encode(
6081            self,
6082            encoder: &mut fidl::encoding::Encoder<
6083                '_,
6084                fidl::encoding::DefaultFuchsiaResourceDialect,
6085            >,
6086            offset: usize,
6087            _depth: fidl::encoding::Depth,
6088        ) -> fidl::Result<()> {
6089            encoder.debug_check_bounds::<DeviceProxyServeControllerRequest>(offset);
6090            // Delegate to tuple encoding.
6091            fidl::encoding::Encode::<
6092                DeviceProxyServeControllerRequest,
6093                fidl::encoding::DefaultFuchsiaResourceDialect,
6094            >::encode(
6095                (<fidl::encoding::Endpoint<
6096                    fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
6097                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6098                    &mut self.req
6099                ),),
6100                encoder,
6101                offset,
6102                _depth,
6103            )
6104        }
6105    }
6106    unsafe impl<
6107            T0: fidl::encoding::Encode<
6108                fidl::encoding::Endpoint<
6109                    fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
6110                >,
6111                fidl::encoding::DefaultFuchsiaResourceDialect,
6112            >,
6113        >
6114        fidl::encoding::Encode<
6115            DeviceProxyServeControllerRequest,
6116            fidl::encoding::DefaultFuchsiaResourceDialect,
6117        > for (T0,)
6118    {
6119        #[inline]
6120        unsafe fn encode(
6121            self,
6122            encoder: &mut fidl::encoding::Encoder<
6123                '_,
6124                fidl::encoding::DefaultFuchsiaResourceDialect,
6125            >,
6126            offset: usize,
6127            depth: fidl::encoding::Depth,
6128        ) -> fidl::Result<()> {
6129            encoder.debug_check_bounds::<DeviceProxyServeControllerRequest>(offset);
6130            // Zero out padding regions. There's no need to apply masks
6131            // because the unmasked parts will be overwritten by fields.
6132            // Write the fields.
6133            self.0.encode(encoder, offset + 0, depth)?;
6134            Ok(())
6135        }
6136    }
6137
6138    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6139        for DeviceProxyServeControllerRequest
6140    {
6141        #[inline(always)]
6142        fn new_empty() -> Self {
6143            Self {
6144                req: fidl::new_empty!(
6145                    fidl::encoding::Endpoint<
6146                        fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
6147                    >,
6148                    fidl::encoding::DefaultFuchsiaResourceDialect
6149                ),
6150            }
6151        }
6152
6153        #[inline]
6154        unsafe fn decode(
6155            &mut self,
6156            decoder: &mut fidl::encoding::Decoder<
6157                '_,
6158                fidl::encoding::DefaultFuchsiaResourceDialect,
6159            >,
6160            offset: usize,
6161            _depth: fidl::encoding::Depth,
6162        ) -> fidl::Result<()> {
6163            decoder.debug_check_bounds::<Self>(offset);
6164            // Verify that padding bytes are zero.
6165            fidl::decode!(
6166                fidl::encoding::Endpoint<
6167                    fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
6168                >,
6169                fidl::encoding::DefaultFuchsiaResourceDialect,
6170                &mut self.req,
6171                decoder,
6172                offset + 0,
6173                _depth
6174            )?;
6175            Ok(())
6176        }
6177    }
6178
6179    impl fidl::encoding::ResourceTypeMarker for DeviceProxyServeDeviceRequest {
6180        type Borrowed<'a> = &'a mut Self;
6181        fn take_or_borrow<'a>(
6182            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6183        ) -> Self::Borrowed<'a> {
6184            value
6185        }
6186    }
6187
6188    unsafe impl fidl::encoding::TypeMarker for DeviceProxyServeDeviceRequest {
6189        type Owned = Self;
6190
6191        #[inline(always)]
6192        fn inline_align(_context: fidl::encoding::Context) -> usize {
6193            4
6194        }
6195
6196        #[inline(always)]
6197        fn inline_size(_context: fidl::encoding::Context) -> usize {
6198            4
6199        }
6200    }
6201
6202    unsafe impl
6203        fidl::encoding::Encode<
6204            DeviceProxyServeDeviceRequest,
6205            fidl::encoding::DefaultFuchsiaResourceDialect,
6206        > for &mut DeviceProxyServeDeviceRequest
6207    {
6208        #[inline]
6209        unsafe fn encode(
6210            self,
6211            encoder: &mut fidl::encoding::Encoder<
6212                '_,
6213                fidl::encoding::DefaultFuchsiaResourceDialect,
6214            >,
6215            offset: usize,
6216            _depth: fidl::encoding::Depth,
6217        ) -> fidl::Result<()> {
6218            encoder.debug_check_bounds::<DeviceProxyServeDeviceRequest>(offset);
6219            // Delegate to tuple encoding.
6220            fidl::encoding::Encode::<
6221                DeviceProxyServeDeviceRequest,
6222                fidl::encoding::DefaultFuchsiaResourceDialect,
6223            >::encode(
6224                (<fidl::encoding::Endpoint<
6225                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
6226                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6227                    &mut self.req
6228                ),),
6229                encoder,
6230                offset,
6231                _depth,
6232            )
6233        }
6234    }
6235    unsafe impl<
6236            T0: fidl::encoding::Encode<
6237                fidl::encoding::Endpoint<
6238                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
6239                >,
6240                fidl::encoding::DefaultFuchsiaResourceDialect,
6241            >,
6242        >
6243        fidl::encoding::Encode<
6244            DeviceProxyServeDeviceRequest,
6245            fidl::encoding::DefaultFuchsiaResourceDialect,
6246        > for (T0,)
6247    {
6248        #[inline]
6249        unsafe fn encode(
6250            self,
6251            encoder: &mut fidl::encoding::Encoder<
6252                '_,
6253                fidl::encoding::DefaultFuchsiaResourceDialect,
6254            >,
6255            offset: usize,
6256            depth: fidl::encoding::Depth,
6257        ) -> fidl::Result<()> {
6258            encoder.debug_check_bounds::<DeviceProxyServeDeviceRequest>(offset);
6259            // Zero out padding regions. There's no need to apply masks
6260            // because the unmasked parts will be overwritten by fields.
6261            // Write the fields.
6262            self.0.encode(encoder, offset + 0, depth)?;
6263            Ok(())
6264        }
6265    }
6266
6267    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6268        for DeviceProxyServeDeviceRequest
6269    {
6270        #[inline(always)]
6271        fn new_empty() -> Self {
6272            Self {
6273                req: fidl::new_empty!(
6274                    fidl::encoding::Endpoint<
6275                        fidl::endpoints::ServerEnd<
6276                            fidl_fuchsia_hardware_network::DeviceInstanceMarker,
6277                        >,
6278                    >,
6279                    fidl::encoding::DefaultFuchsiaResourceDialect
6280                ),
6281            }
6282        }
6283
6284        #[inline]
6285        unsafe fn decode(
6286            &mut self,
6287            decoder: &mut fidl::encoding::Decoder<
6288                '_,
6289                fidl::encoding::DefaultFuchsiaResourceDialect,
6290            >,
6291            offset: usize,
6292            _depth: fidl::encoding::Depth,
6293        ) -> fidl::Result<()> {
6294            decoder.debug_check_bounds::<Self>(offset);
6295            // Verify that padding bytes are zero.
6296            fidl::decode!(
6297                fidl::encoding::Endpoint<
6298                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
6299                >,
6300                fidl::encoding::DefaultFuchsiaResourceDialect,
6301                &mut self.req,
6302                decoder,
6303                offset + 0,
6304                _depth
6305            )?;
6306            Ok(())
6307        }
6308    }
6309
6310    impl fidl::encoding::ResourceTypeMarker for EndpointGetPortRequest {
6311        type Borrowed<'a> = &'a mut Self;
6312        fn take_or_borrow<'a>(
6313            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6314        ) -> Self::Borrowed<'a> {
6315            value
6316        }
6317    }
6318
6319    unsafe impl fidl::encoding::TypeMarker for EndpointGetPortRequest {
6320        type Owned = Self;
6321
6322        #[inline(always)]
6323        fn inline_align(_context: fidl::encoding::Context) -> usize {
6324            4
6325        }
6326
6327        #[inline(always)]
6328        fn inline_size(_context: fidl::encoding::Context) -> usize {
6329            4
6330        }
6331    }
6332
6333    unsafe impl
6334        fidl::encoding::Encode<
6335            EndpointGetPortRequest,
6336            fidl::encoding::DefaultFuchsiaResourceDialect,
6337        > for &mut EndpointGetPortRequest
6338    {
6339        #[inline]
6340        unsafe fn encode(
6341            self,
6342            encoder: &mut fidl::encoding::Encoder<
6343                '_,
6344                fidl::encoding::DefaultFuchsiaResourceDialect,
6345            >,
6346            offset: usize,
6347            _depth: fidl::encoding::Depth,
6348        ) -> fidl::Result<()> {
6349            encoder.debug_check_bounds::<EndpointGetPortRequest>(offset);
6350            // Delegate to tuple encoding.
6351            fidl::encoding::Encode::<
6352                EndpointGetPortRequest,
6353                fidl::encoding::DefaultFuchsiaResourceDialect,
6354            >::encode(
6355                (<fidl::encoding::Endpoint<
6356                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
6357                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6358                    &mut self.port
6359                ),),
6360                encoder,
6361                offset,
6362                _depth,
6363            )
6364        }
6365    }
6366    unsafe impl<
6367            T0: fidl::encoding::Encode<
6368                fidl::encoding::Endpoint<
6369                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
6370                >,
6371                fidl::encoding::DefaultFuchsiaResourceDialect,
6372            >,
6373        >
6374        fidl::encoding::Encode<
6375            EndpointGetPortRequest,
6376            fidl::encoding::DefaultFuchsiaResourceDialect,
6377        > for (T0,)
6378    {
6379        #[inline]
6380        unsafe fn encode(
6381            self,
6382            encoder: &mut fidl::encoding::Encoder<
6383                '_,
6384                fidl::encoding::DefaultFuchsiaResourceDialect,
6385            >,
6386            offset: usize,
6387            depth: fidl::encoding::Depth,
6388        ) -> fidl::Result<()> {
6389            encoder.debug_check_bounds::<EndpointGetPortRequest>(offset);
6390            // Zero out padding regions. There's no need to apply masks
6391            // because the unmasked parts will be overwritten by fields.
6392            // Write the fields.
6393            self.0.encode(encoder, offset + 0, depth)?;
6394            Ok(())
6395        }
6396    }
6397
6398    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6399        for EndpointGetPortRequest
6400    {
6401        #[inline(always)]
6402        fn new_empty() -> Self {
6403            Self {
6404                port: fidl::new_empty!(
6405                    fidl::encoding::Endpoint<
6406                        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
6407                    >,
6408                    fidl::encoding::DefaultFuchsiaResourceDialect
6409                ),
6410            }
6411        }
6412
6413        #[inline]
6414        unsafe fn decode(
6415            &mut self,
6416            decoder: &mut fidl::encoding::Decoder<
6417                '_,
6418                fidl::encoding::DefaultFuchsiaResourceDialect,
6419            >,
6420            offset: usize,
6421            _depth: fidl::encoding::Depth,
6422        ) -> fidl::Result<()> {
6423            decoder.debug_check_bounds::<Self>(offset);
6424            // Verify that padding bytes are zero.
6425            fidl::decode!(
6426                fidl::encoding::Endpoint<
6427                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
6428                >,
6429                fidl::encoding::DefaultFuchsiaResourceDialect,
6430                &mut self.port,
6431                decoder,
6432                offset + 0,
6433                _depth
6434            )?;
6435            Ok(())
6436        }
6437    }
6438
6439    impl fidl::encoding::ResourceTypeMarker for EndpointGetProxyRequest {
6440        type Borrowed<'a> = &'a mut Self;
6441        fn take_or_borrow<'a>(
6442            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6443        ) -> Self::Borrowed<'a> {
6444            value
6445        }
6446    }
6447
6448    unsafe impl fidl::encoding::TypeMarker for EndpointGetProxyRequest {
6449        type Owned = Self;
6450
6451        #[inline(always)]
6452        fn inline_align(_context: fidl::encoding::Context) -> usize {
6453            4
6454        }
6455
6456        #[inline(always)]
6457        fn inline_size(_context: fidl::encoding::Context) -> usize {
6458            4
6459        }
6460    }
6461
6462    unsafe impl
6463        fidl::encoding::Encode<
6464            EndpointGetProxyRequest,
6465            fidl::encoding::DefaultFuchsiaResourceDialect,
6466        > for &mut EndpointGetProxyRequest
6467    {
6468        #[inline]
6469        unsafe fn encode(
6470            self,
6471            encoder: &mut fidl::encoding::Encoder<
6472                '_,
6473                fidl::encoding::DefaultFuchsiaResourceDialect,
6474            >,
6475            offset: usize,
6476            _depth: fidl::encoding::Depth,
6477        ) -> fidl::Result<()> {
6478            encoder.debug_check_bounds::<EndpointGetProxyRequest>(offset);
6479            // Delegate to tuple encoding.
6480            fidl::encoding::Encode::<EndpointGetProxyRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
6481                (
6482                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceProxy_Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.proxy),
6483                ),
6484                encoder, offset, _depth
6485            )
6486        }
6487    }
6488    unsafe impl<
6489            T0: fidl::encoding::Encode<
6490                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceProxy_Marker>>,
6491                fidl::encoding::DefaultFuchsiaResourceDialect,
6492            >,
6493        >
6494        fidl::encoding::Encode<
6495            EndpointGetProxyRequest,
6496            fidl::encoding::DefaultFuchsiaResourceDialect,
6497        > for (T0,)
6498    {
6499        #[inline]
6500        unsafe fn encode(
6501            self,
6502            encoder: &mut fidl::encoding::Encoder<
6503                '_,
6504                fidl::encoding::DefaultFuchsiaResourceDialect,
6505            >,
6506            offset: usize,
6507            depth: fidl::encoding::Depth,
6508        ) -> fidl::Result<()> {
6509            encoder.debug_check_bounds::<EndpointGetProxyRequest>(offset);
6510            // Zero out padding regions. There's no need to apply masks
6511            // because the unmasked parts will be overwritten by fields.
6512            // Write the fields.
6513            self.0.encode(encoder, offset + 0, depth)?;
6514            Ok(())
6515        }
6516    }
6517
6518    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6519        for EndpointGetProxyRequest
6520    {
6521        #[inline(always)]
6522        fn new_empty() -> Self {
6523            Self {
6524                proxy: fidl::new_empty!(
6525                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceProxy_Marker>>,
6526                    fidl::encoding::DefaultFuchsiaResourceDialect
6527                ),
6528            }
6529        }
6530
6531        #[inline]
6532        unsafe fn decode(
6533            &mut self,
6534            decoder: &mut fidl::encoding::Decoder<
6535                '_,
6536                fidl::encoding::DefaultFuchsiaResourceDialect,
6537            >,
6538            offset: usize,
6539            _depth: fidl::encoding::Depth,
6540        ) -> fidl::Result<()> {
6541            decoder.debug_check_bounds::<Self>(offset);
6542            // Verify that padding bytes are zero.
6543            fidl::decode!(
6544                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceProxy_Marker>>,
6545                fidl::encoding::DefaultFuchsiaResourceDialect,
6546                &mut self.proxy,
6547                decoder,
6548                offset + 0,
6549                _depth
6550            )?;
6551            Ok(())
6552        }
6553    }
6554
6555    impl fidl::encoding::ResourceTypeMarker for EndpointManagerCreateEndpointResponse {
6556        type Borrowed<'a> = &'a mut Self;
6557        fn take_or_borrow<'a>(
6558            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6559        ) -> Self::Borrowed<'a> {
6560            value
6561        }
6562    }
6563
6564    unsafe impl fidl::encoding::TypeMarker for EndpointManagerCreateEndpointResponse {
6565        type Owned = Self;
6566
6567        #[inline(always)]
6568        fn inline_align(_context: fidl::encoding::Context) -> usize {
6569            4
6570        }
6571
6572        #[inline(always)]
6573        fn inline_size(_context: fidl::encoding::Context) -> usize {
6574            8
6575        }
6576    }
6577
6578    unsafe impl
6579        fidl::encoding::Encode<
6580            EndpointManagerCreateEndpointResponse,
6581            fidl::encoding::DefaultFuchsiaResourceDialect,
6582        > for &mut EndpointManagerCreateEndpointResponse
6583    {
6584        #[inline]
6585        unsafe fn encode(
6586            self,
6587            encoder: &mut fidl::encoding::Encoder<
6588                '_,
6589                fidl::encoding::DefaultFuchsiaResourceDialect,
6590            >,
6591            offset: usize,
6592            _depth: fidl::encoding::Depth,
6593        ) -> fidl::Result<()> {
6594            encoder.debug_check_bounds::<EndpointManagerCreateEndpointResponse>(offset);
6595            // Delegate to tuple encoding.
6596            fidl::encoding::Encode::<
6597                EndpointManagerCreateEndpointResponse,
6598                fidl::encoding::DefaultFuchsiaResourceDialect,
6599            >::encode(
6600                (
6601                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
6602                    <fidl::encoding::Optional<
6603                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6604                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6605                        &mut self.endpoint
6606                    ),
6607                ),
6608                encoder,
6609                offset,
6610                _depth,
6611            )
6612        }
6613    }
6614    unsafe impl<
6615            T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
6616            T1: fidl::encoding::Encode<
6617                fidl::encoding::Optional<
6618                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6619                >,
6620                fidl::encoding::DefaultFuchsiaResourceDialect,
6621            >,
6622        >
6623        fidl::encoding::Encode<
6624            EndpointManagerCreateEndpointResponse,
6625            fidl::encoding::DefaultFuchsiaResourceDialect,
6626        > for (T0, T1)
6627    {
6628        #[inline]
6629        unsafe fn encode(
6630            self,
6631            encoder: &mut fidl::encoding::Encoder<
6632                '_,
6633                fidl::encoding::DefaultFuchsiaResourceDialect,
6634            >,
6635            offset: usize,
6636            depth: fidl::encoding::Depth,
6637        ) -> fidl::Result<()> {
6638            encoder.debug_check_bounds::<EndpointManagerCreateEndpointResponse>(offset);
6639            // Zero out padding regions. There's no need to apply masks
6640            // because the unmasked parts will be overwritten by fields.
6641            // Write the fields.
6642            self.0.encode(encoder, offset + 0, depth)?;
6643            self.1.encode(encoder, offset + 4, depth)?;
6644            Ok(())
6645        }
6646    }
6647
6648    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6649        for EndpointManagerCreateEndpointResponse
6650    {
6651        #[inline(always)]
6652        fn new_empty() -> Self {
6653            Self {
6654                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
6655                endpoint: fidl::new_empty!(
6656                    fidl::encoding::Optional<
6657                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6658                    >,
6659                    fidl::encoding::DefaultFuchsiaResourceDialect
6660                ),
6661            }
6662        }
6663
6664        #[inline]
6665        unsafe fn decode(
6666            &mut self,
6667            decoder: &mut fidl::encoding::Decoder<
6668                '_,
6669                fidl::encoding::DefaultFuchsiaResourceDialect,
6670            >,
6671            offset: usize,
6672            _depth: fidl::encoding::Depth,
6673        ) -> fidl::Result<()> {
6674            decoder.debug_check_bounds::<Self>(offset);
6675            // Verify that padding bytes are zero.
6676            fidl::decode!(
6677                i32,
6678                fidl::encoding::DefaultFuchsiaResourceDialect,
6679                &mut self.status,
6680                decoder,
6681                offset + 0,
6682                _depth
6683            )?;
6684            fidl::decode!(
6685                fidl::encoding::Optional<
6686                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6687                >,
6688                fidl::encoding::DefaultFuchsiaResourceDialect,
6689                &mut self.endpoint,
6690                decoder,
6691                offset + 4,
6692                _depth
6693            )?;
6694            Ok(())
6695        }
6696    }
6697
6698    impl fidl::encoding::ResourceTypeMarker for EndpointManagerGetEndpointResponse {
6699        type Borrowed<'a> = &'a mut Self;
6700        fn take_or_borrow<'a>(
6701            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6702        ) -> Self::Borrowed<'a> {
6703            value
6704        }
6705    }
6706
6707    unsafe impl fidl::encoding::TypeMarker for EndpointManagerGetEndpointResponse {
6708        type Owned = Self;
6709
6710        #[inline(always)]
6711        fn inline_align(_context: fidl::encoding::Context) -> usize {
6712            4
6713        }
6714
6715        #[inline(always)]
6716        fn inline_size(_context: fidl::encoding::Context) -> usize {
6717            4
6718        }
6719    }
6720
6721    unsafe impl
6722        fidl::encoding::Encode<
6723            EndpointManagerGetEndpointResponse,
6724            fidl::encoding::DefaultFuchsiaResourceDialect,
6725        > for &mut EndpointManagerGetEndpointResponse
6726    {
6727        #[inline]
6728        unsafe fn encode(
6729            self,
6730            encoder: &mut fidl::encoding::Encoder<
6731                '_,
6732                fidl::encoding::DefaultFuchsiaResourceDialect,
6733            >,
6734            offset: usize,
6735            _depth: fidl::encoding::Depth,
6736        ) -> fidl::Result<()> {
6737            encoder.debug_check_bounds::<EndpointManagerGetEndpointResponse>(offset);
6738            // Delegate to tuple encoding.
6739            fidl::encoding::Encode::<
6740                EndpointManagerGetEndpointResponse,
6741                fidl::encoding::DefaultFuchsiaResourceDialect,
6742            >::encode(
6743                (<fidl::encoding::Optional<
6744                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6745                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6746                    &mut self.endpoint
6747                ),),
6748                encoder,
6749                offset,
6750                _depth,
6751            )
6752        }
6753    }
6754    unsafe impl<
6755            T0: fidl::encoding::Encode<
6756                fidl::encoding::Optional<
6757                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6758                >,
6759                fidl::encoding::DefaultFuchsiaResourceDialect,
6760            >,
6761        >
6762        fidl::encoding::Encode<
6763            EndpointManagerGetEndpointResponse,
6764            fidl::encoding::DefaultFuchsiaResourceDialect,
6765        > for (T0,)
6766    {
6767        #[inline]
6768        unsafe fn encode(
6769            self,
6770            encoder: &mut fidl::encoding::Encoder<
6771                '_,
6772                fidl::encoding::DefaultFuchsiaResourceDialect,
6773            >,
6774            offset: usize,
6775            depth: fidl::encoding::Depth,
6776        ) -> fidl::Result<()> {
6777            encoder.debug_check_bounds::<EndpointManagerGetEndpointResponse>(offset);
6778            // Zero out padding regions. There's no need to apply masks
6779            // because the unmasked parts will be overwritten by fields.
6780            // Write the fields.
6781            self.0.encode(encoder, offset + 0, depth)?;
6782            Ok(())
6783        }
6784    }
6785
6786    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6787        for EndpointManagerGetEndpointResponse
6788    {
6789        #[inline(always)]
6790        fn new_empty() -> Self {
6791            Self {
6792                endpoint: fidl::new_empty!(
6793                    fidl::encoding::Optional<
6794                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6795                    >,
6796                    fidl::encoding::DefaultFuchsiaResourceDialect
6797                ),
6798            }
6799        }
6800
6801        #[inline]
6802        unsafe fn decode(
6803            &mut self,
6804            decoder: &mut fidl::encoding::Decoder<
6805                '_,
6806                fidl::encoding::DefaultFuchsiaResourceDialect,
6807            >,
6808            offset: usize,
6809            _depth: fidl::encoding::Depth,
6810        ) -> fidl::Result<()> {
6811            decoder.debug_check_bounds::<Self>(offset);
6812            // Verify that padding bytes are zero.
6813            fidl::decode!(
6814                fidl::encoding::Optional<
6815                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
6816                >,
6817                fidl::encoding::DefaultFuchsiaResourceDialect,
6818                &mut self.endpoint,
6819                decoder,
6820                offset + 0,
6821                _depth
6822            )?;
6823            Ok(())
6824        }
6825    }
6826
6827    impl fidl::encoding::ResourceTypeMarker for NetworkContextCloneRequest {
6828        type Borrowed<'a> = &'a mut Self;
6829        fn take_or_borrow<'a>(
6830            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6831        ) -> Self::Borrowed<'a> {
6832            value
6833        }
6834    }
6835
6836    unsafe impl fidl::encoding::TypeMarker for NetworkContextCloneRequest {
6837        type Owned = Self;
6838
6839        #[inline(always)]
6840        fn inline_align(_context: fidl::encoding::Context) -> usize {
6841            4
6842        }
6843
6844        #[inline(always)]
6845        fn inline_size(_context: fidl::encoding::Context) -> usize {
6846            4
6847        }
6848    }
6849
6850    unsafe impl
6851        fidl::encoding::Encode<
6852            NetworkContextCloneRequest,
6853            fidl::encoding::DefaultFuchsiaResourceDialect,
6854        > for &mut NetworkContextCloneRequest
6855    {
6856        #[inline]
6857        unsafe fn encode(
6858            self,
6859            encoder: &mut fidl::encoding::Encoder<
6860                '_,
6861                fidl::encoding::DefaultFuchsiaResourceDialect,
6862            >,
6863            offset: usize,
6864            _depth: fidl::encoding::Depth,
6865        ) -> fidl::Result<()> {
6866            encoder.debug_check_bounds::<NetworkContextCloneRequest>(offset);
6867            // Delegate to tuple encoding.
6868            fidl::encoding::Encode::<NetworkContextCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
6869                (
6870                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkContextMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.network_context),
6871                ),
6872                encoder, offset, _depth
6873            )
6874        }
6875    }
6876    unsafe impl<
6877            T0: fidl::encoding::Encode<
6878                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkContextMarker>>,
6879                fidl::encoding::DefaultFuchsiaResourceDialect,
6880            >,
6881        >
6882        fidl::encoding::Encode<
6883            NetworkContextCloneRequest,
6884            fidl::encoding::DefaultFuchsiaResourceDialect,
6885        > for (T0,)
6886    {
6887        #[inline]
6888        unsafe fn encode(
6889            self,
6890            encoder: &mut fidl::encoding::Encoder<
6891                '_,
6892                fidl::encoding::DefaultFuchsiaResourceDialect,
6893            >,
6894            offset: usize,
6895            depth: fidl::encoding::Depth,
6896        ) -> fidl::Result<()> {
6897            encoder.debug_check_bounds::<NetworkContextCloneRequest>(offset);
6898            // Zero out padding regions. There's no need to apply masks
6899            // because the unmasked parts will be overwritten by fields.
6900            // Write the fields.
6901            self.0.encode(encoder, offset + 0, depth)?;
6902            Ok(())
6903        }
6904    }
6905
6906    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6907        for NetworkContextCloneRequest
6908    {
6909        #[inline(always)]
6910        fn new_empty() -> Self {
6911            Self {
6912                network_context: fidl::new_empty!(
6913                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkContextMarker>>,
6914                    fidl::encoding::DefaultFuchsiaResourceDialect
6915                ),
6916            }
6917        }
6918
6919        #[inline]
6920        unsafe fn decode(
6921            &mut self,
6922            decoder: &mut fidl::encoding::Decoder<
6923                '_,
6924                fidl::encoding::DefaultFuchsiaResourceDialect,
6925            >,
6926            offset: usize,
6927            _depth: fidl::encoding::Depth,
6928        ) -> fidl::Result<()> {
6929            decoder.debug_check_bounds::<Self>(offset);
6930            // Verify that padding bytes are zero.
6931            fidl::decode!(
6932                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkContextMarker>>,
6933                fidl::encoding::DefaultFuchsiaResourceDialect,
6934                &mut self.network_context,
6935                decoder,
6936                offset + 0,
6937                _depth
6938            )?;
6939            Ok(())
6940        }
6941    }
6942
6943    impl fidl::encoding::ResourceTypeMarker for NetworkContextGetEndpointManagerRequest {
6944        type Borrowed<'a> = &'a mut Self;
6945        fn take_or_borrow<'a>(
6946            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6947        ) -> Self::Borrowed<'a> {
6948            value
6949        }
6950    }
6951
6952    unsafe impl fidl::encoding::TypeMarker for NetworkContextGetEndpointManagerRequest {
6953        type Owned = Self;
6954
6955        #[inline(always)]
6956        fn inline_align(_context: fidl::encoding::Context) -> usize {
6957            4
6958        }
6959
6960        #[inline(always)]
6961        fn inline_size(_context: fidl::encoding::Context) -> usize {
6962            4
6963        }
6964    }
6965
6966    unsafe impl
6967        fidl::encoding::Encode<
6968            NetworkContextGetEndpointManagerRequest,
6969            fidl::encoding::DefaultFuchsiaResourceDialect,
6970        > for &mut NetworkContextGetEndpointManagerRequest
6971    {
6972        #[inline]
6973        unsafe fn encode(
6974            self,
6975            encoder: &mut fidl::encoding::Encoder<
6976                '_,
6977                fidl::encoding::DefaultFuchsiaResourceDialect,
6978            >,
6979            offset: usize,
6980            _depth: fidl::encoding::Depth,
6981        ) -> fidl::Result<()> {
6982            encoder.debug_check_bounds::<NetworkContextGetEndpointManagerRequest>(offset);
6983            // Delegate to tuple encoding.
6984            fidl::encoding::Encode::<NetworkContextGetEndpointManagerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
6985                (
6986                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<EndpointManagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.endp_manager),
6987                ),
6988                encoder, offset, _depth
6989            )
6990        }
6991    }
6992    unsafe impl<
6993            T0: fidl::encoding::Encode<
6994                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<EndpointManagerMarker>>,
6995                fidl::encoding::DefaultFuchsiaResourceDialect,
6996            >,
6997        >
6998        fidl::encoding::Encode<
6999            NetworkContextGetEndpointManagerRequest,
7000            fidl::encoding::DefaultFuchsiaResourceDialect,
7001        > for (T0,)
7002    {
7003        #[inline]
7004        unsafe fn encode(
7005            self,
7006            encoder: &mut fidl::encoding::Encoder<
7007                '_,
7008                fidl::encoding::DefaultFuchsiaResourceDialect,
7009            >,
7010            offset: usize,
7011            depth: fidl::encoding::Depth,
7012        ) -> fidl::Result<()> {
7013            encoder.debug_check_bounds::<NetworkContextGetEndpointManagerRequest>(offset);
7014            // Zero out padding regions. There's no need to apply masks
7015            // because the unmasked parts will be overwritten by fields.
7016            // Write the fields.
7017            self.0.encode(encoder, offset + 0, depth)?;
7018            Ok(())
7019        }
7020    }
7021
7022    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7023        for NetworkContextGetEndpointManagerRequest
7024    {
7025        #[inline(always)]
7026        fn new_empty() -> Self {
7027            Self {
7028                endp_manager: fidl::new_empty!(
7029                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<EndpointManagerMarker>>,
7030                    fidl::encoding::DefaultFuchsiaResourceDialect
7031                ),
7032            }
7033        }
7034
7035        #[inline]
7036        unsafe fn decode(
7037            &mut self,
7038            decoder: &mut fidl::encoding::Decoder<
7039                '_,
7040                fidl::encoding::DefaultFuchsiaResourceDialect,
7041            >,
7042            offset: usize,
7043            _depth: fidl::encoding::Depth,
7044        ) -> fidl::Result<()> {
7045            decoder.debug_check_bounds::<Self>(offset);
7046            // Verify that padding bytes are zero.
7047            fidl::decode!(
7048                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<EndpointManagerMarker>>,
7049                fidl::encoding::DefaultFuchsiaResourceDialect,
7050                &mut self.endp_manager,
7051                decoder,
7052                offset + 0,
7053                _depth
7054            )?;
7055            Ok(())
7056        }
7057    }
7058
7059    impl fidl::encoding::ResourceTypeMarker for NetworkContextGetNetworkManagerRequest {
7060        type Borrowed<'a> = &'a mut Self;
7061        fn take_or_borrow<'a>(
7062            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7063        ) -> Self::Borrowed<'a> {
7064            value
7065        }
7066    }
7067
7068    unsafe impl fidl::encoding::TypeMarker for NetworkContextGetNetworkManagerRequest {
7069        type Owned = Self;
7070
7071        #[inline(always)]
7072        fn inline_align(_context: fidl::encoding::Context) -> usize {
7073            4
7074        }
7075
7076        #[inline(always)]
7077        fn inline_size(_context: fidl::encoding::Context) -> usize {
7078            4
7079        }
7080    }
7081
7082    unsafe impl
7083        fidl::encoding::Encode<
7084            NetworkContextGetNetworkManagerRequest,
7085            fidl::encoding::DefaultFuchsiaResourceDialect,
7086        > for &mut NetworkContextGetNetworkManagerRequest
7087    {
7088        #[inline]
7089        unsafe fn encode(
7090            self,
7091            encoder: &mut fidl::encoding::Encoder<
7092                '_,
7093                fidl::encoding::DefaultFuchsiaResourceDialect,
7094            >,
7095            offset: usize,
7096            _depth: fidl::encoding::Depth,
7097        ) -> fidl::Result<()> {
7098            encoder.debug_check_bounds::<NetworkContextGetNetworkManagerRequest>(offset);
7099            // Delegate to tuple encoding.
7100            fidl::encoding::Encode::<NetworkContextGetNetworkManagerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7101                (
7102                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkManagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.net_manager),
7103                ),
7104                encoder, offset, _depth
7105            )
7106        }
7107    }
7108    unsafe impl<
7109            T0: fidl::encoding::Encode<
7110                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkManagerMarker>>,
7111                fidl::encoding::DefaultFuchsiaResourceDialect,
7112            >,
7113        >
7114        fidl::encoding::Encode<
7115            NetworkContextGetNetworkManagerRequest,
7116            fidl::encoding::DefaultFuchsiaResourceDialect,
7117        > for (T0,)
7118    {
7119        #[inline]
7120        unsafe fn encode(
7121            self,
7122            encoder: &mut fidl::encoding::Encoder<
7123                '_,
7124                fidl::encoding::DefaultFuchsiaResourceDialect,
7125            >,
7126            offset: usize,
7127            depth: fidl::encoding::Depth,
7128        ) -> fidl::Result<()> {
7129            encoder.debug_check_bounds::<NetworkContextGetNetworkManagerRequest>(offset);
7130            // Zero out padding regions. There's no need to apply masks
7131            // because the unmasked parts will be overwritten by fields.
7132            // Write the fields.
7133            self.0.encode(encoder, offset + 0, depth)?;
7134            Ok(())
7135        }
7136    }
7137
7138    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7139        for NetworkContextGetNetworkManagerRequest
7140    {
7141        #[inline(always)]
7142        fn new_empty() -> Self {
7143            Self {
7144                net_manager: fidl::new_empty!(
7145                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkManagerMarker>>,
7146                    fidl::encoding::DefaultFuchsiaResourceDialect
7147                ),
7148            }
7149        }
7150
7151        #[inline]
7152        unsafe fn decode(
7153            &mut self,
7154            decoder: &mut fidl::encoding::Decoder<
7155                '_,
7156                fidl::encoding::DefaultFuchsiaResourceDialect,
7157            >,
7158            offset: usize,
7159            _depth: fidl::encoding::Depth,
7160        ) -> fidl::Result<()> {
7161            decoder.debug_check_bounds::<Self>(offset);
7162            // Verify that padding bytes are zero.
7163            fidl::decode!(
7164                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NetworkManagerMarker>>,
7165                fidl::encoding::DefaultFuchsiaResourceDialect,
7166                &mut self.net_manager,
7167                decoder,
7168                offset + 0,
7169                _depth
7170            )?;
7171            Ok(())
7172        }
7173    }
7174
7175    impl fidl::encoding::ResourceTypeMarker for NetworkContextSetupResponse {
7176        type Borrowed<'a> = &'a mut Self;
7177        fn take_or_borrow<'a>(
7178            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7179        ) -> Self::Borrowed<'a> {
7180            value
7181        }
7182    }
7183
7184    unsafe impl fidl::encoding::TypeMarker for NetworkContextSetupResponse {
7185        type Owned = Self;
7186
7187        #[inline(always)]
7188        fn inline_align(_context: fidl::encoding::Context) -> usize {
7189            4
7190        }
7191
7192        #[inline(always)]
7193        fn inline_size(_context: fidl::encoding::Context) -> usize {
7194            8
7195        }
7196    }
7197
7198    unsafe impl
7199        fidl::encoding::Encode<
7200            NetworkContextSetupResponse,
7201            fidl::encoding::DefaultFuchsiaResourceDialect,
7202        > for &mut NetworkContextSetupResponse
7203    {
7204        #[inline]
7205        unsafe fn encode(
7206            self,
7207            encoder: &mut fidl::encoding::Encoder<
7208                '_,
7209                fidl::encoding::DefaultFuchsiaResourceDialect,
7210            >,
7211            offset: usize,
7212            _depth: fidl::encoding::Depth,
7213        ) -> fidl::Result<()> {
7214            encoder.debug_check_bounds::<NetworkContextSetupResponse>(offset);
7215            // Delegate to tuple encoding.
7216            fidl::encoding::Encode::<
7217                NetworkContextSetupResponse,
7218                fidl::encoding::DefaultFuchsiaResourceDialect,
7219            >::encode(
7220                (
7221                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
7222                    <fidl::encoding::Optional<
7223                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
7224                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7225                        &mut self.setup_handle,
7226                    ),
7227                ),
7228                encoder,
7229                offset,
7230                _depth,
7231            )
7232        }
7233    }
7234    unsafe impl<
7235            T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
7236            T1: fidl::encoding::Encode<
7237                fidl::encoding::Optional<
7238                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
7239                >,
7240                fidl::encoding::DefaultFuchsiaResourceDialect,
7241            >,
7242        >
7243        fidl::encoding::Encode<
7244            NetworkContextSetupResponse,
7245            fidl::encoding::DefaultFuchsiaResourceDialect,
7246        > for (T0, T1)
7247    {
7248        #[inline]
7249        unsafe fn encode(
7250            self,
7251            encoder: &mut fidl::encoding::Encoder<
7252                '_,
7253                fidl::encoding::DefaultFuchsiaResourceDialect,
7254            >,
7255            offset: usize,
7256            depth: fidl::encoding::Depth,
7257        ) -> fidl::Result<()> {
7258            encoder.debug_check_bounds::<NetworkContextSetupResponse>(offset);
7259            // Zero out padding regions. There's no need to apply masks
7260            // because the unmasked parts will be overwritten by fields.
7261            // Write the fields.
7262            self.0.encode(encoder, offset + 0, depth)?;
7263            self.1.encode(encoder, offset + 4, depth)?;
7264            Ok(())
7265        }
7266    }
7267
7268    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7269        for NetworkContextSetupResponse
7270    {
7271        #[inline(always)]
7272        fn new_empty() -> Self {
7273            Self {
7274                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
7275                setup_handle: fidl::new_empty!(
7276                    fidl::encoding::Optional<
7277                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
7278                    >,
7279                    fidl::encoding::DefaultFuchsiaResourceDialect
7280                ),
7281            }
7282        }
7283
7284        #[inline]
7285        unsafe fn decode(
7286            &mut self,
7287            decoder: &mut fidl::encoding::Decoder<
7288                '_,
7289                fidl::encoding::DefaultFuchsiaResourceDialect,
7290            >,
7291            offset: usize,
7292            _depth: fidl::encoding::Depth,
7293        ) -> fidl::Result<()> {
7294            decoder.debug_check_bounds::<Self>(offset);
7295            // Verify that padding bytes are zero.
7296            fidl::decode!(
7297                i32,
7298                fidl::encoding::DefaultFuchsiaResourceDialect,
7299                &mut self.status,
7300                decoder,
7301                offset + 0,
7302                _depth
7303            )?;
7304            fidl::decode!(
7305                fidl::encoding::Optional<
7306                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
7307                >,
7308                fidl::encoding::DefaultFuchsiaResourceDialect,
7309                &mut self.setup_handle,
7310                decoder,
7311                offset + 4,
7312                _depth
7313            )?;
7314            Ok(())
7315        }
7316    }
7317
7318    impl fidl::encoding::ResourceTypeMarker for NetworkCreateFakeEndpointRequest {
7319        type Borrowed<'a> = &'a mut Self;
7320        fn take_or_borrow<'a>(
7321            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7322        ) -> Self::Borrowed<'a> {
7323            value
7324        }
7325    }
7326
7327    unsafe impl fidl::encoding::TypeMarker for NetworkCreateFakeEndpointRequest {
7328        type Owned = Self;
7329
7330        #[inline(always)]
7331        fn inline_align(_context: fidl::encoding::Context) -> usize {
7332            4
7333        }
7334
7335        #[inline(always)]
7336        fn inline_size(_context: fidl::encoding::Context) -> usize {
7337            4
7338        }
7339    }
7340
7341    unsafe impl
7342        fidl::encoding::Encode<
7343            NetworkCreateFakeEndpointRequest,
7344            fidl::encoding::DefaultFuchsiaResourceDialect,
7345        > for &mut NetworkCreateFakeEndpointRequest
7346    {
7347        #[inline]
7348        unsafe fn encode(
7349            self,
7350            encoder: &mut fidl::encoding::Encoder<
7351                '_,
7352                fidl::encoding::DefaultFuchsiaResourceDialect,
7353            >,
7354            offset: usize,
7355            _depth: fidl::encoding::Depth,
7356        ) -> fidl::Result<()> {
7357            encoder.debug_check_bounds::<NetworkCreateFakeEndpointRequest>(offset);
7358            // Delegate to tuple encoding.
7359            fidl::encoding::Encode::<NetworkCreateFakeEndpointRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7360                (
7361                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FakeEndpointMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ep),
7362                ),
7363                encoder, offset, _depth
7364            )
7365        }
7366    }
7367    unsafe impl<
7368            T0: fidl::encoding::Encode<
7369                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FakeEndpointMarker>>,
7370                fidl::encoding::DefaultFuchsiaResourceDialect,
7371            >,
7372        >
7373        fidl::encoding::Encode<
7374            NetworkCreateFakeEndpointRequest,
7375            fidl::encoding::DefaultFuchsiaResourceDialect,
7376        > for (T0,)
7377    {
7378        #[inline]
7379        unsafe fn encode(
7380            self,
7381            encoder: &mut fidl::encoding::Encoder<
7382                '_,
7383                fidl::encoding::DefaultFuchsiaResourceDialect,
7384            >,
7385            offset: usize,
7386            depth: fidl::encoding::Depth,
7387        ) -> fidl::Result<()> {
7388            encoder.debug_check_bounds::<NetworkCreateFakeEndpointRequest>(offset);
7389            // Zero out padding regions. There's no need to apply masks
7390            // because the unmasked parts will be overwritten by fields.
7391            // Write the fields.
7392            self.0.encode(encoder, offset + 0, depth)?;
7393            Ok(())
7394        }
7395    }
7396
7397    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7398        for NetworkCreateFakeEndpointRequest
7399    {
7400        #[inline(always)]
7401        fn new_empty() -> Self {
7402            Self {
7403                ep: fidl::new_empty!(
7404                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FakeEndpointMarker>>,
7405                    fidl::encoding::DefaultFuchsiaResourceDialect
7406                ),
7407            }
7408        }
7409
7410        #[inline]
7411        unsafe fn decode(
7412            &mut self,
7413            decoder: &mut fidl::encoding::Decoder<
7414                '_,
7415                fidl::encoding::DefaultFuchsiaResourceDialect,
7416            >,
7417            offset: usize,
7418            _depth: fidl::encoding::Depth,
7419        ) -> fidl::Result<()> {
7420            decoder.debug_check_bounds::<Self>(offset);
7421            // Verify that padding bytes are zero.
7422            fidl::decode!(
7423                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FakeEndpointMarker>>,
7424                fidl::encoding::DefaultFuchsiaResourceDialect,
7425                &mut self.ep,
7426                decoder,
7427                offset + 0,
7428                _depth
7429            )?;
7430            Ok(())
7431        }
7432    }
7433
7434    impl fidl::encoding::ResourceTypeMarker for NetworkManagerCreateNetworkResponse {
7435        type Borrowed<'a> = &'a mut Self;
7436        fn take_or_borrow<'a>(
7437            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7438        ) -> Self::Borrowed<'a> {
7439            value
7440        }
7441    }
7442
7443    unsafe impl fidl::encoding::TypeMarker for NetworkManagerCreateNetworkResponse {
7444        type Owned = Self;
7445
7446        #[inline(always)]
7447        fn inline_align(_context: fidl::encoding::Context) -> usize {
7448            4
7449        }
7450
7451        #[inline(always)]
7452        fn inline_size(_context: fidl::encoding::Context) -> usize {
7453            8
7454        }
7455    }
7456
7457    unsafe impl
7458        fidl::encoding::Encode<
7459            NetworkManagerCreateNetworkResponse,
7460            fidl::encoding::DefaultFuchsiaResourceDialect,
7461        > for &mut NetworkManagerCreateNetworkResponse
7462    {
7463        #[inline]
7464        unsafe fn encode(
7465            self,
7466            encoder: &mut fidl::encoding::Encoder<
7467                '_,
7468                fidl::encoding::DefaultFuchsiaResourceDialect,
7469            >,
7470            offset: usize,
7471            _depth: fidl::encoding::Depth,
7472        ) -> fidl::Result<()> {
7473            encoder.debug_check_bounds::<NetworkManagerCreateNetworkResponse>(offset);
7474            // Delegate to tuple encoding.
7475            fidl::encoding::Encode::<
7476                NetworkManagerCreateNetworkResponse,
7477                fidl::encoding::DefaultFuchsiaResourceDialect,
7478            >::encode(
7479                (
7480                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
7481                    <fidl::encoding::Optional<
7482                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7483                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7484                        &mut self.net
7485                    ),
7486                ),
7487                encoder,
7488                offset,
7489                _depth,
7490            )
7491        }
7492    }
7493    unsafe impl<
7494            T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
7495            T1: fidl::encoding::Encode<
7496                fidl::encoding::Optional<
7497                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7498                >,
7499                fidl::encoding::DefaultFuchsiaResourceDialect,
7500            >,
7501        >
7502        fidl::encoding::Encode<
7503            NetworkManagerCreateNetworkResponse,
7504            fidl::encoding::DefaultFuchsiaResourceDialect,
7505        > for (T0, T1)
7506    {
7507        #[inline]
7508        unsafe fn encode(
7509            self,
7510            encoder: &mut fidl::encoding::Encoder<
7511                '_,
7512                fidl::encoding::DefaultFuchsiaResourceDialect,
7513            >,
7514            offset: usize,
7515            depth: fidl::encoding::Depth,
7516        ) -> fidl::Result<()> {
7517            encoder.debug_check_bounds::<NetworkManagerCreateNetworkResponse>(offset);
7518            // Zero out padding regions. There's no need to apply masks
7519            // because the unmasked parts will be overwritten by fields.
7520            // Write the fields.
7521            self.0.encode(encoder, offset + 0, depth)?;
7522            self.1.encode(encoder, offset + 4, depth)?;
7523            Ok(())
7524        }
7525    }
7526
7527    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7528        for NetworkManagerCreateNetworkResponse
7529    {
7530        #[inline(always)]
7531        fn new_empty() -> Self {
7532            Self {
7533                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
7534                net: fidl::new_empty!(
7535                    fidl::encoding::Optional<
7536                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7537                    >,
7538                    fidl::encoding::DefaultFuchsiaResourceDialect
7539                ),
7540            }
7541        }
7542
7543        #[inline]
7544        unsafe fn decode(
7545            &mut self,
7546            decoder: &mut fidl::encoding::Decoder<
7547                '_,
7548                fidl::encoding::DefaultFuchsiaResourceDialect,
7549            >,
7550            offset: usize,
7551            _depth: fidl::encoding::Depth,
7552        ) -> fidl::Result<()> {
7553            decoder.debug_check_bounds::<Self>(offset);
7554            // Verify that padding bytes are zero.
7555            fidl::decode!(
7556                i32,
7557                fidl::encoding::DefaultFuchsiaResourceDialect,
7558                &mut self.status,
7559                decoder,
7560                offset + 0,
7561                _depth
7562            )?;
7563            fidl::decode!(
7564                fidl::encoding::Optional<
7565                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7566                >,
7567                fidl::encoding::DefaultFuchsiaResourceDialect,
7568                &mut self.net,
7569                decoder,
7570                offset + 4,
7571                _depth
7572            )?;
7573            Ok(())
7574        }
7575    }
7576
7577    impl fidl::encoding::ResourceTypeMarker for NetworkManagerGetNetworkResponse {
7578        type Borrowed<'a> = &'a mut Self;
7579        fn take_or_borrow<'a>(
7580            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7581        ) -> Self::Borrowed<'a> {
7582            value
7583        }
7584    }
7585
7586    unsafe impl fidl::encoding::TypeMarker for NetworkManagerGetNetworkResponse {
7587        type Owned = Self;
7588
7589        #[inline(always)]
7590        fn inline_align(_context: fidl::encoding::Context) -> usize {
7591            4
7592        }
7593
7594        #[inline(always)]
7595        fn inline_size(_context: fidl::encoding::Context) -> usize {
7596            4
7597        }
7598    }
7599
7600    unsafe impl
7601        fidl::encoding::Encode<
7602            NetworkManagerGetNetworkResponse,
7603            fidl::encoding::DefaultFuchsiaResourceDialect,
7604        > for &mut NetworkManagerGetNetworkResponse
7605    {
7606        #[inline]
7607        unsafe fn encode(
7608            self,
7609            encoder: &mut fidl::encoding::Encoder<
7610                '_,
7611                fidl::encoding::DefaultFuchsiaResourceDialect,
7612            >,
7613            offset: usize,
7614            _depth: fidl::encoding::Depth,
7615        ) -> fidl::Result<()> {
7616            encoder.debug_check_bounds::<NetworkManagerGetNetworkResponse>(offset);
7617            // Delegate to tuple encoding.
7618            fidl::encoding::Encode::<
7619                NetworkManagerGetNetworkResponse,
7620                fidl::encoding::DefaultFuchsiaResourceDialect,
7621            >::encode(
7622                (<fidl::encoding::Optional<
7623                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7624                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7625                    &mut self.net
7626                ),),
7627                encoder,
7628                offset,
7629                _depth,
7630            )
7631        }
7632    }
7633    unsafe impl<
7634            T0: fidl::encoding::Encode<
7635                fidl::encoding::Optional<
7636                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7637                >,
7638                fidl::encoding::DefaultFuchsiaResourceDialect,
7639            >,
7640        >
7641        fidl::encoding::Encode<
7642            NetworkManagerGetNetworkResponse,
7643            fidl::encoding::DefaultFuchsiaResourceDialect,
7644        > for (T0,)
7645    {
7646        #[inline]
7647        unsafe fn encode(
7648            self,
7649            encoder: &mut fidl::encoding::Encoder<
7650                '_,
7651                fidl::encoding::DefaultFuchsiaResourceDialect,
7652            >,
7653            offset: usize,
7654            depth: fidl::encoding::Depth,
7655        ) -> fidl::Result<()> {
7656            encoder.debug_check_bounds::<NetworkManagerGetNetworkResponse>(offset);
7657            // Zero out padding regions. There's no need to apply masks
7658            // because the unmasked parts will be overwritten by fields.
7659            // Write the fields.
7660            self.0.encode(encoder, offset + 0, depth)?;
7661            Ok(())
7662        }
7663    }
7664
7665    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7666        for NetworkManagerGetNetworkResponse
7667    {
7668        #[inline(always)]
7669        fn new_empty() -> Self {
7670            Self {
7671                net: fidl::new_empty!(
7672                    fidl::encoding::Optional<
7673                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7674                    >,
7675                    fidl::encoding::DefaultFuchsiaResourceDialect
7676                ),
7677            }
7678        }
7679
7680        #[inline]
7681        unsafe fn decode(
7682            &mut self,
7683            decoder: &mut fidl::encoding::Decoder<
7684                '_,
7685                fidl::encoding::DefaultFuchsiaResourceDialect,
7686            >,
7687            offset: usize,
7688            _depth: fidl::encoding::Depth,
7689        ) -> fidl::Result<()> {
7690            decoder.debug_check_bounds::<Self>(offset);
7691            // Verify that padding bytes are zero.
7692            fidl::decode!(
7693                fidl::encoding::Optional<
7694                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
7695                >,
7696                fidl::encoding::DefaultFuchsiaResourceDialect,
7697                &mut self.net,
7698                decoder,
7699                offset + 0,
7700                _depth
7701            )?;
7702            Ok(())
7703        }
7704    }
7705}