1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
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 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 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 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 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 pub fn take_event_stream(&self) -> DeviceProxy_EventStream {
289 DeviceProxy_EventStream { event_receiver: self.client.take_event_receiver() }
290 }
291
292 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 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 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
382pub 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 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#[derive(Debug)]
493pub enum DeviceProxy_Request {
494 ServeController {
496 req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
497 control_handle: DeviceProxy_ControlHandle,
498 },
499 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 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 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 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 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 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 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 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 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 pub fn r#get_name(
786 &self,
787 ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
788 EndpointProxyInterface::r#get_name(self)
789 }
790
791 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 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 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 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
954pub 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 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#[derive(Debug)]
1110pub enum EndpointRequest {
1111 GetConfig {
1112 responder: EndpointGetConfigResponder,
1113 },
1114 GetName {
1116 responder: EndpointGetNameResponder,
1117 },
1118 SetLinkUp {
1120 up: bool,
1121 responder: EndpointSetLinkUpResponder,
1122 },
1123 GetPort {
1125 port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
1126 control_handle: EndpointControlHandle,
1127 },
1128 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 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
1240impl std::ops::Drop for EndpointGetConfigResponder {
1244 fn drop(&mut self) {
1245 self.control_handle.shutdown();
1246 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1261 std::mem::forget(self);
1263 }
1264}
1265
1266impl EndpointGetConfigResponder {
1267 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 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
1303impl std::ops::Drop for EndpointGetNameResponder {
1307 fn drop(&mut self) {
1308 self.control_handle.shutdown();
1309 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1324 std::mem::forget(self);
1326 }
1327}
1328
1329impl EndpointGetNameResponder {
1330 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 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
1366impl std::ops::Drop for EndpointSetLinkUpResponder {
1370 fn drop(&mut self) {
1371 self.control_handle.shutdown();
1372 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1387 std::mem::forget(self);
1389 }
1390}
1391
1392impl EndpointSetLinkUpResponder {
1393 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 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 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 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 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 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 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 pub fn take_event_stream(&self) -> EndpointManagerEventStream {
1605 EndpointManagerEventStream { event_receiver: self.client.take_event_receiver() }
1606 }
1607
1608 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 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 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 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
1770pub 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 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#[derive(Debug)]
1912pub enum EndpointManagerRequest {
1913 ListEndpoints { responder: EndpointManagerListEndpointsResponder },
1915 CreateEndpoint {
1917 name: String,
1918 config: EndpointConfig,
1919 responder: EndpointManagerCreateEndpointResponder,
1920 },
1921 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 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
2005impl std::ops::Drop for EndpointManagerListEndpointsResponder {
2009 fn drop(&mut self) {
2010 self.control_handle.shutdown();
2011 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2026 std::mem::forget(self);
2028 }
2029}
2030
2031impl EndpointManagerListEndpointsResponder {
2032 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 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
2068impl std::ops::Drop for EndpointManagerCreateEndpointResponder {
2072 fn drop(&mut self) {
2073 self.control_handle.shutdown();
2074 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2089 std::mem::forget(self);
2091 }
2092}
2093
2094impl EndpointManagerCreateEndpointResponder {
2095 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 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
2143impl std::ops::Drop for EndpointManagerGetEndpointResponder {
2147 fn drop(&mut self) {
2148 self.control_handle.shutdown();
2149 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2164 std::mem::forget(self);
2166 }
2167}
2168
2169impl EndpointManagerGetEndpointResponder {
2170 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 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 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 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 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 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 pub fn take_event_stream(&self) -> FakeEndpointEventStream {
2363 FakeEndpointEventStream { event_receiver: self.client.take_event_receiver() }
2364 }
2365
2366 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 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 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
2485pub 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 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#[derive(Debug)]
2608pub enum FakeEndpointRequest {
2609 Write { data: Vec<u8>, responder: FakeEndpointWriteResponder },
2611 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 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
2690impl std::ops::Drop for FakeEndpointWriteResponder {
2694 fn drop(&mut self) {
2695 self.control_handle.shutdown();
2696 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2711 std::mem::forget(self);
2713 }
2714}
2715
2716impl FakeEndpointWriteResponder {
2717 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 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
2753impl std::ops::Drop for FakeEndpointReadResponder {
2757 fn drop(&mut self) {
2758 self.control_handle.shutdown();
2759 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2774 std::mem::forget(self);
2776 }
2777}
2778
2779impl FakeEndpointReadResponder {
2780 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 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 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 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 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 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 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 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 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 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 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 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 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 pub fn take_event_stream(&self) -> NetworkEventStream {
3093 NetworkEventStream { event_receiver: self.client.take_event_receiver() }
3094 }
3095
3096 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 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 pub fn r#get_name(
3118 &self,
3119 ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
3120 NetworkProxyInterface::r#get_name(self)
3121 }
3122
3123 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 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 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 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 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 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 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
3422pub 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 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#[derive(Debug)]
3649pub enum NetworkRequest {
3650 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 GetConfig { responder: NetworkGetConfigResponder },
3661 GetName { responder: NetworkGetNameResponder },
3663 SetConfig { config: NetworkConfig, responder: NetworkSetConfigResponder },
3665 AttachEndpoint { name: String, responder: NetworkAttachEndpointResponder },
3667 RemoveEndpoint { name: String, responder: NetworkRemoveEndpointResponder },
3669 CreateFakeEndpoint {
3671 ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
3672 control_handle: NetworkControlHandle,
3673 },
3674 StartCapture { name: String, responder: NetworkStartCaptureResponder },
3681 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 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
3847impl std::ops::Drop for NetworkGetConfigResponder {
3851 fn drop(&mut self) {
3852 self.control_handle.shutdown();
3853 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3868 std::mem::forget(self);
3870 }
3871}
3872
3873impl NetworkGetConfigResponder {
3874 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 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
3910impl std::ops::Drop for NetworkGetNameResponder {
3914 fn drop(&mut self) {
3915 self.control_handle.shutdown();
3916 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3931 std::mem::forget(self);
3933 }
3934}
3935
3936impl NetworkGetNameResponder {
3937 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 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
3973impl std::ops::Drop for NetworkSetConfigResponder {
3977 fn drop(&mut self) {
3978 self.control_handle.shutdown();
3979 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3994 std::mem::forget(self);
3996 }
3997}
3998
3999impl NetworkSetConfigResponder {
4000 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 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
4036impl std::ops::Drop for NetworkAttachEndpointResponder {
4040 fn drop(&mut self) {
4041 self.control_handle.shutdown();
4042 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4057 std::mem::forget(self);
4059 }
4060}
4061
4062impl NetworkAttachEndpointResponder {
4063 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 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
4099impl std::ops::Drop for NetworkRemoveEndpointResponder {
4103 fn drop(&mut self) {
4104 self.control_handle.shutdown();
4105 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4120 std::mem::forget(self);
4122 }
4123}
4124
4125impl NetworkRemoveEndpointResponder {
4126 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 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
4162impl std::ops::Drop for NetworkStartCaptureResponder {
4166 fn drop(&mut self) {
4167 self.control_handle.shutdown();
4168 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4183 std::mem::forget(self);
4185 }
4186}
4187
4188impl NetworkStartCaptureResponder {
4189 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 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
4225impl std::ops::Drop for NetworkStopCaptureResponder {
4229 fn drop(&mut self) {
4230 self.control_handle.shutdown();
4231 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4246 std::mem::forget(self);
4248 }
4249}
4250
4251impl NetworkStopCaptureResponder {
4252 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 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 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 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 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 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 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 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
4620pub 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 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#[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 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 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
4893impl std::ops::Drop for NetworkContextSetupResponder {
4897 fn drop(&mut self) {
4898 self.control_handle.shutdown();
4899 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4914 std::mem::forget(self);
4916 }
4917}
4918
4919impl NetworkContextSetupResponder {
4920 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 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 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 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 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 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 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 pub fn take_event_stream(&self) -> NetworkManagerEventStream {
5143 NetworkManagerEventStream { event_receiver: self.client.take_event_receiver() }
5144 }
5145
5146 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 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 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 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
5307pub 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 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#[derive(Debug)]
5449pub enum NetworkManagerRequest {
5450 ListNetworks { responder: NetworkManagerListNetworksResponder },
5452 CreateNetwork {
5454 name: String,
5455 config: NetworkConfig,
5456 responder: NetworkManagerCreateNetworkResponder,
5457 },
5458 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 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
5542impl std::ops::Drop for NetworkManagerListNetworksResponder {
5546 fn drop(&mut self) {
5547 self.control_handle.shutdown();
5548 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5563 std::mem::forget(self);
5565 }
5566}
5567
5568impl NetworkManagerListNetworksResponder {
5569 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 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
5605impl std::ops::Drop for NetworkManagerCreateNetworkResponder {
5609 fn drop(&mut self) {
5610 self.control_handle.shutdown();
5611 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5626 std::mem::forget(self);
5628 }
5629}
5630
5631impl NetworkManagerCreateNetworkResponder {
5632 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 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
5680impl std::ops::Drop for NetworkManagerGetNetworkResponder {
5684 fn drop(&mut self) {
5685 self.control_handle.shutdown();
5686 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5701 std::mem::forget(self);
5703 }
5704}
5705
5706impl NetworkManagerGetNetworkResponder {
5707 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 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 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 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 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 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
5915pub 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 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#[derive(Debug)]
6005pub enum SetupHandleRequest {}
6006
6007impl SetupHandleRequest {
6008 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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}