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

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
