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

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
