fidl_fuchsia_test_runner/
fidl_fuchsia_test_runner.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(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
14pub struct LibraryLoaderCacheBuilderCreateRequest {
15    pub lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
16    pub cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for LibraryLoaderCacheBuilderCreateRequest
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct LibraryLoaderCacheServeRequest {
26    pub loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
30    for LibraryLoaderCacheServeRequest
31{
32}
33
34#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
35pub struct LibraryLoaderCacheMarker;
36
37impl fidl::endpoints::ProtocolMarker for LibraryLoaderCacheMarker {
38    type Proxy = LibraryLoaderCacheProxy;
39    type RequestStream = LibraryLoaderCacheRequestStream;
40    #[cfg(target_os = "fuchsia")]
41    type SynchronousProxy = LibraryLoaderCacheSynchronousProxy;
42
43    const DEBUG_NAME: &'static str = "(anonymous) LibraryLoaderCache";
44}
45
46pub trait LibraryLoaderCacheProxyInterface: Send + Sync {
47    fn r#serve(
48        &self,
49        loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
50    ) -> Result<(), fidl::Error>;
51}
52#[derive(Debug)]
53#[cfg(target_os = "fuchsia")]
54pub struct LibraryLoaderCacheSynchronousProxy {
55    client: fidl::client::sync::Client,
56}
57
58#[cfg(target_os = "fuchsia")]
59impl fidl::endpoints::SynchronousProxy for LibraryLoaderCacheSynchronousProxy {
60    type Proxy = LibraryLoaderCacheProxy;
61    type Protocol = LibraryLoaderCacheMarker;
62
63    fn from_channel(inner: fidl::Channel) -> Self {
64        Self::new(inner)
65    }
66
67    fn into_channel(self) -> fidl::Channel {
68        self.client.into_channel()
69    }
70
71    fn as_channel(&self) -> &fidl::Channel {
72        self.client.as_channel()
73    }
74}
75
76#[cfg(target_os = "fuchsia")]
77impl LibraryLoaderCacheSynchronousProxy {
78    pub fn new(channel: fidl::Channel) -> Self {
79        let protocol_name =
80            <LibraryLoaderCacheMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
81        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
82    }
83
84    pub fn into_channel(self) -> fidl::Channel {
85        self.client.into_channel()
86    }
87
88    /// Waits until an event arrives and returns it. It is safe for other
89    /// threads to make concurrent requests while waiting for an event.
90    pub fn wait_for_event(
91        &self,
92        deadline: zx::MonotonicInstant,
93    ) -> Result<LibraryLoaderCacheEvent, fidl::Error> {
94        LibraryLoaderCacheEvent::decode(self.client.wait_for_event(deadline)?)
95    }
96
97    /// Serve the cache over provided handle.
98    pub fn r#serve(
99        &self,
100        mut loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
101    ) -> Result<(), fidl::Error> {
102        self.client.send::<LibraryLoaderCacheServeRequest>(
103            (loader,),
104            0x1940439126b02e8f,
105            fidl::encoding::DynamicFlags::empty(),
106        )
107    }
108}
109
110#[derive(Debug, Clone)]
111pub struct LibraryLoaderCacheProxy {
112    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
113}
114
115impl fidl::endpoints::Proxy for LibraryLoaderCacheProxy {
116    type Protocol = LibraryLoaderCacheMarker;
117
118    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
119        Self::new(inner)
120    }
121
122    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
123        self.client.into_channel().map_err(|client| Self { client })
124    }
125
126    fn as_channel(&self) -> &::fidl::AsyncChannel {
127        self.client.as_channel()
128    }
129}
130
131impl LibraryLoaderCacheProxy {
132    /// Create a new Proxy for fuchsia.test.runner/LibraryLoaderCache.
133    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
134        let protocol_name =
135            <LibraryLoaderCacheMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
136        Self { client: fidl::client::Client::new(channel, protocol_name) }
137    }
138
139    /// Get a Stream of events from the remote end of the protocol.
140    ///
141    /// # Panics
142    ///
143    /// Panics if the event stream was already taken.
144    pub fn take_event_stream(&self) -> LibraryLoaderCacheEventStream {
145        LibraryLoaderCacheEventStream { event_receiver: self.client.take_event_receiver() }
146    }
147
148    /// Serve the cache over provided handle.
149    pub fn r#serve(
150        &self,
151        mut loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
152    ) -> Result<(), fidl::Error> {
153        LibraryLoaderCacheProxyInterface::r#serve(self, loader)
154    }
155}
156
157impl LibraryLoaderCacheProxyInterface for LibraryLoaderCacheProxy {
158    fn r#serve(
159        &self,
160        mut loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
161    ) -> Result<(), fidl::Error> {
162        self.client.send::<LibraryLoaderCacheServeRequest>(
163            (loader,),
164            0x1940439126b02e8f,
165            fidl::encoding::DynamicFlags::empty(),
166        )
167    }
168}
169
170pub struct LibraryLoaderCacheEventStream {
171    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
172}
173
174impl std::marker::Unpin for LibraryLoaderCacheEventStream {}
175
176impl futures::stream::FusedStream for LibraryLoaderCacheEventStream {
177    fn is_terminated(&self) -> bool {
178        self.event_receiver.is_terminated()
179    }
180}
181
182impl futures::Stream for LibraryLoaderCacheEventStream {
183    type Item = Result<LibraryLoaderCacheEvent, fidl::Error>;
184
185    fn poll_next(
186        mut self: std::pin::Pin<&mut Self>,
187        cx: &mut std::task::Context<'_>,
188    ) -> std::task::Poll<Option<Self::Item>> {
189        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
190            &mut self.event_receiver,
191            cx
192        )?) {
193            Some(buf) => std::task::Poll::Ready(Some(LibraryLoaderCacheEvent::decode(buf))),
194            None => std::task::Poll::Ready(None),
195        }
196    }
197}
198
199#[derive(Debug)]
200pub enum LibraryLoaderCacheEvent {}
201
202impl LibraryLoaderCacheEvent {
203    /// Decodes a message buffer as a [`LibraryLoaderCacheEvent`].
204    fn decode(
205        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
206    ) -> Result<LibraryLoaderCacheEvent, fidl::Error> {
207        let (bytes, _handles) = buf.split_mut();
208        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
209        debug_assert_eq!(tx_header.tx_id, 0);
210        match tx_header.ordinal {
211            _ => Err(fidl::Error::UnknownOrdinal {
212                ordinal: tx_header.ordinal,
213                protocol_name:
214                    <LibraryLoaderCacheMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
215            }),
216        }
217    }
218}
219
220/// A Stream of incoming requests for fuchsia.test.runner/LibraryLoaderCache.
221pub struct LibraryLoaderCacheRequestStream {
222    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
223    is_terminated: bool,
224}
225
226impl std::marker::Unpin for LibraryLoaderCacheRequestStream {}
227
228impl futures::stream::FusedStream for LibraryLoaderCacheRequestStream {
229    fn is_terminated(&self) -> bool {
230        self.is_terminated
231    }
232}
233
234impl fidl::endpoints::RequestStream for LibraryLoaderCacheRequestStream {
235    type Protocol = LibraryLoaderCacheMarker;
236    type ControlHandle = LibraryLoaderCacheControlHandle;
237
238    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
239        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
240    }
241
242    fn control_handle(&self) -> Self::ControlHandle {
243        LibraryLoaderCacheControlHandle { inner: self.inner.clone() }
244    }
245
246    fn into_inner(
247        self,
248    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
249    {
250        (self.inner, self.is_terminated)
251    }
252
253    fn from_inner(
254        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
255        is_terminated: bool,
256    ) -> Self {
257        Self { inner, is_terminated }
258    }
259}
260
261impl futures::Stream for LibraryLoaderCacheRequestStream {
262    type Item = Result<LibraryLoaderCacheRequest, fidl::Error>;
263
264    fn poll_next(
265        mut self: std::pin::Pin<&mut Self>,
266        cx: &mut std::task::Context<'_>,
267    ) -> std::task::Poll<Option<Self::Item>> {
268        let this = &mut *self;
269        if this.inner.check_shutdown(cx) {
270            this.is_terminated = true;
271            return std::task::Poll::Ready(None);
272        }
273        if this.is_terminated {
274            panic!("polled LibraryLoaderCacheRequestStream after completion");
275        }
276        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
277            |bytes, handles| {
278                match this.inner.channel().read_etc(cx, bytes, handles) {
279                    std::task::Poll::Ready(Ok(())) => {}
280                    std::task::Poll::Pending => return std::task::Poll::Pending,
281                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
282                        this.is_terminated = true;
283                        return std::task::Poll::Ready(None);
284                    }
285                    std::task::Poll::Ready(Err(e)) => {
286                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
287                            e.into(),
288                        ))))
289                    }
290                }
291
292                // A message has been received from the channel
293                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
294
295                std::task::Poll::Ready(Some(match header.ordinal {
296                0x1940439126b02e8f => {
297                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
298                    let mut req = fidl::new_empty!(LibraryLoaderCacheServeRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
299                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LibraryLoaderCacheServeRequest>(&header, _body_bytes, handles, &mut req)?;
300                    let control_handle = LibraryLoaderCacheControlHandle {
301                        inner: this.inner.clone(),
302                    };
303                    Ok(LibraryLoaderCacheRequest::Serve {loader: req.loader,
304
305                        control_handle,
306                    })
307                }
308                _ => Err(fidl::Error::UnknownOrdinal {
309                    ordinal: header.ordinal,
310                    protocol_name: <LibraryLoaderCacheMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
311                }),
312            }))
313            },
314        )
315    }
316}
317
318/// Caches lib loader requests in memory.
319#[derive(Debug)]
320pub enum LibraryLoaderCacheRequest {
321    /// Serve the cache over provided handle.
322    Serve {
323        loader: fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
324        control_handle: LibraryLoaderCacheControlHandle,
325    },
326}
327
328impl LibraryLoaderCacheRequest {
329    #[allow(irrefutable_let_patterns)]
330    pub fn into_serve(
331        self,
332    ) -> Option<(
333        fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
334        LibraryLoaderCacheControlHandle,
335    )> {
336        if let LibraryLoaderCacheRequest::Serve { loader, control_handle } = self {
337            Some((loader, control_handle))
338        } else {
339            None
340        }
341    }
342
343    /// Name of the method defined in FIDL
344    pub fn method_name(&self) -> &'static str {
345        match *self {
346            LibraryLoaderCacheRequest::Serve { .. } => "serve",
347        }
348    }
349}
350
351#[derive(Debug, Clone)]
352pub struct LibraryLoaderCacheControlHandle {
353    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
354}
355
356impl fidl::endpoints::ControlHandle for LibraryLoaderCacheControlHandle {
357    fn shutdown(&self) {
358        self.inner.shutdown()
359    }
360    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
361        self.inner.shutdown_with_epitaph(status)
362    }
363
364    fn is_closed(&self) -> bool {
365        self.inner.channel().is_closed()
366    }
367    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
368        self.inner.channel().on_closed()
369    }
370
371    #[cfg(target_os = "fuchsia")]
372    fn signal_peer(
373        &self,
374        clear_mask: zx::Signals,
375        set_mask: zx::Signals,
376    ) -> Result<(), zx_status::Status> {
377        use fidl::Peered;
378        self.inner.channel().signal_peer(clear_mask, set_mask)
379    }
380}
381
382impl LibraryLoaderCacheControlHandle {}
383
384#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
385pub struct LibraryLoaderCacheBuilderMarker;
386
387impl fidl::endpoints::ProtocolMarker for LibraryLoaderCacheBuilderMarker {
388    type Proxy = LibraryLoaderCacheBuilderProxy;
389    type RequestStream = LibraryLoaderCacheBuilderRequestStream;
390    #[cfg(target_os = "fuchsia")]
391    type SynchronousProxy = LibraryLoaderCacheBuilderSynchronousProxy;
392
393    const DEBUG_NAME: &'static str = "fuchsia.test.runner.LibraryLoaderCacheBuilder";
394}
395impl fidl::endpoints::DiscoverableProtocolMarker for LibraryLoaderCacheBuilderMarker {}
396
397pub trait LibraryLoaderCacheBuilderProxyInterface: Send + Sync {
398    fn r#create(
399        &self,
400        lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
401        cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
402    ) -> Result<(), fidl::Error>;
403}
404#[derive(Debug)]
405#[cfg(target_os = "fuchsia")]
406pub struct LibraryLoaderCacheBuilderSynchronousProxy {
407    client: fidl::client::sync::Client,
408}
409
410#[cfg(target_os = "fuchsia")]
411impl fidl::endpoints::SynchronousProxy for LibraryLoaderCacheBuilderSynchronousProxy {
412    type Proxy = LibraryLoaderCacheBuilderProxy;
413    type Protocol = LibraryLoaderCacheBuilderMarker;
414
415    fn from_channel(inner: fidl::Channel) -> Self {
416        Self::new(inner)
417    }
418
419    fn into_channel(self) -> fidl::Channel {
420        self.client.into_channel()
421    }
422
423    fn as_channel(&self) -> &fidl::Channel {
424        self.client.as_channel()
425    }
426}
427
428#[cfg(target_os = "fuchsia")]
429impl LibraryLoaderCacheBuilderSynchronousProxy {
430    pub fn new(channel: fidl::Channel) -> Self {
431        let protocol_name =
432            <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
433        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
434    }
435
436    pub fn into_channel(self) -> fidl::Channel {
437        self.client.into_channel()
438    }
439
440    /// Waits until an event arrives and returns it. It is safe for other
441    /// threads to make concurrent requests while waiting for an event.
442    pub fn wait_for_event(
443        &self,
444        deadline: zx::MonotonicInstant,
445    ) -> Result<LibraryLoaderCacheBuilderEvent, fidl::Error> {
446        LibraryLoaderCacheBuilderEvent::decode(self.client.wait_for_event(deadline)?)
447    }
448
449    /// Create a new LibraryLoaderCache backed by `lib_directory`.
450    /// `lib_directory`: Handle to /pkg/lib of the component which needs
451    ///                  to be launched.
452    /// `cache`: The handle which will serve |LibraryLoaderCache|.
453    pub fn r#create(
454        &self,
455        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
456        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
457    ) -> Result<(), fidl::Error> {
458        self.client.send::<LibraryLoaderCacheBuilderCreateRequest>(
459            (lib_directory, cache),
460            0x5f1be6b603264b0c,
461            fidl::encoding::DynamicFlags::empty(),
462        )
463    }
464}
465
466#[derive(Debug, Clone)]
467pub struct LibraryLoaderCacheBuilderProxy {
468    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
469}
470
471impl fidl::endpoints::Proxy for LibraryLoaderCacheBuilderProxy {
472    type Protocol = LibraryLoaderCacheBuilderMarker;
473
474    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
475        Self::new(inner)
476    }
477
478    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
479        self.client.into_channel().map_err(|client| Self { client })
480    }
481
482    fn as_channel(&self) -> &::fidl::AsyncChannel {
483        self.client.as_channel()
484    }
485}
486
487impl LibraryLoaderCacheBuilderProxy {
488    /// Create a new Proxy for fuchsia.test.runner/LibraryLoaderCacheBuilder.
489    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
490        let protocol_name =
491            <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
492        Self { client: fidl::client::Client::new(channel, protocol_name) }
493    }
494
495    /// Get a Stream of events from the remote end of the protocol.
496    ///
497    /// # Panics
498    ///
499    /// Panics if the event stream was already taken.
500    pub fn take_event_stream(&self) -> LibraryLoaderCacheBuilderEventStream {
501        LibraryLoaderCacheBuilderEventStream { event_receiver: self.client.take_event_receiver() }
502    }
503
504    /// Create a new LibraryLoaderCache backed by `lib_directory`.
505    /// `lib_directory`: Handle to /pkg/lib of the component which needs
506    ///                  to be launched.
507    /// `cache`: The handle which will serve |LibraryLoaderCache|.
508    pub fn r#create(
509        &self,
510        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
511        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
512    ) -> Result<(), fidl::Error> {
513        LibraryLoaderCacheBuilderProxyInterface::r#create(self, lib_directory, cache)
514    }
515}
516
517impl LibraryLoaderCacheBuilderProxyInterface for LibraryLoaderCacheBuilderProxy {
518    fn r#create(
519        &self,
520        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
521        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
522    ) -> Result<(), fidl::Error> {
523        self.client.send::<LibraryLoaderCacheBuilderCreateRequest>(
524            (lib_directory, cache),
525            0x5f1be6b603264b0c,
526            fidl::encoding::DynamicFlags::empty(),
527        )
528    }
529}
530
531pub struct LibraryLoaderCacheBuilderEventStream {
532    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
533}
534
535impl std::marker::Unpin for LibraryLoaderCacheBuilderEventStream {}
536
537impl futures::stream::FusedStream for LibraryLoaderCacheBuilderEventStream {
538    fn is_terminated(&self) -> bool {
539        self.event_receiver.is_terminated()
540    }
541}
542
543impl futures::Stream for LibraryLoaderCacheBuilderEventStream {
544    type Item = Result<LibraryLoaderCacheBuilderEvent, fidl::Error>;
545
546    fn poll_next(
547        mut self: std::pin::Pin<&mut Self>,
548        cx: &mut std::task::Context<'_>,
549    ) -> std::task::Poll<Option<Self::Item>> {
550        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
551            &mut self.event_receiver,
552            cx
553        )?) {
554            Some(buf) => std::task::Poll::Ready(Some(LibraryLoaderCacheBuilderEvent::decode(buf))),
555            None => std::task::Poll::Ready(None),
556        }
557    }
558}
559
560#[derive(Debug)]
561pub enum LibraryLoaderCacheBuilderEvent {}
562
563impl LibraryLoaderCacheBuilderEvent {
564    /// Decodes a message buffer as a [`LibraryLoaderCacheBuilderEvent`].
565    fn decode(
566        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
567    ) -> Result<LibraryLoaderCacheBuilderEvent, fidl::Error> {
568        let (bytes, _handles) = buf.split_mut();
569        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
570        debug_assert_eq!(tx_header.tx_id, 0);
571        match tx_header.ordinal {
572            _ => Err(fidl::Error::UnknownOrdinal {
573                ordinal: tx_header.ordinal,
574                protocol_name:
575                    <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
576            }),
577        }
578    }
579}
580
581/// A Stream of incoming requests for fuchsia.test.runner/LibraryLoaderCacheBuilder.
582pub struct LibraryLoaderCacheBuilderRequestStream {
583    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
584    is_terminated: bool,
585}
586
587impl std::marker::Unpin for LibraryLoaderCacheBuilderRequestStream {}
588
589impl futures::stream::FusedStream for LibraryLoaderCacheBuilderRequestStream {
590    fn is_terminated(&self) -> bool {
591        self.is_terminated
592    }
593}
594
595impl fidl::endpoints::RequestStream for LibraryLoaderCacheBuilderRequestStream {
596    type Protocol = LibraryLoaderCacheBuilderMarker;
597    type ControlHandle = LibraryLoaderCacheBuilderControlHandle;
598
599    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
600        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
601    }
602
603    fn control_handle(&self) -> Self::ControlHandle {
604        LibraryLoaderCacheBuilderControlHandle { inner: self.inner.clone() }
605    }
606
607    fn into_inner(
608        self,
609    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
610    {
611        (self.inner, self.is_terminated)
612    }
613
614    fn from_inner(
615        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
616        is_terminated: bool,
617    ) -> Self {
618        Self { inner, is_terminated }
619    }
620}
621
622impl futures::Stream for LibraryLoaderCacheBuilderRequestStream {
623    type Item = Result<LibraryLoaderCacheBuilderRequest, fidl::Error>;
624
625    fn poll_next(
626        mut self: std::pin::Pin<&mut Self>,
627        cx: &mut std::task::Context<'_>,
628    ) -> std::task::Poll<Option<Self::Item>> {
629        let this = &mut *self;
630        if this.inner.check_shutdown(cx) {
631            this.is_terminated = true;
632            return std::task::Poll::Ready(None);
633        }
634        if this.is_terminated {
635            panic!("polled LibraryLoaderCacheBuilderRequestStream after completion");
636        }
637        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
638            |bytes, handles| {
639                match this.inner.channel().read_etc(cx, bytes, handles) {
640                    std::task::Poll::Ready(Ok(())) => {}
641                    std::task::Poll::Pending => return std::task::Poll::Pending,
642                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
643                        this.is_terminated = true;
644                        return std::task::Poll::Ready(None);
645                    }
646                    std::task::Poll::Ready(Err(e)) => {
647                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
648                            e.into(),
649                        ))))
650                    }
651                }
652
653                // A message has been received from the channel
654                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
655
656                std::task::Poll::Ready(Some(match header.ordinal {
657                0x5f1be6b603264b0c => {
658                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
659                    let mut req = fidl::new_empty!(LibraryLoaderCacheBuilderCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
660                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LibraryLoaderCacheBuilderCreateRequest>(&header, _body_bytes, handles, &mut req)?;
661                    let control_handle = LibraryLoaderCacheBuilderControlHandle {
662                        inner: this.inner.clone(),
663                    };
664                    Ok(LibraryLoaderCacheBuilderRequest::Create {lib_directory: req.lib_directory,
665cache: req.cache,
666
667                        control_handle,
668                    })
669                }
670                _ => Err(fidl::Error::UnknownOrdinal {
671                    ordinal: header.ordinal,
672                    protocol_name: <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
673                }),
674            }))
675            },
676        )
677    }
678}
679
680/// Provides an API to create LibraryLoaderCache. This is used by test runners
681/// to make test execution faster when launching same process in a package
682/// multiple times.
683#[derive(Debug)]
684pub enum LibraryLoaderCacheBuilderRequest {
685    /// Create a new LibraryLoaderCache backed by `lib_directory`.
686    /// `lib_directory`: Handle to /pkg/lib of the component which needs
687    ///                  to be launched.
688    /// `cache`: The handle which will serve |LibraryLoaderCache|.
689    Create {
690        lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
691        cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
692        control_handle: LibraryLoaderCacheBuilderControlHandle,
693    },
694}
695
696impl LibraryLoaderCacheBuilderRequest {
697    #[allow(irrefutable_let_patterns)]
698    pub fn into_create(
699        self,
700    ) -> Option<(
701        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
702        fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
703        LibraryLoaderCacheBuilderControlHandle,
704    )> {
705        if let LibraryLoaderCacheBuilderRequest::Create { lib_directory, cache, control_handle } =
706            self
707        {
708            Some((lib_directory, cache, control_handle))
709        } else {
710            None
711        }
712    }
713
714    /// Name of the method defined in FIDL
715    pub fn method_name(&self) -> &'static str {
716        match *self {
717            LibraryLoaderCacheBuilderRequest::Create { .. } => "create",
718        }
719    }
720}
721
722#[derive(Debug, Clone)]
723pub struct LibraryLoaderCacheBuilderControlHandle {
724    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
725}
726
727impl fidl::endpoints::ControlHandle for LibraryLoaderCacheBuilderControlHandle {
728    fn shutdown(&self) {
729        self.inner.shutdown()
730    }
731    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
732        self.inner.shutdown_with_epitaph(status)
733    }
734
735    fn is_closed(&self) -> bool {
736        self.inner.channel().is_closed()
737    }
738    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
739        self.inner.channel().on_closed()
740    }
741
742    #[cfg(target_os = "fuchsia")]
743    fn signal_peer(
744        &self,
745        clear_mask: zx::Signals,
746        set_mask: zx::Signals,
747    ) -> Result<(), zx_status::Status> {
748        use fidl::Peered;
749        self.inner.channel().signal_peer(clear_mask, set_mask)
750    }
751}
752
753impl LibraryLoaderCacheBuilderControlHandle {}
754
755mod internal {
756    use super::*;
757
758    impl fidl::encoding::ResourceTypeMarker for LibraryLoaderCacheBuilderCreateRequest {
759        type Borrowed<'a> = &'a mut Self;
760        fn take_or_borrow<'a>(
761            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
762        ) -> Self::Borrowed<'a> {
763            value
764        }
765    }
766
767    unsafe impl fidl::encoding::TypeMarker for LibraryLoaderCacheBuilderCreateRequest {
768        type Owned = Self;
769
770        #[inline(always)]
771        fn inline_align(_context: fidl::encoding::Context) -> usize {
772            4
773        }
774
775        #[inline(always)]
776        fn inline_size(_context: fidl::encoding::Context) -> usize {
777            8
778        }
779    }
780
781    unsafe impl
782        fidl::encoding::Encode<
783            LibraryLoaderCacheBuilderCreateRequest,
784            fidl::encoding::DefaultFuchsiaResourceDialect,
785        > for &mut LibraryLoaderCacheBuilderCreateRequest
786    {
787        #[inline]
788        unsafe fn encode(
789            self,
790            encoder: &mut fidl::encoding::Encoder<
791                '_,
792                fidl::encoding::DefaultFuchsiaResourceDialect,
793            >,
794            offset: usize,
795            _depth: fidl::encoding::Depth,
796        ) -> fidl::Result<()> {
797            encoder.debug_check_bounds::<LibraryLoaderCacheBuilderCreateRequest>(offset);
798            // Delegate to tuple encoding.
799            fidl::encoding::Encode::<LibraryLoaderCacheBuilderCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
800                (
801                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.lib_directory),
802                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.cache),
803                ),
804                encoder, offset, _depth
805            )
806        }
807    }
808    unsafe impl<
809            T0: fidl::encoding::Encode<
810                fidl::encoding::Endpoint<
811                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
812                >,
813                fidl::encoding::DefaultFuchsiaResourceDialect,
814            >,
815            T1: fidl::encoding::Encode<
816                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
817                fidl::encoding::DefaultFuchsiaResourceDialect,
818            >,
819        >
820        fidl::encoding::Encode<
821            LibraryLoaderCacheBuilderCreateRequest,
822            fidl::encoding::DefaultFuchsiaResourceDialect,
823        > for (T0, T1)
824    {
825        #[inline]
826        unsafe fn encode(
827            self,
828            encoder: &mut fidl::encoding::Encoder<
829                '_,
830                fidl::encoding::DefaultFuchsiaResourceDialect,
831            >,
832            offset: usize,
833            depth: fidl::encoding::Depth,
834        ) -> fidl::Result<()> {
835            encoder.debug_check_bounds::<LibraryLoaderCacheBuilderCreateRequest>(offset);
836            // Zero out padding regions. There's no need to apply masks
837            // because the unmasked parts will be overwritten by fields.
838            // Write the fields.
839            self.0.encode(encoder, offset + 0, depth)?;
840            self.1.encode(encoder, offset + 4, depth)?;
841            Ok(())
842        }
843    }
844
845    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
846        for LibraryLoaderCacheBuilderCreateRequest
847    {
848        #[inline(always)]
849        fn new_empty() -> Self {
850            Self {
851                lib_directory: fidl::new_empty!(
852                    fidl::encoding::Endpoint<
853                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
854                    >,
855                    fidl::encoding::DefaultFuchsiaResourceDialect
856                ),
857                cache: fidl::new_empty!(
858                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
859                    fidl::encoding::DefaultFuchsiaResourceDialect
860                ),
861            }
862        }
863
864        #[inline]
865        unsafe fn decode(
866            &mut self,
867            decoder: &mut fidl::encoding::Decoder<
868                '_,
869                fidl::encoding::DefaultFuchsiaResourceDialect,
870            >,
871            offset: usize,
872            _depth: fidl::encoding::Depth,
873        ) -> fidl::Result<()> {
874            decoder.debug_check_bounds::<Self>(offset);
875            // Verify that padding bytes are zero.
876            fidl::decode!(
877                fidl::encoding::Endpoint<
878                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
879                >,
880                fidl::encoding::DefaultFuchsiaResourceDialect,
881                &mut self.lib_directory,
882                decoder,
883                offset + 0,
884                _depth
885            )?;
886            fidl::decode!(
887                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
888                fidl::encoding::DefaultFuchsiaResourceDialect,
889                &mut self.cache,
890                decoder,
891                offset + 4,
892                _depth
893            )?;
894            Ok(())
895        }
896    }
897
898    impl fidl::encoding::ResourceTypeMarker for LibraryLoaderCacheServeRequest {
899        type Borrowed<'a> = &'a mut Self;
900        fn take_or_borrow<'a>(
901            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
902        ) -> Self::Borrowed<'a> {
903            value
904        }
905    }
906
907    unsafe impl fidl::encoding::TypeMarker for LibraryLoaderCacheServeRequest {
908        type Owned = Self;
909
910        #[inline(always)]
911        fn inline_align(_context: fidl::encoding::Context) -> usize {
912            4
913        }
914
915        #[inline(always)]
916        fn inline_size(_context: fidl::encoding::Context) -> usize {
917            4
918        }
919    }
920
921    unsafe impl
922        fidl::encoding::Encode<
923            LibraryLoaderCacheServeRequest,
924            fidl::encoding::DefaultFuchsiaResourceDialect,
925        > for &mut LibraryLoaderCacheServeRequest
926    {
927        #[inline]
928        unsafe fn encode(
929            self,
930            encoder: &mut fidl::encoding::Encoder<
931                '_,
932                fidl::encoding::DefaultFuchsiaResourceDialect,
933            >,
934            offset: usize,
935            _depth: fidl::encoding::Depth,
936        ) -> fidl::Result<()> {
937            encoder.debug_check_bounds::<LibraryLoaderCacheServeRequest>(offset);
938            // Delegate to tuple encoding.
939            fidl::encoding::Encode::<
940                LibraryLoaderCacheServeRequest,
941                fidl::encoding::DefaultFuchsiaResourceDialect,
942            >::encode(
943                (<fidl::encoding::Endpoint<
944                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
945                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
946                    &mut self.loader
947                ),),
948                encoder,
949                offset,
950                _depth,
951            )
952        }
953    }
954    unsafe impl<
955            T0: fidl::encoding::Encode<
956                fidl::encoding::Endpoint<
957                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
958                >,
959                fidl::encoding::DefaultFuchsiaResourceDialect,
960            >,
961        >
962        fidl::encoding::Encode<
963            LibraryLoaderCacheServeRequest,
964            fidl::encoding::DefaultFuchsiaResourceDialect,
965        > for (T0,)
966    {
967        #[inline]
968        unsafe fn encode(
969            self,
970            encoder: &mut fidl::encoding::Encoder<
971                '_,
972                fidl::encoding::DefaultFuchsiaResourceDialect,
973            >,
974            offset: usize,
975            depth: fidl::encoding::Depth,
976        ) -> fidl::Result<()> {
977            encoder.debug_check_bounds::<LibraryLoaderCacheServeRequest>(offset);
978            // Zero out padding regions. There's no need to apply masks
979            // because the unmasked parts will be overwritten by fields.
980            // Write the fields.
981            self.0.encode(encoder, offset + 0, depth)?;
982            Ok(())
983        }
984    }
985
986    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
987        for LibraryLoaderCacheServeRequest
988    {
989        #[inline(always)]
990        fn new_empty() -> Self {
991            Self {
992                loader: fidl::new_empty!(
993                    fidl::encoding::Endpoint<
994                        fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
995                    >,
996                    fidl::encoding::DefaultFuchsiaResourceDialect
997                ),
998            }
999        }
1000
1001        #[inline]
1002        unsafe fn decode(
1003            &mut self,
1004            decoder: &mut fidl::encoding::Decoder<
1005                '_,
1006                fidl::encoding::DefaultFuchsiaResourceDialect,
1007            >,
1008            offset: usize,
1009            _depth: fidl::encoding::Depth,
1010        ) -> fidl::Result<()> {
1011            decoder.debug_check_bounds::<Self>(offset);
1012            // Verify that padding bytes are zero.
1013            fidl::decode!(
1014                fidl::encoding::Endpoint<
1015                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
1016                >,
1017                fidl::encoding::DefaultFuchsiaResourceDialect,
1018                &mut self.loader,
1019                decoder,
1020                offset + 0,
1021                _depth
1022            )?;
1023            Ok(())
1024        }
1025    }
1026}
fidl_fuchsia_test_runner/fidl_fuchsia_test_runner.rs

fidl_fuchsia_test_runner/
fidl_fuchsia_test_runner.rs
