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 { Some((responder)) } else { None }
1066    }
1067
1068    /// Name of the method defined in FIDL
1069    pub fn method_name(&self) -> &'static str {
1070        match *self {
1071            FacadeProviderRequest::GetFacades { .. } => "get_facades",
1072            FacadeProviderRequest::Execute { .. } => "execute",
1073            FacadeProviderRequest::Cleanup { .. } => "cleanup",
1074            FacadeProviderRequest::Print { .. } => "print",
1075        }
1076    }
1077}
1078
1079#[derive(Debug, Clone)]
1080pub struct FacadeProviderControlHandle {
1081    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1082}
1083
1084impl fidl::endpoints::ControlHandle for FacadeProviderControlHandle {
1085    fn shutdown(&self) {
1086        self.inner.shutdown()
1087    }
1088    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1089        self.inner.shutdown_with_epitaph(status)
1090    }
1091
1092    fn is_closed(&self) -> bool {
1093        self.inner.channel().is_closed()
1094    }
1095    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1096        self.inner.channel().on_closed()
1097    }
1098
1099    #[cfg(target_os = "fuchsia")]
1100    fn signal_peer(
1101        &self,
1102        clear_mask: zx::Signals,
1103        set_mask: zx::Signals,
1104    ) -> Result<(), zx_status::Status> {
1105        use fidl::Peered;
1106        self.inner.channel().signal_peer(clear_mask, set_mask)
1107    }
1108}
1109
1110impl FacadeProviderControlHandle {}
1111
1112#[must_use = "FIDL methods require a response to be sent"]
1113#[derive(Debug)]
1114pub struct FacadeProviderExecuteResponder {
1115    control_handle: std::mem::ManuallyDrop<FacadeProviderControlHandle>,
1116    tx_id: u32,
1117}
1118
1119/// Set the the channel to be shutdown (see [`FacadeProviderControlHandle::shutdown`])
1120/// if the responder is dropped without sending a response, so that the client
1121/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1122impl std::ops::Drop for FacadeProviderExecuteResponder {
1123    fn drop(&mut self) {
1124        self.control_handle.shutdown();
1125        // Safety: drops once, never accessed again
1126        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1127    }
1128}
1129
1130impl fidl::endpoints::Responder for FacadeProviderExecuteResponder {
1131    type ControlHandle = FacadeProviderControlHandle;
1132
1133    fn control_handle(&self) -> &FacadeProviderControlHandle {
1134        &self.control_handle
1135    }
1136
1137    fn drop_without_shutdown(mut self) {
1138        // Safety: drops once, never accessed again due to mem::forget
1139        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1140        // Prevent Drop from running (which would shut down the channel)
1141        std::mem::forget(self);
1142    }
1143}
1144
1145impl FacadeProviderExecuteResponder {
1146    /// Sends a response to the FIDL transaction.
1147    ///
1148    /// Sets the channel to shutdown if an error occurs.
1149    pub fn send(
1150        self,
1151        mut result_blob: Option<fidl::Vmo>,
1152        mut error: Option<&str>,
1153    ) -> Result<(), fidl::Error> {
1154        let _result = self.send_raw(result_blob, error);
1155        if _result.is_err() {
1156            self.control_handle.shutdown();
1157        }
1158        self.drop_without_shutdown();
1159        _result
1160    }
1161
1162    /// Similar to "send" but does not shutdown the channel if an error occurs.
1163    pub fn send_no_shutdown_on_err(
1164        self,
1165        mut result_blob: Option<fidl::Vmo>,
1166        mut error: Option<&str>,
1167    ) -> Result<(), fidl::Error> {
1168        let _result = self.send_raw(result_blob, error);
1169        self.drop_without_shutdown();
1170        _result
1171    }
1172
1173    fn send_raw(
1174        &self,
1175        mut result_blob: Option<fidl::Vmo>,
1176        mut error: Option<&str>,
1177    ) -> Result<(), fidl::Error> {
1178        self.control_handle.inner.send::<FacadeProviderExecuteResponse>(
1179            (result_blob, error),
1180            self.tx_id,
1181            0x7d6de537b3caf392,
1182            fidl::encoding::DynamicFlags::empty(),
1183        )
1184    }
1185}
1186
1187#[must_use = "FIDL methods require a response to be sent"]
1188#[derive(Debug)]
1189pub struct FacadeProviderCleanupResponder {
1190    control_handle: std::mem::ManuallyDrop<FacadeProviderControlHandle>,
1191    tx_id: u32,
1192}
1193
1194/// Set the the channel to be shutdown (see [`FacadeProviderControlHandle::shutdown`])
1195/// if the responder is dropped without sending a response, so that the client
1196/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1197impl std::ops::Drop for FacadeProviderCleanupResponder {
1198    fn drop(&mut self) {
1199        self.control_handle.shutdown();
1200        // Safety: drops once, never accessed again
1201        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1202    }
1203}
1204
1205impl fidl::endpoints::Responder for FacadeProviderCleanupResponder {
1206    type ControlHandle = FacadeProviderControlHandle;
1207
1208    fn control_handle(&self) -> &FacadeProviderControlHandle {
1209        &self.control_handle
1210    }
1211
1212    fn drop_without_shutdown(mut self) {
1213        // Safety: drops once, never accessed again due to mem::forget
1214        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1215        // Prevent Drop from running (which would shut down the channel)
1216        std::mem::forget(self);
1217    }
1218}
1219
1220impl FacadeProviderCleanupResponder {
1221    /// Sends a response to the FIDL transaction.
1222    ///
1223    /// Sets the channel to shutdown if an error occurs.
1224    pub fn send(self) -> Result<(), fidl::Error> {
1225        let _result = self.send_raw();
1226        if _result.is_err() {
1227            self.control_handle.shutdown();
1228        }
1229        self.drop_without_shutdown();
1230        _result
1231    }
1232
1233    /// Similar to "send" but does not shutdown the channel if an error occurs.
1234    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1235        let _result = self.send_raw();
1236        self.drop_without_shutdown();
1237        _result
1238    }
1239
1240    fn send_raw(&self) -> Result<(), fidl::Error> {
1241        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1242            (),
1243            self.tx_id,
1244            0x3d3accf7ad309712,
1245            fidl::encoding::DynamicFlags::empty(),
1246        )
1247    }
1248}
1249
1250#[must_use = "FIDL methods require a response to be sent"]
1251#[derive(Debug)]
1252pub struct FacadeProviderPrintResponder {
1253    control_handle: std::mem::ManuallyDrop<FacadeProviderControlHandle>,
1254    tx_id: u32,
1255}
1256
1257/// Set the the channel to be shutdown (see [`FacadeProviderControlHandle::shutdown`])
1258/// if the responder is dropped without sending a response, so that the client
1259/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1260impl std::ops::Drop for FacadeProviderPrintResponder {
1261    fn drop(&mut self) {
1262        self.control_handle.shutdown();
1263        // Safety: drops once, never accessed again
1264        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1265    }
1266}
1267
1268impl fidl::endpoints::Responder for FacadeProviderPrintResponder {
1269    type ControlHandle = FacadeProviderControlHandle;
1270
1271    fn control_handle(&self) -> &FacadeProviderControlHandle {
1272        &self.control_handle
1273    }
1274
1275    fn drop_without_shutdown(mut self) {
1276        // Safety: drops once, never accessed again due to mem::forget
1277        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1278        // Prevent Drop from running (which would shut down the channel)
1279        std::mem::forget(self);
1280    }
1281}
1282
1283impl FacadeProviderPrintResponder {
1284    /// Sends a response to the FIDL transaction.
1285    ///
1286    /// Sets the channel to shutdown if an error occurs.
1287    pub fn send(self) -> Result<(), fidl::Error> {
1288        let _result = self.send_raw();
1289        if _result.is_err() {
1290            self.control_handle.shutdown();
1291        }
1292        self.drop_without_shutdown();
1293        _result
1294    }
1295
1296    /// Similar to "send" but does not shutdown the channel if an error occurs.
1297    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1298        let _result = self.send_raw();
1299        self.drop_without_shutdown();
1300        _result
1301    }
1302
1303    fn send_raw(&self) -> Result<(), fidl::Error> {
1304        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1305            (),
1306            self.tx_id,
1307            0x3e8853ac2d3a18d7,
1308            fidl::encoding::DynamicFlags::empty(),
1309        )
1310    }
1311}
1312
1313mod internal {
1314    use super::*;
1315
1316    impl fidl::encoding::ResourceTypeMarker for FacadeProviderExecuteRequest {
1317        type Borrowed<'a> = &'a mut Self;
1318        fn take_or_borrow<'a>(
1319            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1320        ) -> Self::Borrowed<'a> {
1321            value
1322        }
1323    }
1324
1325    unsafe impl fidl::encoding::TypeMarker for FacadeProviderExecuteRequest {
1326        type Owned = Self;
1327
1328        #[inline(always)]
1329        fn inline_align(_context: fidl::encoding::Context) -> usize {
1330            8
1331        }
1332
1333        #[inline(always)]
1334        fn inline_size(_context: fidl::encoding::Context) -> usize {
1335            40
1336        }
1337    }
1338
1339    unsafe impl
1340        fidl::encoding::Encode<
1341            FacadeProviderExecuteRequest,
1342            fidl::encoding::DefaultFuchsiaResourceDialect,
1343        > for &mut FacadeProviderExecuteRequest
1344    {
1345        #[inline]
1346        unsafe fn encode(
1347            self,
1348            encoder: &mut fidl::encoding::Encoder<
1349                '_,
1350                fidl::encoding::DefaultFuchsiaResourceDialect,
1351            >,
1352            offset: usize,
1353            _depth: fidl::encoding::Depth,
1354        ) -> fidl::Result<()> {
1355            encoder.debug_check_bounds::<FacadeProviderExecuteRequest>(offset);
1356            // Delegate to tuple encoding.
1357            fidl::encoding::Encode::<
1358                FacadeProviderExecuteRequest,
1359                fidl::encoding::DefaultFuchsiaResourceDialect,
1360            >::encode(
1361                (
1362                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
1363                        &self.facade,
1364                    ),
1365                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
1366                        &self.command,
1367                    ),
1368                    <fidl::encoding::HandleType<
1369                        fidl::Vmo,
1370                        { fidl::ObjectType::VMO.into_raw() },
1371                        2147483648,
1372                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1373                        &mut self.params_blob
1374                    ),
1375                ),
1376                encoder,
1377                offset,
1378                _depth,
1379            )
1380        }
1381    }
1382    unsafe impl<
1383        T0: fidl::encoding::Encode<
1384                fidl::encoding::UnboundedString,
1385                fidl::encoding::DefaultFuchsiaResourceDialect,
1386            >,
1387        T1: fidl::encoding::Encode<
1388                fidl::encoding::UnboundedString,
1389                fidl::encoding::DefaultFuchsiaResourceDialect,
1390            >,
1391        T2: fidl::encoding::Encode<
1392                fidl::encoding::HandleType<
1393                    fidl::Vmo,
1394                    { fidl::ObjectType::VMO.into_raw() },
1395                    2147483648,
1396                >,
1397                fidl::encoding::DefaultFuchsiaResourceDialect,
1398            >,
1399    >
1400        fidl::encoding::Encode<
1401            FacadeProviderExecuteRequest,
1402            fidl::encoding::DefaultFuchsiaResourceDialect,
1403        > for (T0, T1, T2)
1404    {
1405        #[inline]
1406        unsafe fn encode(
1407            self,
1408            encoder: &mut fidl::encoding::Encoder<
1409                '_,
1410                fidl::encoding::DefaultFuchsiaResourceDialect,
1411            >,
1412            offset: usize,
1413            depth: fidl::encoding::Depth,
1414        ) -> fidl::Result<()> {
1415            encoder.debug_check_bounds::<FacadeProviderExecuteRequest>(offset);
1416            // Zero out padding regions. There's no need to apply masks
1417            // because the unmasked parts will be overwritten by fields.
1418            unsafe {
1419                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
1420                (ptr as *mut u64).write_unaligned(0);
1421            }
1422            // Write the fields.
1423            self.0.encode(encoder, offset + 0, depth)?;
1424            self.1.encode(encoder, offset + 16, depth)?;
1425            self.2.encode(encoder, offset + 32, depth)?;
1426            Ok(())
1427        }
1428    }
1429
1430    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1431        for FacadeProviderExecuteRequest
1432    {
1433        #[inline(always)]
1434        fn new_empty() -> Self {
1435            Self {
1436                facade: fidl::new_empty!(
1437                    fidl::encoding::UnboundedString,
1438                    fidl::encoding::DefaultFuchsiaResourceDialect
1439                ),
1440                command: fidl::new_empty!(
1441                    fidl::encoding::UnboundedString,
1442                    fidl::encoding::DefaultFuchsiaResourceDialect
1443                ),
1444                params_blob: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1445            }
1446        }
1447
1448        #[inline]
1449        unsafe fn decode(
1450            &mut self,
1451            decoder: &mut fidl::encoding::Decoder<
1452                '_,
1453                fidl::encoding::DefaultFuchsiaResourceDialect,
1454            >,
1455            offset: usize,
1456            _depth: fidl::encoding::Depth,
1457        ) -> fidl::Result<()> {
1458            decoder.debug_check_bounds::<Self>(offset);
1459            // Verify that padding bytes are zero.
1460            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
1461            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1462            let mask = 0xffffffff00000000u64;
1463            let maskedval = padval & mask;
1464            if maskedval != 0 {
1465                return Err(fidl::Error::NonZeroPadding {
1466                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
1467                });
1468            }
1469            fidl::decode!(
1470                fidl::encoding::UnboundedString,
1471                fidl::encoding::DefaultFuchsiaResourceDialect,
1472                &mut self.facade,
1473                decoder,
1474                offset + 0,
1475                _depth
1476            )?;
1477            fidl::decode!(
1478                fidl::encoding::UnboundedString,
1479                fidl::encoding::DefaultFuchsiaResourceDialect,
1480                &mut self.command,
1481                decoder,
1482                offset + 16,
1483                _depth
1484            )?;
1485            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.params_blob, decoder, offset + 32, _depth)?;
1486            Ok(())
1487        }
1488    }
1489
1490    impl fidl::encoding::ResourceTypeMarker for FacadeProviderExecuteResponse {
1491        type Borrowed<'a> = &'a mut Self;
1492        fn take_or_borrow<'a>(
1493            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1494        ) -> Self::Borrowed<'a> {
1495            value
1496        }
1497    }
1498
1499    unsafe impl fidl::encoding::TypeMarker for FacadeProviderExecuteResponse {
1500        type Owned = Self;
1501
1502        #[inline(always)]
1503        fn inline_align(_context: fidl::encoding::Context) -> usize {
1504            8
1505        }
1506
1507        #[inline(always)]
1508        fn inline_size(_context: fidl::encoding::Context) -> usize {
1509            24
1510        }
1511    }
1512
1513    unsafe impl
1514        fidl::encoding::Encode<
1515            FacadeProviderExecuteResponse,
1516            fidl::encoding::DefaultFuchsiaResourceDialect,
1517        > for &mut FacadeProviderExecuteResponse
1518    {
1519        #[inline]
1520        unsafe fn encode(
1521            self,
1522            encoder: &mut fidl::encoding::Encoder<
1523                '_,
1524                fidl::encoding::DefaultFuchsiaResourceDialect,
1525            >,
1526            offset: usize,
1527            _depth: fidl::encoding::Depth,
1528        ) -> fidl::Result<()> {
1529            encoder.debug_check_bounds::<FacadeProviderExecuteResponse>(offset);
1530            // Delegate to tuple encoding.
1531            fidl::encoding::Encode::<FacadeProviderExecuteResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1532                (
1533                    <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),
1534                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.error),
1535                ),
1536                encoder, offset, _depth
1537            )
1538        }
1539    }
1540    unsafe impl<
1541        T0: fidl::encoding::Encode<
1542                fidl::encoding::Optional<
1543                    fidl::encoding::HandleType<
1544                        fidl::Vmo,
1545                        { fidl::ObjectType::VMO.into_raw() },
1546                        2147483648,
1547                    >,
1548                >,
1549                fidl::encoding::DefaultFuchsiaResourceDialect,
1550            >,
1551        T1: fidl::encoding::Encode<
1552                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1553                fidl::encoding::DefaultFuchsiaResourceDialect,
1554            >,
1555    >
1556        fidl::encoding::Encode<
1557            FacadeProviderExecuteResponse,
1558            fidl::encoding::DefaultFuchsiaResourceDialect,
1559        > for (T0, T1)
1560    {
1561        #[inline]
1562        unsafe fn encode(
1563            self,
1564            encoder: &mut fidl::encoding::Encoder<
1565                '_,
1566                fidl::encoding::DefaultFuchsiaResourceDialect,
1567            >,
1568            offset: usize,
1569            depth: fidl::encoding::Depth,
1570        ) -> fidl::Result<()> {
1571            encoder.debug_check_bounds::<FacadeProviderExecuteResponse>(offset);
1572            // Zero out padding regions. There's no need to apply masks
1573            // because the unmasked parts will be overwritten by fields.
1574            unsafe {
1575                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1576                (ptr as *mut u64).write_unaligned(0);
1577            }
1578            // Write the fields.
1579            self.0.encode(encoder, offset + 0, depth)?;
1580            self.1.encode(encoder, offset + 8, depth)?;
1581            Ok(())
1582        }
1583    }
1584
1585    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1586        for FacadeProviderExecuteResponse
1587    {
1588        #[inline(always)]
1589        fn new_empty() -> Self {
1590            Self {
1591                result_blob: fidl::new_empty!(
1592                    fidl::encoding::Optional<
1593                        fidl::encoding::HandleType<
1594                            fidl::Vmo,
1595                            { fidl::ObjectType::VMO.into_raw() },
1596                            2147483648,
1597                        >,
1598                    >,
1599                    fidl::encoding::DefaultFuchsiaResourceDialect
1600                ),
1601                error: fidl::new_empty!(
1602                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1603                    fidl::encoding::DefaultFuchsiaResourceDialect
1604                ),
1605            }
1606        }
1607
1608        #[inline]
1609        unsafe fn decode(
1610            &mut self,
1611            decoder: &mut fidl::encoding::Decoder<
1612                '_,
1613                fidl::encoding::DefaultFuchsiaResourceDialect,
1614            >,
1615            offset: usize,
1616            _depth: fidl::encoding::Depth,
1617        ) -> fidl::Result<()> {
1618            decoder.debug_check_bounds::<Self>(offset);
1619            // Verify that padding bytes are zero.
1620            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1621            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1622            let mask = 0xffffffff00000000u64;
1623            let maskedval = padval & mask;
1624            if maskedval != 0 {
1625                return Err(fidl::Error::NonZeroPadding {
1626                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1627                });
1628            }
1629            fidl::decode!(
1630                fidl::encoding::Optional<
1631                    fidl::encoding::HandleType<
1632                        fidl::Vmo,
1633                        { fidl::ObjectType::VMO.into_raw() },
1634                        2147483648,
1635                    >,
1636                >,
1637                fidl::encoding::DefaultFuchsiaResourceDialect,
1638                &mut self.result_blob,
1639                decoder,
1640                offset + 0,
1641                _depth
1642            )?;
1643            fidl::decode!(
1644                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1645                fidl::encoding::DefaultFuchsiaResourceDialect,
1646                &mut self.error,
1647                decoder,
1648                offset + 8,
1649                _depth
1650            )?;
1651            Ok(())
1652        }
1653    }
1654
1655    impl fidl::encoding::ResourceTypeMarker for FacadeProviderGetFacadesRequest {
1656        type Borrowed<'a> = &'a mut Self;
1657        fn take_or_borrow<'a>(
1658            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1659        ) -> Self::Borrowed<'a> {
1660            value
1661        }
1662    }
1663
1664    unsafe impl fidl::encoding::TypeMarker for FacadeProviderGetFacadesRequest {
1665        type Owned = Self;
1666
1667        #[inline(always)]
1668        fn inline_align(_context: fidl::encoding::Context) -> usize {
1669            4
1670        }
1671
1672        #[inline(always)]
1673        fn inline_size(_context: fidl::encoding::Context) -> usize {
1674            4
1675        }
1676    }
1677
1678    unsafe impl
1679        fidl::encoding::Encode<
1680            FacadeProviderGetFacadesRequest,
1681            fidl::encoding::DefaultFuchsiaResourceDialect,
1682        > for &mut FacadeProviderGetFacadesRequest
1683    {
1684        #[inline]
1685        unsafe fn encode(
1686            self,
1687            encoder: &mut fidl::encoding::Encoder<
1688                '_,
1689                fidl::encoding::DefaultFuchsiaResourceDialect,
1690            >,
1691            offset: usize,
1692            _depth: fidl::encoding::Depth,
1693        ) -> fidl::Result<()> {
1694            encoder.debug_check_bounds::<FacadeProviderGetFacadesRequest>(offset);
1695            // Delegate to tuple encoding.
1696            fidl::encoding::Encode::<FacadeProviderGetFacadesRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1697                (
1698                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FacadeIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iterator),
1699                ),
1700                encoder, offset, _depth
1701            )
1702        }
1703    }
1704    unsafe impl<
1705        T0: fidl::encoding::Encode<
1706                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FacadeIteratorMarker>>,
1707                fidl::encoding::DefaultFuchsiaResourceDialect,
1708            >,
1709    >
1710        fidl::encoding::Encode<
1711            FacadeProviderGetFacadesRequest,
1712            fidl::encoding::DefaultFuchsiaResourceDialect,
1713        > for (T0,)
1714    {
1715        #[inline]
1716        unsafe fn encode(
1717            self,
1718            encoder: &mut fidl::encoding::Encoder<
1719                '_,
1720                fidl::encoding::DefaultFuchsiaResourceDialect,
1721            >,
1722            offset: usize,
1723            depth: fidl::encoding::Depth,
1724        ) -> fidl::Result<()> {
1725            encoder.debug_check_bounds::<FacadeProviderGetFacadesRequest>(offset);
1726            // Zero out padding regions. There's no need to apply masks
1727            // because the unmasked parts will be overwritten by fields.
1728            // Write the fields.
1729            self.0.encode(encoder, offset + 0, depth)?;
1730            Ok(())
1731        }
1732    }
1733
1734    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1735        for FacadeProviderGetFacadesRequest
1736    {
1737        #[inline(always)]
1738        fn new_empty() -> Self {
1739            Self {
1740                iterator: fidl::new_empty!(
1741                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FacadeIteratorMarker>>,
1742                    fidl::encoding::DefaultFuchsiaResourceDialect
1743                ),
1744            }
1745        }
1746
1747        #[inline]
1748        unsafe fn decode(
1749            &mut self,
1750            decoder: &mut fidl::encoding::Decoder<
1751                '_,
1752                fidl::encoding::DefaultFuchsiaResourceDialect,
1753            >,
1754            offset: usize,
1755            _depth: fidl::encoding::Depth,
1756        ) -> fidl::Result<()> {
1757            decoder.debug_check_bounds::<Self>(offset);
1758            // Verify that padding bytes are zero.
1759            fidl::decode!(
1760                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FacadeIteratorMarker>>,
1761                fidl::encoding::DefaultFuchsiaResourceDialect,
1762                &mut self.iterator,
1763                decoder,
1764                offset + 0,
1765                _depth
1766            )?;
1767            Ok(())
1768        }
1769    }
1770}
fidl_fuchsia_testing_sl4f/fidl_fuchsia_testing_sl4f.rs

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
