fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs

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

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
