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