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

fidl_fuchsia_testing_sl4f/
fidl_fuchsia_testing_sl4f.rs
