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

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
