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_hardware_overnet__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct CallbackNewLinkRequest {
16 pub socket: fidl::Socket,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CallbackNewLinkRequest {}
20
21#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
22pub struct DeviceSetCallbackRequest {
23 pub callback: fidl::endpoints::ClientEnd<CallbackMarker>,
24}
25
26impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for DeviceSetCallbackRequest {}
27
28#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
29pub struct UsbSetCallbackRequest {
30 pub callback: fidl::endpoints::ClientEnd<CallbackMarker>,
31}
32
33impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for UsbSetCallbackRequest {}
34
35#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
36pub struct CallbackMarker;
37
38impl fidl::endpoints::ProtocolMarker for CallbackMarker {
39 type Proxy = CallbackProxy;
40 type RequestStream = CallbackRequestStream;
41 #[cfg(target_os = "fuchsia")]
42 type SynchronousProxy = CallbackSynchronousProxy;
43
44 const DEBUG_NAME: &'static str = "(anonymous) Callback";
45}
46
47pub trait CallbackProxyInterface: Send + Sync {
48 type NewLinkResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
49 fn r#new_link(&self, socket: fidl::Socket) -> Self::NewLinkResponseFut;
50}
51#[derive(Debug)]
52#[cfg(target_os = "fuchsia")]
53pub struct CallbackSynchronousProxy {
54 client: fidl::client::sync::Client,
55}
56
57#[cfg(target_os = "fuchsia")]
58impl fidl::endpoints::SynchronousProxy for CallbackSynchronousProxy {
59 type Proxy = CallbackProxy;
60 type Protocol = CallbackMarker;
61
62 fn from_channel(inner: fidl::Channel) -> Self {
63 Self::new(inner)
64 }
65
66 fn into_channel(self) -> fidl::Channel {
67 self.client.into_channel()
68 }
69
70 fn as_channel(&self) -> &fidl::Channel {
71 self.client.as_channel()
72 }
73}
74
75#[cfg(target_os = "fuchsia")]
76impl CallbackSynchronousProxy {
77 pub fn new(channel: fidl::Channel) -> Self {
78 let protocol_name = <CallbackMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
79 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
80 }
81
82 pub fn into_channel(self) -> fidl::Channel {
83 self.client.into_channel()
84 }
85
86 pub fn wait_for_event(
89 &self,
90 deadline: zx::MonotonicInstant,
91 ) -> Result<CallbackEvent, fidl::Error> {
92 CallbackEvent::decode(self.client.wait_for_event(deadline)?)
93 }
94
95 pub fn r#new_link(
96 &self,
97 mut socket: fidl::Socket,
98 ___deadline: zx::MonotonicInstant,
99 ) -> Result<(), fidl::Error> {
100 let _response =
101 self.client.send_query::<CallbackNewLinkRequest, fidl::encoding::EmptyPayload>(
102 (socket,),
103 0x70409481ebe346e5,
104 fidl::encoding::DynamicFlags::empty(),
105 ___deadline,
106 )?;
107 Ok(_response)
108 }
109}
110
111#[cfg(target_os = "fuchsia")]
112impl From<CallbackSynchronousProxy> for zx::Handle {
113 fn from(value: CallbackSynchronousProxy) -> Self {
114 value.into_channel().into()
115 }
116}
117
118#[cfg(target_os = "fuchsia")]
119impl From<fidl::Channel> for CallbackSynchronousProxy {
120 fn from(value: fidl::Channel) -> Self {
121 Self::new(value)
122 }
123}
124
125#[cfg(target_os = "fuchsia")]
126impl fidl::endpoints::FromClient for CallbackSynchronousProxy {
127 type Protocol = CallbackMarker;
128
129 fn from_client(value: fidl::endpoints::ClientEnd<CallbackMarker>) -> Self {
130 Self::new(value.into_channel())
131 }
132}
133
134#[derive(Debug, Clone)]
135pub struct CallbackProxy {
136 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
137}
138
139impl fidl::endpoints::Proxy for CallbackProxy {
140 type Protocol = CallbackMarker;
141
142 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
143 Self::new(inner)
144 }
145
146 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
147 self.client.into_channel().map_err(|client| Self { client })
148 }
149
150 fn as_channel(&self) -> &::fidl::AsyncChannel {
151 self.client.as_channel()
152 }
153}
154
155impl CallbackProxy {
156 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
158 let protocol_name = <CallbackMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
159 Self { client: fidl::client::Client::new(channel, protocol_name) }
160 }
161
162 pub fn take_event_stream(&self) -> CallbackEventStream {
168 CallbackEventStream { event_receiver: self.client.take_event_receiver() }
169 }
170
171 pub fn r#new_link(
172 &self,
173 mut socket: fidl::Socket,
174 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
175 CallbackProxyInterface::r#new_link(self, socket)
176 }
177}
178
179impl CallbackProxyInterface for CallbackProxy {
180 type NewLinkResponseFut =
181 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
182 fn r#new_link(&self, mut socket: fidl::Socket) -> Self::NewLinkResponseFut {
183 fn _decode(
184 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
185 ) -> Result<(), fidl::Error> {
186 let _response = fidl::client::decode_transaction_body::<
187 fidl::encoding::EmptyPayload,
188 fidl::encoding::DefaultFuchsiaResourceDialect,
189 0x70409481ebe346e5,
190 >(_buf?)?;
191 Ok(_response)
192 }
193 self.client.send_query_and_decode::<CallbackNewLinkRequest, ()>(
194 (socket,),
195 0x70409481ebe346e5,
196 fidl::encoding::DynamicFlags::empty(),
197 _decode,
198 )
199 }
200}
201
202pub struct CallbackEventStream {
203 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
204}
205
206impl std::marker::Unpin for CallbackEventStream {}
207
208impl futures::stream::FusedStream for CallbackEventStream {
209 fn is_terminated(&self) -> bool {
210 self.event_receiver.is_terminated()
211 }
212}
213
214impl futures::Stream for CallbackEventStream {
215 type Item = Result<CallbackEvent, fidl::Error>;
216
217 fn poll_next(
218 mut self: std::pin::Pin<&mut Self>,
219 cx: &mut std::task::Context<'_>,
220 ) -> std::task::Poll<Option<Self::Item>> {
221 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
222 &mut self.event_receiver,
223 cx
224 )?) {
225 Some(buf) => std::task::Poll::Ready(Some(CallbackEvent::decode(buf))),
226 None => std::task::Poll::Ready(None),
227 }
228 }
229}
230
231#[derive(Debug)]
232pub enum CallbackEvent {}
233
234impl CallbackEvent {
235 fn decode(
237 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
238 ) -> Result<CallbackEvent, fidl::Error> {
239 let (bytes, _handles) = buf.split_mut();
240 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
241 debug_assert_eq!(tx_header.tx_id, 0);
242 match tx_header.ordinal {
243 _ => Err(fidl::Error::UnknownOrdinal {
244 ordinal: tx_header.ordinal,
245 protocol_name: <CallbackMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
246 }),
247 }
248 }
249}
250
251pub struct CallbackRequestStream {
253 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
254 is_terminated: bool,
255}
256
257impl std::marker::Unpin for CallbackRequestStream {}
258
259impl futures::stream::FusedStream for CallbackRequestStream {
260 fn is_terminated(&self) -> bool {
261 self.is_terminated
262 }
263}
264
265impl fidl::endpoints::RequestStream for CallbackRequestStream {
266 type Protocol = CallbackMarker;
267 type ControlHandle = CallbackControlHandle;
268
269 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
270 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
271 }
272
273 fn control_handle(&self) -> Self::ControlHandle {
274 CallbackControlHandle { inner: self.inner.clone() }
275 }
276
277 fn into_inner(
278 self,
279 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
280 {
281 (self.inner, self.is_terminated)
282 }
283
284 fn from_inner(
285 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
286 is_terminated: bool,
287 ) -> Self {
288 Self { inner, is_terminated }
289 }
290}
291
292impl futures::Stream for CallbackRequestStream {
293 type Item = Result<CallbackRequest, fidl::Error>;
294
295 fn poll_next(
296 mut self: std::pin::Pin<&mut Self>,
297 cx: &mut std::task::Context<'_>,
298 ) -> std::task::Poll<Option<Self::Item>> {
299 let this = &mut *self;
300 if this.inner.check_shutdown(cx) {
301 this.is_terminated = true;
302 return std::task::Poll::Ready(None);
303 }
304 if this.is_terminated {
305 panic!("polled CallbackRequestStream after completion");
306 }
307 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
308 |bytes, handles| {
309 match this.inner.channel().read_etc(cx, bytes, handles) {
310 std::task::Poll::Ready(Ok(())) => {}
311 std::task::Poll::Pending => return std::task::Poll::Pending,
312 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
313 this.is_terminated = true;
314 return std::task::Poll::Ready(None);
315 }
316 std::task::Poll::Ready(Err(e)) => {
317 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
318 e.into(),
319 ))))
320 }
321 }
322
323 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
325
326 std::task::Poll::Ready(Some(match header.ordinal {
327 0x70409481ebe346e5 => {
328 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
329 let mut req = fidl::new_empty!(
330 CallbackNewLinkRequest,
331 fidl::encoding::DefaultFuchsiaResourceDialect
332 );
333 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CallbackNewLinkRequest>(&header, _body_bytes, handles, &mut req)?;
334 let control_handle = CallbackControlHandle { inner: this.inner.clone() };
335 Ok(CallbackRequest::NewLink {
336 socket: req.socket,
337
338 responder: CallbackNewLinkResponder {
339 control_handle: std::mem::ManuallyDrop::new(control_handle),
340 tx_id: header.tx_id,
341 },
342 })
343 }
344 _ => Err(fidl::Error::UnknownOrdinal {
345 ordinal: header.ordinal,
346 protocol_name:
347 <CallbackMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
348 }),
349 }))
350 },
351 )
352 }
353}
354
355#[derive(Debug)]
356pub enum CallbackRequest {
357 NewLink { socket: fidl::Socket, responder: CallbackNewLinkResponder },
358}
359
360impl CallbackRequest {
361 #[allow(irrefutable_let_patterns)]
362 pub fn into_new_link(self) -> Option<(fidl::Socket, CallbackNewLinkResponder)> {
363 if let CallbackRequest::NewLink { socket, responder } = self {
364 Some((socket, responder))
365 } else {
366 None
367 }
368 }
369
370 pub fn method_name(&self) -> &'static str {
372 match *self {
373 CallbackRequest::NewLink { .. } => "new_link",
374 }
375 }
376}
377
378#[derive(Debug, Clone)]
379pub struct CallbackControlHandle {
380 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
381}
382
383impl fidl::endpoints::ControlHandle for CallbackControlHandle {
384 fn shutdown(&self) {
385 self.inner.shutdown()
386 }
387 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
388 self.inner.shutdown_with_epitaph(status)
389 }
390
391 fn is_closed(&self) -> bool {
392 self.inner.channel().is_closed()
393 }
394 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
395 self.inner.channel().on_closed()
396 }
397
398 #[cfg(target_os = "fuchsia")]
399 fn signal_peer(
400 &self,
401 clear_mask: zx::Signals,
402 set_mask: zx::Signals,
403 ) -> Result<(), zx_status::Status> {
404 use fidl::Peered;
405 self.inner.channel().signal_peer(clear_mask, set_mask)
406 }
407}
408
409impl CallbackControlHandle {}
410
411#[must_use = "FIDL methods require a response to be sent"]
412#[derive(Debug)]
413pub struct CallbackNewLinkResponder {
414 control_handle: std::mem::ManuallyDrop<CallbackControlHandle>,
415 tx_id: u32,
416}
417
418impl std::ops::Drop for CallbackNewLinkResponder {
422 fn drop(&mut self) {
423 self.control_handle.shutdown();
424 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
426 }
427}
428
429impl fidl::endpoints::Responder for CallbackNewLinkResponder {
430 type ControlHandle = CallbackControlHandle;
431
432 fn control_handle(&self) -> &CallbackControlHandle {
433 &self.control_handle
434 }
435
436 fn drop_without_shutdown(mut self) {
437 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
439 std::mem::forget(self);
441 }
442}
443
444impl CallbackNewLinkResponder {
445 pub fn send(self) -> Result<(), fidl::Error> {
449 let _result = self.send_raw();
450 if _result.is_err() {
451 self.control_handle.shutdown();
452 }
453 self.drop_without_shutdown();
454 _result
455 }
456
457 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
459 let _result = self.send_raw();
460 self.drop_without_shutdown();
461 _result
462 }
463
464 fn send_raw(&self) -> Result<(), fidl::Error> {
465 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
466 (),
467 self.tx_id,
468 0x70409481ebe346e5,
469 fidl::encoding::DynamicFlags::empty(),
470 )
471 }
472}
473
474#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
475pub struct DeviceMarker;
476
477impl fidl::endpoints::ProtocolMarker for DeviceMarker {
478 type Proxy = DeviceProxy;
479 type RequestStream = DeviceRequestStream;
480 #[cfg(target_os = "fuchsia")]
481 type SynchronousProxy = DeviceSynchronousProxy;
482
483 const DEBUG_NAME: &'static str = "(anonymous) Device";
484}
485
486pub trait DeviceProxyInterface: Send + Sync {
487 type SetCallbackResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
488 fn r#set_callback(
489 &self,
490 callback: fidl::endpoints::ClientEnd<CallbackMarker>,
491 ) -> Self::SetCallbackResponseFut;
492}
493#[derive(Debug)]
494#[cfg(target_os = "fuchsia")]
495pub struct DeviceSynchronousProxy {
496 client: fidl::client::sync::Client,
497}
498
499#[cfg(target_os = "fuchsia")]
500impl fidl::endpoints::SynchronousProxy for DeviceSynchronousProxy {
501 type Proxy = DeviceProxy;
502 type Protocol = DeviceMarker;
503
504 fn from_channel(inner: fidl::Channel) -> Self {
505 Self::new(inner)
506 }
507
508 fn into_channel(self) -> fidl::Channel {
509 self.client.into_channel()
510 }
511
512 fn as_channel(&self) -> &fidl::Channel {
513 self.client.as_channel()
514 }
515}
516
517#[cfg(target_os = "fuchsia")]
518impl DeviceSynchronousProxy {
519 pub fn new(channel: fidl::Channel) -> Self {
520 let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
521 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
522 }
523
524 pub fn into_channel(self) -> fidl::Channel {
525 self.client.into_channel()
526 }
527
528 pub fn wait_for_event(
531 &self,
532 deadline: zx::MonotonicInstant,
533 ) -> Result<DeviceEvent, fidl::Error> {
534 DeviceEvent::decode(self.client.wait_for_event(deadline)?)
535 }
536
537 pub fn r#set_callback(
538 &self,
539 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
540 ___deadline: zx::MonotonicInstant,
541 ) -> Result<(), fidl::Error> {
542 let _response =
543 self.client.send_query::<DeviceSetCallbackRequest, fidl::encoding::EmptyPayload>(
544 (callback,),
545 0x4a3aeb347fde77c7,
546 fidl::encoding::DynamicFlags::empty(),
547 ___deadline,
548 )?;
549 Ok(_response)
550 }
551}
552
553#[cfg(target_os = "fuchsia")]
554impl From<DeviceSynchronousProxy> for zx::Handle {
555 fn from(value: DeviceSynchronousProxy) -> Self {
556 value.into_channel().into()
557 }
558}
559
560#[cfg(target_os = "fuchsia")]
561impl From<fidl::Channel> for DeviceSynchronousProxy {
562 fn from(value: fidl::Channel) -> Self {
563 Self::new(value)
564 }
565}
566
567#[cfg(target_os = "fuchsia")]
568impl fidl::endpoints::FromClient for DeviceSynchronousProxy {
569 type Protocol = DeviceMarker;
570
571 fn from_client(value: fidl::endpoints::ClientEnd<DeviceMarker>) -> Self {
572 Self::new(value.into_channel())
573 }
574}
575
576#[derive(Debug, Clone)]
577pub struct DeviceProxy {
578 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
579}
580
581impl fidl::endpoints::Proxy for DeviceProxy {
582 type Protocol = DeviceMarker;
583
584 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
585 Self::new(inner)
586 }
587
588 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
589 self.client.into_channel().map_err(|client| Self { client })
590 }
591
592 fn as_channel(&self) -> &::fidl::AsyncChannel {
593 self.client.as_channel()
594 }
595}
596
597impl DeviceProxy {
598 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
600 let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
601 Self { client: fidl::client::Client::new(channel, protocol_name) }
602 }
603
604 pub fn take_event_stream(&self) -> DeviceEventStream {
610 DeviceEventStream { event_receiver: self.client.take_event_receiver() }
611 }
612
613 pub fn r#set_callback(
614 &self,
615 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
616 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
617 DeviceProxyInterface::r#set_callback(self, callback)
618 }
619}
620
621impl DeviceProxyInterface for DeviceProxy {
622 type SetCallbackResponseFut =
623 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
624 fn r#set_callback(
625 &self,
626 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
627 ) -> Self::SetCallbackResponseFut {
628 fn _decode(
629 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
630 ) -> Result<(), fidl::Error> {
631 let _response = fidl::client::decode_transaction_body::<
632 fidl::encoding::EmptyPayload,
633 fidl::encoding::DefaultFuchsiaResourceDialect,
634 0x4a3aeb347fde77c7,
635 >(_buf?)?;
636 Ok(_response)
637 }
638 self.client.send_query_and_decode::<DeviceSetCallbackRequest, ()>(
639 (callback,),
640 0x4a3aeb347fde77c7,
641 fidl::encoding::DynamicFlags::empty(),
642 _decode,
643 )
644 }
645}
646
647pub struct DeviceEventStream {
648 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
649}
650
651impl std::marker::Unpin for DeviceEventStream {}
652
653impl futures::stream::FusedStream for DeviceEventStream {
654 fn is_terminated(&self) -> bool {
655 self.event_receiver.is_terminated()
656 }
657}
658
659impl futures::Stream for DeviceEventStream {
660 type Item = Result<DeviceEvent, fidl::Error>;
661
662 fn poll_next(
663 mut self: std::pin::Pin<&mut Self>,
664 cx: &mut std::task::Context<'_>,
665 ) -> std::task::Poll<Option<Self::Item>> {
666 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
667 &mut self.event_receiver,
668 cx
669 )?) {
670 Some(buf) => std::task::Poll::Ready(Some(DeviceEvent::decode(buf))),
671 None => std::task::Poll::Ready(None),
672 }
673 }
674}
675
676#[derive(Debug)]
677pub enum DeviceEvent {}
678
679impl DeviceEvent {
680 fn decode(
682 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
683 ) -> Result<DeviceEvent, fidl::Error> {
684 let (bytes, _handles) = buf.split_mut();
685 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
686 debug_assert_eq!(tx_header.tx_id, 0);
687 match tx_header.ordinal {
688 _ => Err(fidl::Error::UnknownOrdinal {
689 ordinal: tx_header.ordinal,
690 protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
691 }),
692 }
693 }
694}
695
696pub struct DeviceRequestStream {
698 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
699 is_terminated: bool,
700}
701
702impl std::marker::Unpin for DeviceRequestStream {}
703
704impl futures::stream::FusedStream for DeviceRequestStream {
705 fn is_terminated(&self) -> bool {
706 self.is_terminated
707 }
708}
709
710impl fidl::endpoints::RequestStream for DeviceRequestStream {
711 type Protocol = DeviceMarker;
712 type ControlHandle = DeviceControlHandle;
713
714 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
715 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
716 }
717
718 fn control_handle(&self) -> Self::ControlHandle {
719 DeviceControlHandle { inner: self.inner.clone() }
720 }
721
722 fn into_inner(
723 self,
724 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
725 {
726 (self.inner, self.is_terminated)
727 }
728
729 fn from_inner(
730 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
731 is_terminated: bool,
732 ) -> Self {
733 Self { inner, is_terminated }
734 }
735}
736
737impl futures::Stream for DeviceRequestStream {
738 type Item = Result<DeviceRequest, fidl::Error>;
739
740 fn poll_next(
741 mut self: std::pin::Pin<&mut Self>,
742 cx: &mut std::task::Context<'_>,
743 ) -> std::task::Poll<Option<Self::Item>> {
744 let this = &mut *self;
745 if this.inner.check_shutdown(cx) {
746 this.is_terminated = true;
747 return std::task::Poll::Ready(None);
748 }
749 if this.is_terminated {
750 panic!("polled DeviceRequestStream after completion");
751 }
752 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
753 |bytes, handles| {
754 match this.inner.channel().read_etc(cx, bytes, handles) {
755 std::task::Poll::Ready(Ok(())) => {}
756 std::task::Poll::Pending => return std::task::Poll::Pending,
757 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
758 this.is_terminated = true;
759 return std::task::Poll::Ready(None);
760 }
761 std::task::Poll::Ready(Err(e)) => {
762 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
763 e.into(),
764 ))))
765 }
766 }
767
768 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
770
771 std::task::Poll::Ready(Some(match header.ordinal {
772 0x4a3aeb347fde77c7 => {
773 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
774 let mut req = fidl::new_empty!(
775 DeviceSetCallbackRequest,
776 fidl::encoding::DefaultFuchsiaResourceDialect
777 );
778 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetCallbackRequest>(&header, _body_bytes, handles, &mut req)?;
779 let control_handle = DeviceControlHandle { inner: this.inner.clone() };
780 Ok(DeviceRequest::SetCallback {
781 callback: req.callback,
782
783 responder: DeviceSetCallbackResponder {
784 control_handle: std::mem::ManuallyDrop::new(control_handle),
785 tx_id: header.tx_id,
786 },
787 })
788 }
789 _ => Err(fidl::Error::UnknownOrdinal {
790 ordinal: header.ordinal,
791 protocol_name:
792 <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
793 }),
794 }))
795 },
796 )
797 }
798}
799
800#[derive(Debug)]
801pub enum DeviceRequest {
802 SetCallback {
803 callback: fidl::endpoints::ClientEnd<CallbackMarker>,
804 responder: DeviceSetCallbackResponder,
805 },
806}
807
808impl DeviceRequest {
809 #[allow(irrefutable_let_patterns)]
810 pub fn into_set_callback(
811 self,
812 ) -> Option<(fidl::endpoints::ClientEnd<CallbackMarker>, DeviceSetCallbackResponder)> {
813 if let DeviceRequest::SetCallback { callback, responder } = self {
814 Some((callback, responder))
815 } else {
816 None
817 }
818 }
819
820 pub fn method_name(&self) -> &'static str {
822 match *self {
823 DeviceRequest::SetCallback { .. } => "set_callback",
824 }
825 }
826}
827
828#[derive(Debug, Clone)]
829pub struct DeviceControlHandle {
830 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
831}
832
833impl fidl::endpoints::ControlHandle for DeviceControlHandle {
834 fn shutdown(&self) {
835 self.inner.shutdown()
836 }
837 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
838 self.inner.shutdown_with_epitaph(status)
839 }
840
841 fn is_closed(&self) -> bool {
842 self.inner.channel().is_closed()
843 }
844 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
845 self.inner.channel().on_closed()
846 }
847
848 #[cfg(target_os = "fuchsia")]
849 fn signal_peer(
850 &self,
851 clear_mask: zx::Signals,
852 set_mask: zx::Signals,
853 ) -> Result<(), zx_status::Status> {
854 use fidl::Peered;
855 self.inner.channel().signal_peer(clear_mask, set_mask)
856 }
857}
858
859impl DeviceControlHandle {}
860
861#[must_use = "FIDL methods require a response to be sent"]
862#[derive(Debug)]
863pub struct DeviceSetCallbackResponder {
864 control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
865 tx_id: u32,
866}
867
868impl std::ops::Drop for DeviceSetCallbackResponder {
872 fn drop(&mut self) {
873 self.control_handle.shutdown();
874 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
876 }
877}
878
879impl fidl::endpoints::Responder for DeviceSetCallbackResponder {
880 type ControlHandle = DeviceControlHandle;
881
882 fn control_handle(&self) -> &DeviceControlHandle {
883 &self.control_handle
884 }
885
886 fn drop_without_shutdown(mut self) {
887 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
889 std::mem::forget(self);
891 }
892}
893
894impl DeviceSetCallbackResponder {
895 pub fn send(self) -> Result<(), fidl::Error> {
899 let _result = self.send_raw();
900 if _result.is_err() {
901 self.control_handle.shutdown();
902 }
903 self.drop_without_shutdown();
904 _result
905 }
906
907 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
909 let _result = self.send_raw();
910 self.drop_without_shutdown();
911 _result
912 }
913
914 fn send_raw(&self) -> Result<(), fidl::Error> {
915 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
916 (),
917 self.tx_id,
918 0x4a3aeb347fde77c7,
919 fidl::encoding::DynamicFlags::empty(),
920 )
921 }
922}
923
924#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
925pub struct UsbMarker;
926
927impl fidl::endpoints::ProtocolMarker for UsbMarker {
928 type Proxy = UsbProxy;
929 type RequestStream = UsbRequestStream;
930 #[cfg(target_os = "fuchsia")]
931 type SynchronousProxy = UsbSynchronousProxy;
932
933 const DEBUG_NAME: &'static str = "(anonymous) Usb";
934}
935
936pub trait UsbProxyInterface: Send + Sync {
937 type SetCallbackResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
938 fn r#set_callback(
939 &self,
940 callback: fidl::endpoints::ClientEnd<CallbackMarker>,
941 ) -> Self::SetCallbackResponseFut;
942}
943#[derive(Debug)]
944#[cfg(target_os = "fuchsia")]
945pub struct UsbSynchronousProxy {
946 client: fidl::client::sync::Client,
947}
948
949#[cfg(target_os = "fuchsia")]
950impl fidl::endpoints::SynchronousProxy for UsbSynchronousProxy {
951 type Proxy = UsbProxy;
952 type Protocol = UsbMarker;
953
954 fn from_channel(inner: fidl::Channel) -> Self {
955 Self::new(inner)
956 }
957
958 fn into_channel(self) -> fidl::Channel {
959 self.client.into_channel()
960 }
961
962 fn as_channel(&self) -> &fidl::Channel {
963 self.client.as_channel()
964 }
965}
966
967#[cfg(target_os = "fuchsia")]
968impl UsbSynchronousProxy {
969 pub fn new(channel: fidl::Channel) -> Self {
970 let protocol_name = <UsbMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
971 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
972 }
973
974 pub fn into_channel(self) -> fidl::Channel {
975 self.client.into_channel()
976 }
977
978 pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<UsbEvent, fidl::Error> {
981 UsbEvent::decode(self.client.wait_for_event(deadline)?)
982 }
983
984 pub fn r#set_callback(
985 &self,
986 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
987 ___deadline: zx::MonotonicInstant,
988 ) -> Result<(), fidl::Error> {
989 let _response =
990 self.client.send_query::<UsbSetCallbackRequest, fidl::encoding::EmptyPayload>(
991 (callback,),
992 0x2c87fd21b8c05e0b,
993 fidl::encoding::DynamicFlags::empty(),
994 ___deadline,
995 )?;
996 Ok(_response)
997 }
998}
999
1000#[cfg(target_os = "fuchsia")]
1001impl From<UsbSynchronousProxy> for zx::Handle {
1002 fn from(value: UsbSynchronousProxy) -> Self {
1003 value.into_channel().into()
1004 }
1005}
1006
1007#[cfg(target_os = "fuchsia")]
1008impl From<fidl::Channel> for UsbSynchronousProxy {
1009 fn from(value: fidl::Channel) -> Self {
1010 Self::new(value)
1011 }
1012}
1013
1014#[cfg(target_os = "fuchsia")]
1015impl fidl::endpoints::FromClient for UsbSynchronousProxy {
1016 type Protocol = UsbMarker;
1017
1018 fn from_client(value: fidl::endpoints::ClientEnd<UsbMarker>) -> Self {
1019 Self::new(value.into_channel())
1020 }
1021}
1022
1023#[derive(Debug, Clone)]
1024pub struct UsbProxy {
1025 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1026}
1027
1028impl fidl::endpoints::Proxy for UsbProxy {
1029 type Protocol = UsbMarker;
1030
1031 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1032 Self::new(inner)
1033 }
1034
1035 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1036 self.client.into_channel().map_err(|client| Self { client })
1037 }
1038
1039 fn as_channel(&self) -> &::fidl::AsyncChannel {
1040 self.client.as_channel()
1041 }
1042}
1043
1044impl UsbProxy {
1045 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1047 let protocol_name = <UsbMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1048 Self { client: fidl::client::Client::new(channel, protocol_name) }
1049 }
1050
1051 pub fn take_event_stream(&self) -> UsbEventStream {
1057 UsbEventStream { event_receiver: self.client.take_event_receiver() }
1058 }
1059
1060 pub fn r#set_callback(
1061 &self,
1062 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
1063 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1064 UsbProxyInterface::r#set_callback(self, callback)
1065 }
1066}
1067
1068impl UsbProxyInterface for UsbProxy {
1069 type SetCallbackResponseFut =
1070 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1071 fn r#set_callback(
1072 &self,
1073 mut callback: fidl::endpoints::ClientEnd<CallbackMarker>,
1074 ) -> Self::SetCallbackResponseFut {
1075 fn _decode(
1076 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1077 ) -> Result<(), fidl::Error> {
1078 let _response = fidl::client::decode_transaction_body::<
1079 fidl::encoding::EmptyPayload,
1080 fidl::encoding::DefaultFuchsiaResourceDialect,
1081 0x2c87fd21b8c05e0b,
1082 >(_buf?)?;
1083 Ok(_response)
1084 }
1085 self.client.send_query_and_decode::<UsbSetCallbackRequest, ()>(
1086 (callback,),
1087 0x2c87fd21b8c05e0b,
1088 fidl::encoding::DynamicFlags::empty(),
1089 _decode,
1090 )
1091 }
1092}
1093
1094pub struct UsbEventStream {
1095 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1096}
1097
1098impl std::marker::Unpin for UsbEventStream {}
1099
1100impl futures::stream::FusedStream for UsbEventStream {
1101 fn is_terminated(&self) -> bool {
1102 self.event_receiver.is_terminated()
1103 }
1104}
1105
1106impl futures::Stream for UsbEventStream {
1107 type Item = Result<UsbEvent, fidl::Error>;
1108
1109 fn poll_next(
1110 mut self: std::pin::Pin<&mut Self>,
1111 cx: &mut std::task::Context<'_>,
1112 ) -> std::task::Poll<Option<Self::Item>> {
1113 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1114 &mut self.event_receiver,
1115 cx
1116 )?) {
1117 Some(buf) => std::task::Poll::Ready(Some(UsbEvent::decode(buf))),
1118 None => std::task::Poll::Ready(None),
1119 }
1120 }
1121}
1122
1123#[derive(Debug)]
1124pub enum UsbEvent {}
1125
1126impl UsbEvent {
1127 fn decode(
1129 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1130 ) -> Result<UsbEvent, fidl::Error> {
1131 let (bytes, _handles) = buf.split_mut();
1132 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1133 debug_assert_eq!(tx_header.tx_id, 0);
1134 match tx_header.ordinal {
1135 _ => Err(fidl::Error::UnknownOrdinal {
1136 ordinal: tx_header.ordinal,
1137 protocol_name: <UsbMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1138 }),
1139 }
1140 }
1141}
1142
1143pub struct UsbRequestStream {
1145 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1146 is_terminated: bool,
1147}
1148
1149impl std::marker::Unpin for UsbRequestStream {}
1150
1151impl futures::stream::FusedStream for UsbRequestStream {
1152 fn is_terminated(&self) -> bool {
1153 self.is_terminated
1154 }
1155}
1156
1157impl fidl::endpoints::RequestStream for UsbRequestStream {
1158 type Protocol = UsbMarker;
1159 type ControlHandle = UsbControlHandle;
1160
1161 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1162 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1163 }
1164
1165 fn control_handle(&self) -> Self::ControlHandle {
1166 UsbControlHandle { inner: self.inner.clone() }
1167 }
1168
1169 fn into_inner(
1170 self,
1171 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1172 {
1173 (self.inner, self.is_terminated)
1174 }
1175
1176 fn from_inner(
1177 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1178 is_terminated: bool,
1179 ) -> Self {
1180 Self { inner, is_terminated }
1181 }
1182}
1183
1184impl futures::Stream for UsbRequestStream {
1185 type Item = Result<UsbRequest, fidl::Error>;
1186
1187 fn poll_next(
1188 mut self: std::pin::Pin<&mut Self>,
1189 cx: &mut std::task::Context<'_>,
1190 ) -> std::task::Poll<Option<Self::Item>> {
1191 let this = &mut *self;
1192 if this.inner.check_shutdown(cx) {
1193 this.is_terminated = true;
1194 return std::task::Poll::Ready(None);
1195 }
1196 if this.is_terminated {
1197 panic!("polled UsbRequestStream after completion");
1198 }
1199 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1200 |bytes, handles| {
1201 match this.inner.channel().read_etc(cx, bytes, handles) {
1202 std::task::Poll::Ready(Ok(())) => {}
1203 std::task::Poll::Pending => return std::task::Poll::Pending,
1204 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1205 this.is_terminated = true;
1206 return std::task::Poll::Ready(None);
1207 }
1208 std::task::Poll::Ready(Err(e)) => {
1209 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1210 e.into(),
1211 ))))
1212 }
1213 }
1214
1215 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1217
1218 std::task::Poll::Ready(Some(match header.ordinal {
1219 0x2c87fd21b8c05e0b => {
1220 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1221 let mut req = fidl::new_empty!(
1222 UsbSetCallbackRequest,
1223 fidl::encoding::DefaultFuchsiaResourceDialect
1224 );
1225 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsbSetCallbackRequest>(&header, _body_bytes, handles, &mut req)?;
1226 let control_handle = UsbControlHandle { inner: this.inner.clone() };
1227 Ok(UsbRequest::SetCallback {
1228 callback: req.callback,
1229
1230 responder: UsbSetCallbackResponder {
1231 control_handle: std::mem::ManuallyDrop::new(control_handle),
1232 tx_id: header.tx_id,
1233 },
1234 })
1235 }
1236 _ => Err(fidl::Error::UnknownOrdinal {
1237 ordinal: header.ordinal,
1238 protocol_name: <UsbMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1239 }),
1240 }))
1241 },
1242 )
1243 }
1244}
1245
1246#[derive(Debug)]
1247pub enum UsbRequest {
1248 SetCallback {
1249 callback: fidl::endpoints::ClientEnd<CallbackMarker>,
1250 responder: UsbSetCallbackResponder,
1251 },
1252}
1253
1254impl UsbRequest {
1255 #[allow(irrefutable_let_patterns)]
1256 pub fn into_set_callback(
1257 self,
1258 ) -> Option<(fidl::endpoints::ClientEnd<CallbackMarker>, UsbSetCallbackResponder)> {
1259 if let UsbRequest::SetCallback { callback, responder } = self {
1260 Some((callback, responder))
1261 } else {
1262 None
1263 }
1264 }
1265
1266 pub fn method_name(&self) -> &'static str {
1268 match *self {
1269 UsbRequest::SetCallback { .. } => "set_callback",
1270 }
1271 }
1272}
1273
1274#[derive(Debug, Clone)]
1275pub struct UsbControlHandle {
1276 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1277}
1278
1279impl fidl::endpoints::ControlHandle for UsbControlHandle {
1280 fn shutdown(&self) {
1281 self.inner.shutdown()
1282 }
1283 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1284 self.inner.shutdown_with_epitaph(status)
1285 }
1286
1287 fn is_closed(&self) -> bool {
1288 self.inner.channel().is_closed()
1289 }
1290 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1291 self.inner.channel().on_closed()
1292 }
1293
1294 #[cfg(target_os = "fuchsia")]
1295 fn signal_peer(
1296 &self,
1297 clear_mask: zx::Signals,
1298 set_mask: zx::Signals,
1299 ) -> Result<(), zx_status::Status> {
1300 use fidl::Peered;
1301 self.inner.channel().signal_peer(clear_mask, set_mask)
1302 }
1303}
1304
1305impl UsbControlHandle {}
1306
1307#[must_use = "FIDL methods require a response to be sent"]
1308#[derive(Debug)]
1309pub struct UsbSetCallbackResponder {
1310 control_handle: std::mem::ManuallyDrop<UsbControlHandle>,
1311 tx_id: u32,
1312}
1313
1314impl std::ops::Drop for UsbSetCallbackResponder {
1318 fn drop(&mut self) {
1319 self.control_handle.shutdown();
1320 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1322 }
1323}
1324
1325impl fidl::endpoints::Responder for UsbSetCallbackResponder {
1326 type ControlHandle = UsbControlHandle;
1327
1328 fn control_handle(&self) -> &UsbControlHandle {
1329 &self.control_handle
1330 }
1331
1332 fn drop_without_shutdown(mut self) {
1333 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1335 std::mem::forget(self);
1337 }
1338}
1339
1340impl UsbSetCallbackResponder {
1341 pub fn send(self) -> Result<(), fidl::Error> {
1345 let _result = self.send_raw();
1346 if _result.is_err() {
1347 self.control_handle.shutdown();
1348 }
1349 self.drop_without_shutdown();
1350 _result
1351 }
1352
1353 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1355 let _result = self.send_raw();
1356 self.drop_without_shutdown();
1357 _result
1358 }
1359
1360 fn send_raw(&self) -> Result<(), fidl::Error> {
1361 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1362 (),
1363 self.tx_id,
1364 0x2c87fd21b8c05e0b,
1365 fidl::encoding::DynamicFlags::empty(),
1366 )
1367 }
1368}
1369
1370#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1371pub struct ServiceMarker;
1372
1373#[cfg(target_os = "fuchsia")]
1374impl fidl::endpoints::ServiceMarker for ServiceMarker {
1375 type Proxy = ServiceProxy;
1376 type Request = ServiceRequest;
1377 const SERVICE_NAME: &'static str = "fuchsia.hardware.overnet.Service";
1378}
1379
1380#[cfg(target_os = "fuchsia")]
1383pub enum ServiceRequest {
1384 Device(DeviceRequestStream),
1385}
1386
1387#[cfg(target_os = "fuchsia")]
1388impl fidl::endpoints::ServiceRequest for ServiceRequest {
1389 type Service = ServiceMarker;
1390
1391 fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
1392 match name {
1393 "device" => Self::Device(
1394 <DeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
1395 ),
1396 _ => panic!("no such member protocol name for service Service"),
1397 }
1398 }
1399
1400 fn member_names() -> &'static [&'static str] {
1401 &["device"]
1402 }
1403}
1404#[cfg(target_os = "fuchsia")]
1405pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
1406
1407#[cfg(target_os = "fuchsia")]
1408impl fidl::endpoints::ServiceProxy for ServiceProxy {
1409 type Service = ServiceMarker;
1410
1411 fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
1412 Self(opener)
1413 }
1414}
1415
1416#[cfg(target_os = "fuchsia")]
1417impl ServiceProxy {
1418 pub fn connect_to_device(&self) -> Result<DeviceProxy, fidl::Error> {
1419 let (proxy, server_end) = fidl::endpoints::create_proxy::<DeviceMarker>();
1420 self.connect_channel_to_device(server_end)?;
1421 Ok(proxy)
1422 }
1423
1424 pub fn connect_to_device_sync(&self) -> Result<DeviceSynchronousProxy, fidl::Error> {
1427 let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DeviceMarker>();
1428 self.connect_channel_to_device(server_end)?;
1429 Ok(proxy)
1430 }
1431
1432 pub fn connect_channel_to_device(
1435 &self,
1436 server_end: fidl::endpoints::ServerEnd<DeviceMarker>,
1437 ) -> Result<(), fidl::Error> {
1438 self.0.open_member("device", server_end.into_channel())
1439 }
1440
1441 pub fn instance_name(&self) -> &str {
1442 self.0.instance_name()
1443 }
1444}
1445
1446#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1447pub struct UsbServiceMarker;
1448
1449#[cfg(target_os = "fuchsia")]
1450impl fidl::endpoints::ServiceMarker for UsbServiceMarker {
1451 type Proxy = UsbServiceProxy;
1452 type Request = UsbServiceRequest;
1453 const SERVICE_NAME: &'static str = "fuchsia.hardware.overnet.UsbService";
1454}
1455
1456#[cfg(target_os = "fuchsia")]
1459pub enum UsbServiceRequest {
1460 Device(UsbRequestStream),
1461}
1462
1463#[cfg(target_os = "fuchsia")]
1464impl fidl::endpoints::ServiceRequest for UsbServiceRequest {
1465 type Service = UsbServiceMarker;
1466
1467 fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
1468 match name {
1469 "device" => Self::Device(
1470 <UsbRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
1471 ),
1472 _ => panic!("no such member protocol name for service UsbService"),
1473 }
1474 }
1475
1476 fn member_names() -> &'static [&'static str] {
1477 &["device"]
1478 }
1479}
1480#[cfg(target_os = "fuchsia")]
1481pub struct UsbServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
1482
1483#[cfg(target_os = "fuchsia")]
1484impl fidl::endpoints::ServiceProxy for UsbServiceProxy {
1485 type Service = UsbServiceMarker;
1486
1487 fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
1488 Self(opener)
1489 }
1490}
1491
1492#[cfg(target_os = "fuchsia")]
1493impl UsbServiceProxy {
1494 pub fn connect_to_device(&self) -> Result<UsbProxy, fidl::Error> {
1495 let (proxy, server_end) = fidl::endpoints::create_proxy::<UsbMarker>();
1496 self.connect_channel_to_device(server_end)?;
1497 Ok(proxy)
1498 }
1499
1500 pub fn connect_to_device_sync(&self) -> Result<UsbSynchronousProxy, fidl::Error> {
1503 let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<UsbMarker>();
1504 self.connect_channel_to_device(server_end)?;
1505 Ok(proxy)
1506 }
1507
1508 pub fn connect_channel_to_device(
1511 &self,
1512 server_end: fidl::endpoints::ServerEnd<UsbMarker>,
1513 ) -> Result<(), fidl::Error> {
1514 self.0.open_member("device", server_end.into_channel())
1515 }
1516
1517 pub fn instance_name(&self) -> &str {
1518 self.0.instance_name()
1519 }
1520}
1521
1522mod internal {
1523 use super::*;
1524
1525 impl fidl::encoding::ResourceTypeMarker for CallbackNewLinkRequest {
1526 type Borrowed<'a> = &'a mut Self;
1527 fn take_or_borrow<'a>(
1528 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1529 ) -> Self::Borrowed<'a> {
1530 value
1531 }
1532 }
1533
1534 unsafe impl fidl::encoding::TypeMarker for CallbackNewLinkRequest {
1535 type Owned = Self;
1536
1537 #[inline(always)]
1538 fn inline_align(_context: fidl::encoding::Context) -> usize {
1539 4
1540 }
1541
1542 #[inline(always)]
1543 fn inline_size(_context: fidl::encoding::Context) -> usize {
1544 4
1545 }
1546 }
1547
1548 unsafe impl
1549 fidl::encoding::Encode<
1550 CallbackNewLinkRequest,
1551 fidl::encoding::DefaultFuchsiaResourceDialect,
1552 > for &mut CallbackNewLinkRequest
1553 {
1554 #[inline]
1555 unsafe fn encode(
1556 self,
1557 encoder: &mut fidl::encoding::Encoder<
1558 '_,
1559 fidl::encoding::DefaultFuchsiaResourceDialect,
1560 >,
1561 offset: usize,
1562 _depth: fidl::encoding::Depth,
1563 ) -> fidl::Result<()> {
1564 encoder.debug_check_bounds::<CallbackNewLinkRequest>(offset);
1565 fidl::encoding::Encode::<
1567 CallbackNewLinkRequest,
1568 fidl::encoding::DefaultFuchsiaResourceDialect,
1569 >::encode(
1570 (<fidl::encoding::HandleType<
1571 fidl::Socket,
1572 { fidl::ObjectType::SOCKET.into_raw() },
1573 2147483648,
1574 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1575 &mut self.socket
1576 ),),
1577 encoder,
1578 offset,
1579 _depth,
1580 )
1581 }
1582 }
1583 unsafe impl<
1584 T0: fidl::encoding::Encode<
1585 fidl::encoding::HandleType<
1586 fidl::Socket,
1587 { fidl::ObjectType::SOCKET.into_raw() },
1588 2147483648,
1589 >,
1590 fidl::encoding::DefaultFuchsiaResourceDialect,
1591 >,
1592 >
1593 fidl::encoding::Encode<
1594 CallbackNewLinkRequest,
1595 fidl::encoding::DefaultFuchsiaResourceDialect,
1596 > for (T0,)
1597 {
1598 #[inline]
1599 unsafe fn encode(
1600 self,
1601 encoder: &mut fidl::encoding::Encoder<
1602 '_,
1603 fidl::encoding::DefaultFuchsiaResourceDialect,
1604 >,
1605 offset: usize,
1606 depth: fidl::encoding::Depth,
1607 ) -> fidl::Result<()> {
1608 encoder.debug_check_bounds::<CallbackNewLinkRequest>(offset);
1609 self.0.encode(encoder, offset + 0, depth)?;
1613 Ok(())
1614 }
1615 }
1616
1617 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1618 for CallbackNewLinkRequest
1619 {
1620 #[inline(always)]
1621 fn new_empty() -> Self {
1622 Self {
1623 socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1624 }
1625 }
1626
1627 #[inline]
1628 unsafe fn decode(
1629 &mut self,
1630 decoder: &mut fidl::encoding::Decoder<
1631 '_,
1632 fidl::encoding::DefaultFuchsiaResourceDialect,
1633 >,
1634 offset: usize,
1635 _depth: fidl::encoding::Depth,
1636 ) -> fidl::Result<()> {
1637 decoder.debug_check_bounds::<Self>(offset);
1638 fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
1640 Ok(())
1641 }
1642 }
1643
1644 impl fidl::encoding::ResourceTypeMarker for DeviceSetCallbackRequest {
1645 type Borrowed<'a> = &'a mut Self;
1646 fn take_or_borrow<'a>(
1647 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1648 ) -> Self::Borrowed<'a> {
1649 value
1650 }
1651 }
1652
1653 unsafe impl fidl::encoding::TypeMarker for DeviceSetCallbackRequest {
1654 type Owned = Self;
1655
1656 #[inline(always)]
1657 fn inline_align(_context: fidl::encoding::Context) -> usize {
1658 4
1659 }
1660
1661 #[inline(always)]
1662 fn inline_size(_context: fidl::encoding::Context) -> usize {
1663 4
1664 }
1665 }
1666
1667 unsafe impl
1668 fidl::encoding::Encode<
1669 DeviceSetCallbackRequest,
1670 fidl::encoding::DefaultFuchsiaResourceDialect,
1671 > for &mut DeviceSetCallbackRequest
1672 {
1673 #[inline]
1674 unsafe fn encode(
1675 self,
1676 encoder: &mut fidl::encoding::Encoder<
1677 '_,
1678 fidl::encoding::DefaultFuchsiaResourceDialect,
1679 >,
1680 offset: usize,
1681 _depth: fidl::encoding::Depth,
1682 ) -> fidl::Result<()> {
1683 encoder.debug_check_bounds::<DeviceSetCallbackRequest>(offset);
1684 fidl::encoding::Encode::<DeviceSetCallbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1686 (
1687 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.callback),
1688 ),
1689 encoder, offset, _depth
1690 )
1691 }
1692 }
1693 unsafe impl<
1694 T0: fidl::encoding::Encode<
1695 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1696 fidl::encoding::DefaultFuchsiaResourceDialect,
1697 >,
1698 >
1699 fidl::encoding::Encode<
1700 DeviceSetCallbackRequest,
1701 fidl::encoding::DefaultFuchsiaResourceDialect,
1702 > for (T0,)
1703 {
1704 #[inline]
1705 unsafe fn encode(
1706 self,
1707 encoder: &mut fidl::encoding::Encoder<
1708 '_,
1709 fidl::encoding::DefaultFuchsiaResourceDialect,
1710 >,
1711 offset: usize,
1712 depth: fidl::encoding::Depth,
1713 ) -> fidl::Result<()> {
1714 encoder.debug_check_bounds::<DeviceSetCallbackRequest>(offset);
1715 self.0.encode(encoder, offset + 0, depth)?;
1719 Ok(())
1720 }
1721 }
1722
1723 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1724 for DeviceSetCallbackRequest
1725 {
1726 #[inline(always)]
1727 fn new_empty() -> Self {
1728 Self {
1729 callback: fidl::new_empty!(
1730 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1731 fidl::encoding::DefaultFuchsiaResourceDialect
1732 ),
1733 }
1734 }
1735
1736 #[inline]
1737 unsafe fn decode(
1738 &mut self,
1739 decoder: &mut fidl::encoding::Decoder<
1740 '_,
1741 fidl::encoding::DefaultFuchsiaResourceDialect,
1742 >,
1743 offset: usize,
1744 _depth: fidl::encoding::Depth,
1745 ) -> fidl::Result<()> {
1746 decoder.debug_check_bounds::<Self>(offset);
1747 fidl::decode!(
1749 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1750 fidl::encoding::DefaultFuchsiaResourceDialect,
1751 &mut self.callback,
1752 decoder,
1753 offset + 0,
1754 _depth
1755 )?;
1756 Ok(())
1757 }
1758 }
1759
1760 impl fidl::encoding::ResourceTypeMarker for UsbSetCallbackRequest {
1761 type Borrowed<'a> = &'a mut Self;
1762 fn take_or_borrow<'a>(
1763 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1764 ) -> Self::Borrowed<'a> {
1765 value
1766 }
1767 }
1768
1769 unsafe impl fidl::encoding::TypeMarker for UsbSetCallbackRequest {
1770 type Owned = Self;
1771
1772 #[inline(always)]
1773 fn inline_align(_context: fidl::encoding::Context) -> usize {
1774 4
1775 }
1776
1777 #[inline(always)]
1778 fn inline_size(_context: fidl::encoding::Context) -> usize {
1779 4
1780 }
1781 }
1782
1783 unsafe impl
1784 fidl::encoding::Encode<UsbSetCallbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1785 for &mut UsbSetCallbackRequest
1786 {
1787 #[inline]
1788 unsafe fn encode(
1789 self,
1790 encoder: &mut fidl::encoding::Encoder<
1791 '_,
1792 fidl::encoding::DefaultFuchsiaResourceDialect,
1793 >,
1794 offset: usize,
1795 _depth: fidl::encoding::Depth,
1796 ) -> fidl::Result<()> {
1797 encoder.debug_check_bounds::<UsbSetCallbackRequest>(offset);
1798 fidl::encoding::Encode::<UsbSetCallbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1800 (
1801 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.callback),
1802 ),
1803 encoder, offset, _depth
1804 )
1805 }
1806 }
1807 unsafe impl<
1808 T0: fidl::encoding::Encode<
1809 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1810 fidl::encoding::DefaultFuchsiaResourceDialect,
1811 >,
1812 >
1813 fidl::encoding::Encode<UsbSetCallbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1814 for (T0,)
1815 {
1816 #[inline]
1817 unsafe fn encode(
1818 self,
1819 encoder: &mut fidl::encoding::Encoder<
1820 '_,
1821 fidl::encoding::DefaultFuchsiaResourceDialect,
1822 >,
1823 offset: usize,
1824 depth: fidl::encoding::Depth,
1825 ) -> fidl::Result<()> {
1826 encoder.debug_check_bounds::<UsbSetCallbackRequest>(offset);
1827 self.0.encode(encoder, offset + 0, depth)?;
1831 Ok(())
1832 }
1833 }
1834
1835 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1836 for UsbSetCallbackRequest
1837 {
1838 #[inline(always)]
1839 fn new_empty() -> Self {
1840 Self {
1841 callback: fidl::new_empty!(
1842 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1843 fidl::encoding::DefaultFuchsiaResourceDialect
1844 ),
1845 }
1846 }
1847
1848 #[inline]
1849 unsafe fn decode(
1850 &mut self,
1851 decoder: &mut fidl::encoding::Decoder<
1852 '_,
1853 fidl::encoding::DefaultFuchsiaResourceDialect,
1854 >,
1855 offset: usize,
1856 _depth: fidl::encoding::Depth,
1857 ) -> fidl::Result<()> {
1858 decoder.debug_check_bounds::<Self>(offset);
1859 fidl::decode!(
1861 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallbackMarker>>,
1862 fidl::encoding::DefaultFuchsiaResourceDialect,
1863 &mut self.callback,
1864 decoder,
1865 offset + 0,
1866 _depth
1867 )?;
1868 Ok(())
1869 }
1870 }
1871}