fidl_fuchsia_factory/
fidl_fuchsia_factory.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 FactoryStoreProviderGetFactoryStoreRequest {
15    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
16}
17
18impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
19    for FactoryStoreProviderGetFactoryStoreRequest
20{
21}
22
23#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
24pub struct AlphaFactoryStoreProviderMarker;
25
26impl fidl::endpoints::ProtocolMarker for AlphaFactoryStoreProviderMarker {
27    type Proxy = AlphaFactoryStoreProviderProxy;
28    type RequestStream = AlphaFactoryStoreProviderRequestStream;
29    #[cfg(target_os = "fuchsia")]
30    type SynchronousProxy = AlphaFactoryStoreProviderSynchronousProxy;
31
32    const DEBUG_NAME: &'static str = "fuchsia.factory.AlphaFactoryStoreProvider";
33}
34impl fidl::endpoints::DiscoverableProtocolMarker for AlphaFactoryStoreProviderMarker {}
35
36pub trait AlphaFactoryStoreProviderProxyInterface: Send + Sync {
37    fn r#get_factory_store(
38        &self,
39        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
40    ) -> Result<(), fidl::Error>;
41}
42#[derive(Debug)]
43#[cfg(target_os = "fuchsia")]
44pub struct AlphaFactoryStoreProviderSynchronousProxy {
45    client: fidl::client::sync::Client,
46}
47
48#[cfg(target_os = "fuchsia")]
49impl fidl::endpoints::SynchronousProxy for AlphaFactoryStoreProviderSynchronousProxy {
50    type Proxy = AlphaFactoryStoreProviderProxy;
51    type Protocol = AlphaFactoryStoreProviderMarker;
52
53    fn from_channel(inner: fidl::Channel) -> Self {
54        Self::new(inner)
55    }
56
57    fn into_channel(self) -> fidl::Channel {
58        self.client.into_channel()
59    }
60
61    fn as_channel(&self) -> &fidl::Channel {
62        self.client.as_channel()
63    }
64}
65
66#[cfg(target_os = "fuchsia")]
67impl AlphaFactoryStoreProviderSynchronousProxy {
68    pub fn new(channel: fidl::Channel) -> Self {
69        let protocol_name =
70            <AlphaFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
71        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
72    }
73
74    pub fn into_channel(self) -> fidl::Channel {
75        self.client.into_channel()
76    }
77
78    /// Waits until an event arrives and returns it. It is safe for other
79    /// threads to make concurrent requests while waiting for an event.
80    pub fn wait_for_event(
81        &self,
82        deadline: zx::MonotonicInstant,
83    ) -> Result<AlphaFactoryStoreProviderEvent, fidl::Error> {
84        AlphaFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
85    }
86
87    pub fn r#get_factory_store(
88        &self,
89        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
90    ) -> Result<(), fidl::Error> {
91        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
92            (dir,),
93            0x21fa8e8bc0e1209e,
94            fidl::encoding::DynamicFlags::empty(),
95        )
96    }
97}
98
99#[derive(Debug, Clone)]
100pub struct AlphaFactoryStoreProviderProxy {
101    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
102}
103
104impl fidl::endpoints::Proxy for AlphaFactoryStoreProviderProxy {
105    type Protocol = AlphaFactoryStoreProviderMarker;
106
107    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
108        Self::new(inner)
109    }
110
111    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
112        self.client.into_channel().map_err(|client| Self { client })
113    }
114
115    fn as_channel(&self) -> &::fidl::AsyncChannel {
116        self.client.as_channel()
117    }
118}
119
120impl AlphaFactoryStoreProviderProxy {
121    /// Create a new Proxy for fuchsia.factory/AlphaFactoryStoreProvider.
122    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
123        let protocol_name =
124            <AlphaFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
125        Self { client: fidl::client::Client::new(channel, protocol_name) }
126    }
127
128    /// Get a Stream of events from the remote end of the protocol.
129    ///
130    /// # Panics
131    ///
132    /// Panics if the event stream was already taken.
133    pub fn take_event_stream(&self) -> AlphaFactoryStoreProviderEventStream {
134        AlphaFactoryStoreProviderEventStream { event_receiver: self.client.take_event_receiver() }
135    }
136
137    pub fn r#get_factory_store(
138        &self,
139        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
140    ) -> Result<(), fidl::Error> {
141        AlphaFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
142    }
143}
144
145impl AlphaFactoryStoreProviderProxyInterface for AlphaFactoryStoreProviderProxy {
146    fn r#get_factory_store(
147        &self,
148        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
149    ) -> Result<(), fidl::Error> {
150        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
151            (dir,),
152            0x21fa8e8bc0e1209e,
153            fidl::encoding::DynamicFlags::empty(),
154        )
155    }
156}
157
158pub struct AlphaFactoryStoreProviderEventStream {
159    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
160}
161
162impl std::marker::Unpin for AlphaFactoryStoreProviderEventStream {}
163
164impl futures::stream::FusedStream for AlphaFactoryStoreProviderEventStream {
165    fn is_terminated(&self) -> bool {
166        self.event_receiver.is_terminated()
167    }
168}
169
170impl futures::Stream for AlphaFactoryStoreProviderEventStream {
171    type Item = Result<AlphaFactoryStoreProviderEvent, fidl::Error>;
172
173    fn poll_next(
174        mut self: std::pin::Pin<&mut Self>,
175        cx: &mut std::task::Context<'_>,
176    ) -> std::task::Poll<Option<Self::Item>> {
177        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
178            &mut self.event_receiver,
179            cx
180        )?) {
181            Some(buf) => std::task::Poll::Ready(Some(AlphaFactoryStoreProviderEvent::decode(buf))),
182            None => std::task::Poll::Ready(None),
183        }
184    }
185}
186
187#[derive(Debug)]
188pub enum AlphaFactoryStoreProviderEvent {}
189
190impl AlphaFactoryStoreProviderEvent {
191    /// Decodes a message buffer as a [`AlphaFactoryStoreProviderEvent`].
192    fn decode(
193        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
194    ) -> Result<AlphaFactoryStoreProviderEvent, fidl::Error> {
195        let (bytes, _handles) = buf.split_mut();
196        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
197        debug_assert_eq!(tx_header.tx_id, 0);
198        match tx_header.ordinal {
199            _ => Err(fidl::Error::UnknownOrdinal {
200                ordinal: tx_header.ordinal,
201                protocol_name:
202                    <AlphaFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
203            }),
204        }
205    }
206}
207
208/// A Stream of incoming requests for fuchsia.factory/AlphaFactoryStoreProvider.
209pub struct AlphaFactoryStoreProviderRequestStream {
210    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
211    is_terminated: bool,
212}
213
214impl std::marker::Unpin for AlphaFactoryStoreProviderRequestStream {}
215
216impl futures::stream::FusedStream for AlphaFactoryStoreProviderRequestStream {
217    fn is_terminated(&self) -> bool {
218        self.is_terminated
219    }
220}
221
222impl fidl::endpoints::RequestStream for AlphaFactoryStoreProviderRequestStream {
223    type Protocol = AlphaFactoryStoreProviderMarker;
224    type ControlHandle = AlphaFactoryStoreProviderControlHandle;
225
226    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
227        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
228    }
229
230    fn control_handle(&self) -> Self::ControlHandle {
231        AlphaFactoryStoreProviderControlHandle { inner: self.inner.clone() }
232    }
233
234    fn into_inner(
235        self,
236    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
237    {
238        (self.inner, self.is_terminated)
239    }
240
241    fn from_inner(
242        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
243        is_terminated: bool,
244    ) -> Self {
245        Self { inner, is_terminated }
246    }
247}
248
249impl futures::Stream for AlphaFactoryStoreProviderRequestStream {
250    type Item = Result<AlphaFactoryStoreProviderRequest, fidl::Error>;
251
252    fn poll_next(
253        mut self: std::pin::Pin<&mut Self>,
254        cx: &mut std::task::Context<'_>,
255    ) -> std::task::Poll<Option<Self::Item>> {
256        let this = &mut *self;
257        if this.inner.check_shutdown(cx) {
258            this.is_terminated = true;
259            return std::task::Poll::Ready(None);
260        }
261        if this.is_terminated {
262            panic!("polled AlphaFactoryStoreProviderRequestStream after completion");
263        }
264        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
265            |bytes, handles| {
266                match this.inner.channel().read_etc(cx, bytes, handles) {
267                    std::task::Poll::Ready(Ok(())) => {}
268                    std::task::Poll::Pending => return std::task::Poll::Pending,
269                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
270                        this.is_terminated = true;
271                        return std::task::Poll::Ready(None);
272                    }
273                    std::task::Poll::Ready(Err(e)) => {
274                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
275                            e.into(),
276                        ))))
277                    }
278                }
279
280                // A message has been received from the channel
281                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
282
283                std::task::Poll::Ready(Some(match header.ordinal {
284                0x21fa8e8bc0e1209e => {
285                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
286                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
287                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
288                    let control_handle = AlphaFactoryStoreProviderControlHandle {
289                        inner: this.inner.clone(),
290                    };
291                    Ok(AlphaFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
292
293                        control_handle,
294                    })
295                }
296                _ => Err(fidl::Error::UnknownOrdinal {
297                    ordinal: header.ordinal,
298                    protocol_name: <AlphaFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
299                }),
300            }))
301            },
302        )
303    }
304}
305
306#[derive(Debug)]
307pub enum AlphaFactoryStoreProviderRequest {
308    GetFactoryStore {
309        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
310        control_handle: AlphaFactoryStoreProviderControlHandle,
311    },
312}
313
314impl AlphaFactoryStoreProviderRequest {
315    #[allow(irrefutable_let_patterns)]
316    pub fn into_get_factory_store(
317        self,
318    ) -> Option<(
319        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
320        AlphaFactoryStoreProviderControlHandle,
321    )> {
322        if let AlphaFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self {
323            Some((dir, control_handle))
324        } else {
325            None
326        }
327    }
328
329    /// Name of the method defined in FIDL
330    pub fn method_name(&self) -> &'static str {
331        match *self {
332            AlphaFactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
333        }
334    }
335}
336
337#[derive(Debug, Clone)]
338pub struct AlphaFactoryStoreProviderControlHandle {
339    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
340}
341
342impl fidl::endpoints::ControlHandle for AlphaFactoryStoreProviderControlHandle {
343    fn shutdown(&self) {
344        self.inner.shutdown()
345    }
346    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
347        self.inner.shutdown_with_epitaph(status)
348    }
349
350    fn is_closed(&self) -> bool {
351        self.inner.channel().is_closed()
352    }
353    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
354        self.inner.channel().on_closed()
355    }
356
357    #[cfg(target_os = "fuchsia")]
358    fn signal_peer(
359        &self,
360        clear_mask: zx::Signals,
361        set_mask: zx::Signals,
362    ) -> Result<(), zx_status::Status> {
363        use fidl::Peered;
364        self.inner.channel().signal_peer(clear_mask, set_mask)
365    }
366}
367
368impl AlphaFactoryStoreProviderControlHandle {}
369
370#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
371pub struct CastCredentialsFactoryStoreProviderMarker;
372
373impl fidl::endpoints::ProtocolMarker for CastCredentialsFactoryStoreProviderMarker {
374    type Proxy = CastCredentialsFactoryStoreProviderProxy;
375    type RequestStream = CastCredentialsFactoryStoreProviderRequestStream;
376    #[cfg(target_os = "fuchsia")]
377    type SynchronousProxy = CastCredentialsFactoryStoreProviderSynchronousProxy;
378
379    const DEBUG_NAME: &'static str = "fuchsia.factory.CastCredentialsFactoryStoreProvider";
380}
381impl fidl::endpoints::DiscoverableProtocolMarker for CastCredentialsFactoryStoreProviderMarker {}
382
383pub trait CastCredentialsFactoryStoreProviderProxyInterface: Send + Sync {
384    fn r#get_factory_store(
385        &self,
386        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
387    ) -> Result<(), fidl::Error>;
388}
389#[derive(Debug)]
390#[cfg(target_os = "fuchsia")]
391pub struct CastCredentialsFactoryStoreProviderSynchronousProxy {
392    client: fidl::client::sync::Client,
393}
394
395#[cfg(target_os = "fuchsia")]
396impl fidl::endpoints::SynchronousProxy for CastCredentialsFactoryStoreProviderSynchronousProxy {
397    type Proxy = CastCredentialsFactoryStoreProviderProxy;
398    type Protocol = CastCredentialsFactoryStoreProviderMarker;
399
400    fn from_channel(inner: fidl::Channel) -> Self {
401        Self::new(inner)
402    }
403
404    fn into_channel(self) -> fidl::Channel {
405        self.client.into_channel()
406    }
407
408    fn as_channel(&self) -> &fidl::Channel {
409        self.client.as_channel()
410    }
411}
412
413#[cfg(target_os = "fuchsia")]
414impl CastCredentialsFactoryStoreProviderSynchronousProxy {
415    pub fn new(channel: fidl::Channel) -> Self {
416        let protocol_name = <CastCredentialsFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
417        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
418    }
419
420    pub fn into_channel(self) -> fidl::Channel {
421        self.client.into_channel()
422    }
423
424    /// Waits until an event arrives and returns it. It is safe for other
425    /// threads to make concurrent requests while waiting for an event.
426    pub fn wait_for_event(
427        &self,
428        deadline: zx::MonotonicInstant,
429    ) -> Result<CastCredentialsFactoryStoreProviderEvent, fidl::Error> {
430        CastCredentialsFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
431    }
432
433    pub fn r#get_factory_store(
434        &self,
435        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
436    ) -> Result<(), fidl::Error> {
437        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
438            (dir,),
439            0x21fa8e8bc0e1209e,
440            fidl::encoding::DynamicFlags::empty(),
441        )
442    }
443}
444
445#[derive(Debug, Clone)]
446pub struct CastCredentialsFactoryStoreProviderProxy {
447    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
448}
449
450impl fidl::endpoints::Proxy for CastCredentialsFactoryStoreProviderProxy {
451    type Protocol = CastCredentialsFactoryStoreProviderMarker;
452
453    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
454        Self::new(inner)
455    }
456
457    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
458        self.client.into_channel().map_err(|client| Self { client })
459    }
460
461    fn as_channel(&self) -> &::fidl::AsyncChannel {
462        self.client.as_channel()
463    }
464}
465
466impl CastCredentialsFactoryStoreProviderProxy {
467    /// Create a new Proxy for fuchsia.factory/CastCredentialsFactoryStoreProvider.
468    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
469        let protocol_name = <CastCredentialsFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
470        Self { client: fidl::client::Client::new(channel, protocol_name) }
471    }
472
473    /// Get a Stream of events from the remote end of the protocol.
474    ///
475    /// # Panics
476    ///
477    /// Panics if the event stream was already taken.
478    pub fn take_event_stream(&self) -> CastCredentialsFactoryStoreProviderEventStream {
479        CastCredentialsFactoryStoreProviderEventStream {
480            event_receiver: self.client.take_event_receiver(),
481        }
482    }
483
484    pub fn r#get_factory_store(
485        &self,
486        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
487    ) -> Result<(), fidl::Error> {
488        CastCredentialsFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
489    }
490}
491
492impl CastCredentialsFactoryStoreProviderProxyInterface
493    for CastCredentialsFactoryStoreProviderProxy
494{
495    fn r#get_factory_store(
496        &self,
497        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
498    ) -> Result<(), fidl::Error> {
499        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
500            (dir,),
501            0x21fa8e8bc0e1209e,
502            fidl::encoding::DynamicFlags::empty(),
503        )
504    }
505}
506
507pub struct CastCredentialsFactoryStoreProviderEventStream {
508    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
509}
510
511impl std::marker::Unpin for CastCredentialsFactoryStoreProviderEventStream {}
512
513impl futures::stream::FusedStream for CastCredentialsFactoryStoreProviderEventStream {
514    fn is_terminated(&self) -> bool {
515        self.event_receiver.is_terminated()
516    }
517}
518
519impl futures::Stream for CastCredentialsFactoryStoreProviderEventStream {
520    type Item = Result<CastCredentialsFactoryStoreProviderEvent, fidl::Error>;
521
522    fn poll_next(
523        mut self: std::pin::Pin<&mut Self>,
524        cx: &mut std::task::Context<'_>,
525    ) -> std::task::Poll<Option<Self::Item>> {
526        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
527            &mut self.event_receiver,
528            cx
529        )?) {
530            Some(buf) => {
531                std::task::Poll::Ready(Some(CastCredentialsFactoryStoreProviderEvent::decode(buf)))
532            }
533            None => std::task::Poll::Ready(None),
534        }
535    }
536}
537
538#[derive(Debug)]
539pub enum CastCredentialsFactoryStoreProviderEvent {}
540
541impl CastCredentialsFactoryStoreProviderEvent {
542    /// Decodes a message buffer as a [`CastCredentialsFactoryStoreProviderEvent`].
543    fn decode(
544        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
545    ) -> Result<CastCredentialsFactoryStoreProviderEvent, fidl::Error> {
546        let (bytes, _handles) = buf.split_mut();
547        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
548        debug_assert_eq!(tx_header.tx_id, 0);
549        match tx_header.ordinal {
550            _ => Err(fidl::Error::UnknownOrdinal {
551                ordinal: tx_header.ordinal,
552                protocol_name: <CastCredentialsFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
553            })
554        }
555    }
556}
557
558/// A Stream of incoming requests for fuchsia.factory/CastCredentialsFactoryStoreProvider.
559pub struct CastCredentialsFactoryStoreProviderRequestStream {
560    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
561    is_terminated: bool,
562}
563
564impl std::marker::Unpin for CastCredentialsFactoryStoreProviderRequestStream {}
565
566impl futures::stream::FusedStream for CastCredentialsFactoryStoreProviderRequestStream {
567    fn is_terminated(&self) -> bool {
568        self.is_terminated
569    }
570}
571
572impl fidl::endpoints::RequestStream for CastCredentialsFactoryStoreProviderRequestStream {
573    type Protocol = CastCredentialsFactoryStoreProviderMarker;
574    type ControlHandle = CastCredentialsFactoryStoreProviderControlHandle;
575
576    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
577        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
578    }
579
580    fn control_handle(&self) -> Self::ControlHandle {
581        CastCredentialsFactoryStoreProviderControlHandle { inner: self.inner.clone() }
582    }
583
584    fn into_inner(
585        self,
586    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
587    {
588        (self.inner, self.is_terminated)
589    }
590
591    fn from_inner(
592        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
593        is_terminated: bool,
594    ) -> Self {
595        Self { inner, is_terminated }
596    }
597}
598
599impl futures::Stream for CastCredentialsFactoryStoreProviderRequestStream {
600    type Item = Result<CastCredentialsFactoryStoreProviderRequest, fidl::Error>;
601
602    fn poll_next(
603        mut self: std::pin::Pin<&mut Self>,
604        cx: &mut std::task::Context<'_>,
605    ) -> std::task::Poll<Option<Self::Item>> {
606        let this = &mut *self;
607        if this.inner.check_shutdown(cx) {
608            this.is_terminated = true;
609            return std::task::Poll::Ready(None);
610        }
611        if this.is_terminated {
612            panic!("polled CastCredentialsFactoryStoreProviderRequestStream after completion");
613        }
614        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
615            |bytes, handles| {
616                match this.inner.channel().read_etc(cx, bytes, handles) {
617                    std::task::Poll::Ready(Ok(())) => {}
618                    std::task::Poll::Pending => return std::task::Poll::Pending,
619                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
620                        this.is_terminated = true;
621                        return std::task::Poll::Ready(None);
622                    }
623                    std::task::Poll::Ready(Err(e)) => {
624                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
625                            e.into(),
626                        ))))
627                    }
628                }
629
630                // A message has been received from the channel
631                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
632
633                std::task::Poll::Ready(Some(match header.ordinal {
634                0x21fa8e8bc0e1209e => {
635                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
636                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
637                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
638                    let control_handle = CastCredentialsFactoryStoreProviderControlHandle {
639                        inner: this.inner.clone(),
640                    };
641                    Ok(CastCredentialsFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
642
643                        control_handle,
644                    })
645                }
646                _ => Err(fidl::Error::UnknownOrdinal {
647                    ordinal: header.ordinal,
648                    protocol_name: <CastCredentialsFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
649                }),
650            }))
651            },
652        )
653    }
654}
655
656/// This protocol exposes a method to connect to a directory containing
657/// Cast-specific factory data: public certificates and keys for
658/// authentication with Cast servers.
659#[derive(Debug)]
660pub enum CastCredentialsFactoryStoreProviderRequest {
661    GetFactoryStore {
662        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
663        control_handle: CastCredentialsFactoryStoreProviderControlHandle,
664    },
665}
666
667impl CastCredentialsFactoryStoreProviderRequest {
668    #[allow(irrefutable_let_patterns)]
669    pub fn into_get_factory_store(
670        self,
671    ) -> Option<(
672        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
673        CastCredentialsFactoryStoreProviderControlHandle,
674    )> {
675        if let CastCredentialsFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } =
676            self
677        {
678            Some((dir, control_handle))
679        } else {
680            None
681        }
682    }
683
684    /// Name of the method defined in FIDL
685    pub fn method_name(&self) -> &'static str {
686        match *self {
687            CastCredentialsFactoryStoreProviderRequest::GetFactoryStore { .. } => {
688                "get_factory_store"
689            }
690        }
691    }
692}
693
694#[derive(Debug, Clone)]
695pub struct CastCredentialsFactoryStoreProviderControlHandle {
696    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
697}
698
699impl fidl::endpoints::ControlHandle for CastCredentialsFactoryStoreProviderControlHandle {
700    fn shutdown(&self) {
701        self.inner.shutdown()
702    }
703    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
704        self.inner.shutdown_with_epitaph(status)
705    }
706
707    fn is_closed(&self) -> bool {
708        self.inner.channel().is_closed()
709    }
710    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
711        self.inner.channel().on_closed()
712    }
713
714    #[cfg(target_os = "fuchsia")]
715    fn signal_peer(
716        &self,
717        clear_mask: zx::Signals,
718        set_mask: zx::Signals,
719    ) -> Result<(), zx_status::Status> {
720        use fidl::Peered;
721        self.inner.channel().signal_peer(clear_mask, set_mask)
722    }
723}
724
725impl CastCredentialsFactoryStoreProviderControlHandle {}
726
727#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
728pub struct FactoryStoreProviderMarker;
729
730impl fidl::endpoints::ProtocolMarker for FactoryStoreProviderMarker {
731    type Proxy = FactoryStoreProviderProxy;
732    type RequestStream = FactoryStoreProviderRequestStream;
733    #[cfg(target_os = "fuchsia")]
734    type SynchronousProxy = FactoryStoreProviderSynchronousProxy;
735
736    const DEBUG_NAME: &'static str = "(anonymous) FactoryStoreProvider";
737}
738
739pub trait FactoryStoreProviderProxyInterface: Send + Sync {
740    fn r#get_factory_store(
741        &self,
742        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
743    ) -> Result<(), fidl::Error>;
744}
745#[derive(Debug)]
746#[cfg(target_os = "fuchsia")]
747pub struct FactoryStoreProviderSynchronousProxy {
748    client: fidl::client::sync::Client,
749}
750
751#[cfg(target_os = "fuchsia")]
752impl fidl::endpoints::SynchronousProxy for FactoryStoreProviderSynchronousProxy {
753    type Proxy = FactoryStoreProviderProxy;
754    type Protocol = FactoryStoreProviderMarker;
755
756    fn from_channel(inner: fidl::Channel) -> Self {
757        Self::new(inner)
758    }
759
760    fn into_channel(self) -> fidl::Channel {
761        self.client.into_channel()
762    }
763
764    fn as_channel(&self) -> &fidl::Channel {
765        self.client.as_channel()
766    }
767}
768
769#[cfg(target_os = "fuchsia")]
770impl FactoryStoreProviderSynchronousProxy {
771    pub fn new(channel: fidl::Channel) -> Self {
772        let protocol_name =
773            <FactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
774        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
775    }
776
777    pub fn into_channel(self) -> fidl::Channel {
778        self.client.into_channel()
779    }
780
781    /// Waits until an event arrives and returns it. It is safe for other
782    /// threads to make concurrent requests while waiting for an event.
783    pub fn wait_for_event(
784        &self,
785        deadline: zx::MonotonicInstant,
786    ) -> Result<FactoryStoreProviderEvent, fidl::Error> {
787        FactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
788    }
789
790    pub fn r#get_factory_store(
791        &self,
792        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
793    ) -> Result<(), fidl::Error> {
794        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
795            (dir,),
796            0x21fa8e8bc0e1209e,
797            fidl::encoding::DynamicFlags::empty(),
798        )
799    }
800}
801
802#[derive(Debug, Clone)]
803pub struct FactoryStoreProviderProxy {
804    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
805}
806
807impl fidl::endpoints::Proxy for FactoryStoreProviderProxy {
808    type Protocol = FactoryStoreProviderMarker;
809
810    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
811        Self::new(inner)
812    }
813
814    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
815        self.client.into_channel().map_err(|client| Self { client })
816    }
817
818    fn as_channel(&self) -> &::fidl::AsyncChannel {
819        self.client.as_channel()
820    }
821}
822
823impl FactoryStoreProviderProxy {
824    /// Create a new Proxy for fuchsia.factory/FactoryStoreProvider.
825    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
826        let protocol_name =
827            <FactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
828        Self { client: fidl::client::Client::new(channel, protocol_name) }
829    }
830
831    /// Get a Stream of events from the remote end of the protocol.
832    ///
833    /// # Panics
834    ///
835    /// Panics if the event stream was already taken.
836    pub fn take_event_stream(&self) -> FactoryStoreProviderEventStream {
837        FactoryStoreProviderEventStream { event_receiver: self.client.take_event_receiver() }
838    }
839
840    pub fn r#get_factory_store(
841        &self,
842        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
843    ) -> Result<(), fidl::Error> {
844        FactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
845    }
846}
847
848impl FactoryStoreProviderProxyInterface for FactoryStoreProviderProxy {
849    fn r#get_factory_store(
850        &self,
851        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
852    ) -> Result<(), fidl::Error> {
853        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
854            (dir,),
855            0x21fa8e8bc0e1209e,
856            fidl::encoding::DynamicFlags::empty(),
857        )
858    }
859}
860
861pub struct FactoryStoreProviderEventStream {
862    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
863}
864
865impl std::marker::Unpin for FactoryStoreProviderEventStream {}
866
867impl futures::stream::FusedStream for FactoryStoreProviderEventStream {
868    fn is_terminated(&self) -> bool {
869        self.event_receiver.is_terminated()
870    }
871}
872
873impl futures::Stream for FactoryStoreProviderEventStream {
874    type Item = Result<FactoryStoreProviderEvent, fidl::Error>;
875
876    fn poll_next(
877        mut self: std::pin::Pin<&mut Self>,
878        cx: &mut std::task::Context<'_>,
879    ) -> std::task::Poll<Option<Self::Item>> {
880        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
881            &mut self.event_receiver,
882            cx
883        )?) {
884            Some(buf) => std::task::Poll::Ready(Some(FactoryStoreProviderEvent::decode(buf))),
885            None => std::task::Poll::Ready(None),
886        }
887    }
888}
889
890#[derive(Debug)]
891pub enum FactoryStoreProviderEvent {}
892
893impl FactoryStoreProviderEvent {
894    /// Decodes a message buffer as a [`FactoryStoreProviderEvent`].
895    fn decode(
896        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
897    ) -> Result<FactoryStoreProviderEvent, fidl::Error> {
898        let (bytes, _handles) = buf.split_mut();
899        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
900        debug_assert_eq!(tx_header.tx_id, 0);
901        match tx_header.ordinal {
902            _ => Err(fidl::Error::UnknownOrdinal {
903                ordinal: tx_header.ordinal,
904                protocol_name:
905                    <FactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
906            }),
907        }
908    }
909}
910
911/// A Stream of incoming requests for fuchsia.factory/FactoryStoreProvider.
912pub struct FactoryStoreProviderRequestStream {
913    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
914    is_terminated: bool,
915}
916
917impl std::marker::Unpin for FactoryStoreProviderRequestStream {}
918
919impl futures::stream::FusedStream for FactoryStoreProviderRequestStream {
920    fn is_terminated(&self) -> bool {
921        self.is_terminated
922    }
923}
924
925impl fidl::endpoints::RequestStream for FactoryStoreProviderRequestStream {
926    type Protocol = FactoryStoreProviderMarker;
927    type ControlHandle = FactoryStoreProviderControlHandle;
928
929    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
930        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
931    }
932
933    fn control_handle(&self) -> Self::ControlHandle {
934        FactoryStoreProviderControlHandle { inner: self.inner.clone() }
935    }
936
937    fn into_inner(
938        self,
939    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
940    {
941        (self.inner, self.is_terminated)
942    }
943
944    fn from_inner(
945        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
946        is_terminated: bool,
947    ) -> Self {
948        Self { inner, is_terminated }
949    }
950}
951
952impl futures::Stream for FactoryStoreProviderRequestStream {
953    type Item = Result<FactoryStoreProviderRequest, fidl::Error>;
954
955    fn poll_next(
956        mut self: std::pin::Pin<&mut Self>,
957        cx: &mut std::task::Context<'_>,
958    ) -> std::task::Poll<Option<Self::Item>> {
959        let this = &mut *self;
960        if this.inner.check_shutdown(cx) {
961            this.is_terminated = true;
962            return std::task::Poll::Ready(None);
963        }
964        if this.is_terminated {
965            panic!("polled FactoryStoreProviderRequestStream after completion");
966        }
967        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
968            |bytes, handles| {
969                match this.inner.channel().read_etc(cx, bytes, handles) {
970                    std::task::Poll::Ready(Ok(())) => {}
971                    std::task::Poll::Pending => return std::task::Poll::Pending,
972                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
973                        this.is_terminated = true;
974                        return std::task::Poll::Ready(None);
975                    }
976                    std::task::Poll::Ready(Err(e)) => {
977                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
978                            e.into(),
979                        ))))
980                    }
981                }
982
983                // A message has been received from the channel
984                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
985
986                std::task::Poll::Ready(Some(match header.ordinal {
987                0x21fa8e8bc0e1209e => {
988                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
989                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
990                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
991                    let control_handle = FactoryStoreProviderControlHandle {
992                        inner: this.inner.clone(),
993                    };
994                    Ok(FactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
995
996                        control_handle,
997                    })
998                }
999                _ => Err(fidl::Error::UnknownOrdinal {
1000                    ordinal: header.ordinal,
1001                    protocol_name: <FactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1002                }),
1003            }))
1004            },
1005        )
1006    }
1007}
1008
1009/// This protocol is a base protocol for all providers of factory store
1010/// directories. It exposes a single method to allow clients to establish a
1011/// connection to a directory containing the relevant factory data. All files
1012/// surfaced by a component that implements FactoryStoreProvider (or any
1013/// protocol that depends on it) are expected to be validated for consistency
1014/// before being exposed to clients.
1015#[derive(Debug)]
1016pub enum FactoryStoreProviderRequest {
1017    GetFactoryStore {
1018        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1019        control_handle: FactoryStoreProviderControlHandle,
1020    },
1021}
1022
1023impl FactoryStoreProviderRequest {
1024    #[allow(irrefutable_let_patterns)]
1025    pub fn into_get_factory_store(
1026        self,
1027    ) -> Option<(
1028        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1029        FactoryStoreProviderControlHandle,
1030    )> {
1031        if let FactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self {
1032            Some((dir, control_handle))
1033        } else {
1034            None
1035        }
1036    }
1037
1038    /// Name of the method defined in FIDL
1039    pub fn method_name(&self) -> &'static str {
1040        match *self {
1041            FactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
1042        }
1043    }
1044}
1045
1046#[derive(Debug, Clone)]
1047pub struct FactoryStoreProviderControlHandle {
1048    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1049}
1050
1051impl fidl::endpoints::ControlHandle for FactoryStoreProviderControlHandle {
1052    fn shutdown(&self) {
1053        self.inner.shutdown()
1054    }
1055    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1056        self.inner.shutdown_with_epitaph(status)
1057    }
1058
1059    fn is_closed(&self) -> bool {
1060        self.inner.channel().is_closed()
1061    }
1062    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1063        self.inner.channel().on_closed()
1064    }
1065
1066    #[cfg(target_os = "fuchsia")]
1067    fn signal_peer(
1068        &self,
1069        clear_mask: zx::Signals,
1070        set_mask: zx::Signals,
1071    ) -> Result<(), zx_status::Status> {
1072        use fidl::Peered;
1073        self.inner.channel().signal_peer(clear_mask, set_mask)
1074    }
1075}
1076
1077impl FactoryStoreProviderControlHandle {}
1078
1079#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1080pub struct MiscFactoryStoreProviderMarker;
1081
1082impl fidl::endpoints::ProtocolMarker for MiscFactoryStoreProviderMarker {
1083    type Proxy = MiscFactoryStoreProviderProxy;
1084    type RequestStream = MiscFactoryStoreProviderRequestStream;
1085    #[cfg(target_os = "fuchsia")]
1086    type SynchronousProxy = MiscFactoryStoreProviderSynchronousProxy;
1087
1088    const DEBUG_NAME: &'static str = "fuchsia.factory.MiscFactoryStoreProvider";
1089}
1090impl fidl::endpoints::DiscoverableProtocolMarker for MiscFactoryStoreProviderMarker {}
1091
1092pub trait MiscFactoryStoreProviderProxyInterface: Send + Sync {
1093    fn r#get_factory_store(
1094        &self,
1095        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1096    ) -> Result<(), fidl::Error>;
1097}
1098#[derive(Debug)]
1099#[cfg(target_os = "fuchsia")]
1100pub struct MiscFactoryStoreProviderSynchronousProxy {
1101    client: fidl::client::sync::Client,
1102}
1103
1104#[cfg(target_os = "fuchsia")]
1105impl fidl::endpoints::SynchronousProxy for MiscFactoryStoreProviderSynchronousProxy {
1106    type Proxy = MiscFactoryStoreProviderProxy;
1107    type Protocol = MiscFactoryStoreProviderMarker;
1108
1109    fn from_channel(inner: fidl::Channel) -> Self {
1110        Self::new(inner)
1111    }
1112
1113    fn into_channel(self) -> fidl::Channel {
1114        self.client.into_channel()
1115    }
1116
1117    fn as_channel(&self) -> &fidl::Channel {
1118        self.client.as_channel()
1119    }
1120}
1121
1122#[cfg(target_os = "fuchsia")]
1123impl MiscFactoryStoreProviderSynchronousProxy {
1124    pub fn new(channel: fidl::Channel) -> Self {
1125        let protocol_name =
1126            <MiscFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1127        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1128    }
1129
1130    pub fn into_channel(self) -> fidl::Channel {
1131        self.client.into_channel()
1132    }
1133
1134    /// Waits until an event arrives and returns it. It is safe for other
1135    /// threads to make concurrent requests while waiting for an event.
1136    pub fn wait_for_event(
1137        &self,
1138        deadline: zx::MonotonicInstant,
1139    ) -> Result<MiscFactoryStoreProviderEvent, fidl::Error> {
1140        MiscFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
1141    }
1142
1143    pub fn r#get_factory_store(
1144        &self,
1145        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1146    ) -> Result<(), fidl::Error> {
1147        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1148            (dir,),
1149            0x21fa8e8bc0e1209e,
1150            fidl::encoding::DynamicFlags::empty(),
1151        )
1152    }
1153}
1154
1155#[derive(Debug, Clone)]
1156pub struct MiscFactoryStoreProviderProxy {
1157    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1158}
1159
1160impl fidl::endpoints::Proxy for MiscFactoryStoreProviderProxy {
1161    type Protocol = MiscFactoryStoreProviderMarker;
1162
1163    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1164        Self::new(inner)
1165    }
1166
1167    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1168        self.client.into_channel().map_err(|client| Self { client })
1169    }
1170
1171    fn as_channel(&self) -> &::fidl::AsyncChannel {
1172        self.client.as_channel()
1173    }
1174}
1175
1176impl MiscFactoryStoreProviderProxy {
1177    /// Create a new Proxy for fuchsia.factory/MiscFactoryStoreProvider.
1178    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1179        let protocol_name =
1180            <MiscFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1181        Self { client: fidl::client::Client::new(channel, protocol_name) }
1182    }
1183
1184    /// Get a Stream of events from the remote end of the protocol.
1185    ///
1186    /// # Panics
1187    ///
1188    /// Panics if the event stream was already taken.
1189    pub fn take_event_stream(&self) -> MiscFactoryStoreProviderEventStream {
1190        MiscFactoryStoreProviderEventStream { event_receiver: self.client.take_event_receiver() }
1191    }
1192
1193    pub fn r#get_factory_store(
1194        &self,
1195        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1196    ) -> Result<(), fidl::Error> {
1197        MiscFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
1198    }
1199}
1200
1201impl MiscFactoryStoreProviderProxyInterface for MiscFactoryStoreProviderProxy {
1202    fn r#get_factory_store(
1203        &self,
1204        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1205    ) -> Result<(), fidl::Error> {
1206        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1207            (dir,),
1208            0x21fa8e8bc0e1209e,
1209            fidl::encoding::DynamicFlags::empty(),
1210        )
1211    }
1212}
1213
1214pub struct MiscFactoryStoreProviderEventStream {
1215    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1216}
1217
1218impl std::marker::Unpin for MiscFactoryStoreProviderEventStream {}
1219
1220impl futures::stream::FusedStream for MiscFactoryStoreProviderEventStream {
1221    fn is_terminated(&self) -> bool {
1222        self.event_receiver.is_terminated()
1223    }
1224}
1225
1226impl futures::Stream for MiscFactoryStoreProviderEventStream {
1227    type Item = Result<MiscFactoryStoreProviderEvent, fidl::Error>;
1228
1229    fn poll_next(
1230        mut self: std::pin::Pin<&mut Self>,
1231        cx: &mut std::task::Context<'_>,
1232    ) -> std::task::Poll<Option<Self::Item>> {
1233        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1234            &mut self.event_receiver,
1235            cx
1236        )?) {
1237            Some(buf) => std::task::Poll::Ready(Some(MiscFactoryStoreProviderEvent::decode(buf))),
1238            None => std::task::Poll::Ready(None),
1239        }
1240    }
1241}
1242
1243#[derive(Debug)]
1244pub enum MiscFactoryStoreProviderEvent {}
1245
1246impl MiscFactoryStoreProviderEvent {
1247    /// Decodes a message buffer as a [`MiscFactoryStoreProviderEvent`].
1248    fn decode(
1249        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1250    ) -> Result<MiscFactoryStoreProviderEvent, fidl::Error> {
1251        let (bytes, _handles) = buf.split_mut();
1252        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1253        debug_assert_eq!(tx_header.tx_id, 0);
1254        match tx_header.ordinal {
1255            _ => Err(fidl::Error::UnknownOrdinal {
1256                ordinal: tx_header.ordinal,
1257                protocol_name:
1258                    <MiscFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1259            }),
1260        }
1261    }
1262}
1263
1264/// A Stream of incoming requests for fuchsia.factory/MiscFactoryStoreProvider.
1265pub struct MiscFactoryStoreProviderRequestStream {
1266    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1267    is_terminated: bool,
1268}
1269
1270impl std::marker::Unpin for MiscFactoryStoreProviderRequestStream {}
1271
1272impl futures::stream::FusedStream for MiscFactoryStoreProviderRequestStream {
1273    fn is_terminated(&self) -> bool {
1274        self.is_terminated
1275    }
1276}
1277
1278impl fidl::endpoints::RequestStream for MiscFactoryStoreProviderRequestStream {
1279    type Protocol = MiscFactoryStoreProviderMarker;
1280    type ControlHandle = MiscFactoryStoreProviderControlHandle;
1281
1282    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1283        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1284    }
1285
1286    fn control_handle(&self) -> Self::ControlHandle {
1287        MiscFactoryStoreProviderControlHandle { inner: self.inner.clone() }
1288    }
1289
1290    fn into_inner(
1291        self,
1292    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1293    {
1294        (self.inner, self.is_terminated)
1295    }
1296
1297    fn from_inner(
1298        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1299        is_terminated: bool,
1300    ) -> Self {
1301        Self { inner, is_terminated }
1302    }
1303}
1304
1305impl futures::Stream for MiscFactoryStoreProviderRequestStream {
1306    type Item = Result<MiscFactoryStoreProviderRequest, fidl::Error>;
1307
1308    fn poll_next(
1309        mut self: std::pin::Pin<&mut Self>,
1310        cx: &mut std::task::Context<'_>,
1311    ) -> std::task::Poll<Option<Self::Item>> {
1312        let this = &mut *self;
1313        if this.inner.check_shutdown(cx) {
1314            this.is_terminated = true;
1315            return std::task::Poll::Ready(None);
1316        }
1317        if this.is_terminated {
1318            panic!("polled MiscFactoryStoreProviderRequestStream after completion");
1319        }
1320        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1321            |bytes, handles| {
1322                match this.inner.channel().read_etc(cx, bytes, handles) {
1323                    std::task::Poll::Ready(Ok(())) => {}
1324                    std::task::Poll::Pending => return std::task::Poll::Pending,
1325                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1326                        this.is_terminated = true;
1327                        return std::task::Poll::Ready(None);
1328                    }
1329                    std::task::Poll::Ready(Err(e)) => {
1330                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1331                            e.into(),
1332                        ))))
1333                    }
1334                }
1335
1336                // A message has been received from the channel
1337                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1338
1339                std::task::Poll::Ready(Some(match header.ordinal {
1340                0x21fa8e8bc0e1209e => {
1341                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1342                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1343                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
1344                    let control_handle = MiscFactoryStoreProviderControlHandle {
1345                        inner: this.inner.clone(),
1346                    };
1347                    Ok(MiscFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
1348
1349                        control_handle,
1350                    })
1351                }
1352                _ => Err(fidl::Error::UnknownOrdinal {
1353                    ordinal: header.ordinal,
1354                    protocol_name: <MiscFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1355                }),
1356            }))
1357            },
1358        )
1359    }
1360}
1361
1362/// This protocol exposes a method to connect to a directory containing
1363/// miscellaneous factory data such as tuning/calibration files, region-specific
1364/// audio files, factory process metadata files, and more. Any raw files not
1365/// covered by other FactoryStoreProviders or methods in fuchsia.hwinfo will
1366/// appear here.
1367#[derive(Debug)]
1368pub enum MiscFactoryStoreProviderRequest {
1369    GetFactoryStore {
1370        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1371        control_handle: MiscFactoryStoreProviderControlHandle,
1372    },
1373}
1374
1375impl MiscFactoryStoreProviderRequest {
1376    #[allow(irrefutable_let_patterns)]
1377    pub fn into_get_factory_store(
1378        self,
1379    ) -> Option<(
1380        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1381        MiscFactoryStoreProviderControlHandle,
1382    )> {
1383        if let MiscFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self {
1384            Some((dir, control_handle))
1385        } else {
1386            None
1387        }
1388    }
1389
1390    /// Name of the method defined in FIDL
1391    pub fn method_name(&self) -> &'static str {
1392        match *self {
1393            MiscFactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
1394        }
1395    }
1396}
1397
1398#[derive(Debug, Clone)]
1399pub struct MiscFactoryStoreProviderControlHandle {
1400    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1401}
1402
1403impl fidl::endpoints::ControlHandle for MiscFactoryStoreProviderControlHandle {
1404    fn shutdown(&self) {
1405        self.inner.shutdown()
1406    }
1407    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1408        self.inner.shutdown_with_epitaph(status)
1409    }
1410
1411    fn is_closed(&self) -> bool {
1412        self.inner.channel().is_closed()
1413    }
1414    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1415        self.inner.channel().on_closed()
1416    }
1417
1418    #[cfg(target_os = "fuchsia")]
1419    fn signal_peer(
1420        &self,
1421        clear_mask: zx::Signals,
1422        set_mask: zx::Signals,
1423    ) -> Result<(), zx_status::Status> {
1424        use fidl::Peered;
1425        self.inner.channel().signal_peer(clear_mask, set_mask)
1426    }
1427}
1428
1429impl MiscFactoryStoreProviderControlHandle {}
1430
1431#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1432pub struct PlayReadyFactoryStoreProviderMarker;
1433
1434impl fidl::endpoints::ProtocolMarker for PlayReadyFactoryStoreProviderMarker {
1435    type Proxy = PlayReadyFactoryStoreProviderProxy;
1436    type RequestStream = PlayReadyFactoryStoreProviderRequestStream;
1437    #[cfg(target_os = "fuchsia")]
1438    type SynchronousProxy = PlayReadyFactoryStoreProviderSynchronousProxy;
1439
1440    const DEBUG_NAME: &'static str = "fuchsia.factory.PlayReadyFactoryStoreProvider";
1441}
1442impl fidl::endpoints::DiscoverableProtocolMarker for PlayReadyFactoryStoreProviderMarker {}
1443
1444pub trait PlayReadyFactoryStoreProviderProxyInterface: Send + Sync {
1445    fn r#get_factory_store(
1446        &self,
1447        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1448    ) -> Result<(), fidl::Error>;
1449}
1450#[derive(Debug)]
1451#[cfg(target_os = "fuchsia")]
1452pub struct PlayReadyFactoryStoreProviderSynchronousProxy {
1453    client: fidl::client::sync::Client,
1454}
1455
1456#[cfg(target_os = "fuchsia")]
1457impl fidl::endpoints::SynchronousProxy for PlayReadyFactoryStoreProviderSynchronousProxy {
1458    type Proxy = PlayReadyFactoryStoreProviderProxy;
1459    type Protocol = PlayReadyFactoryStoreProviderMarker;
1460
1461    fn from_channel(inner: fidl::Channel) -> Self {
1462        Self::new(inner)
1463    }
1464
1465    fn into_channel(self) -> fidl::Channel {
1466        self.client.into_channel()
1467    }
1468
1469    fn as_channel(&self) -> &fidl::Channel {
1470        self.client.as_channel()
1471    }
1472}
1473
1474#[cfg(target_os = "fuchsia")]
1475impl PlayReadyFactoryStoreProviderSynchronousProxy {
1476    pub fn new(channel: fidl::Channel) -> Self {
1477        let protocol_name =
1478            <PlayReadyFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1479        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1480    }
1481
1482    pub fn into_channel(self) -> fidl::Channel {
1483        self.client.into_channel()
1484    }
1485
1486    /// Waits until an event arrives and returns it. It is safe for other
1487    /// threads to make concurrent requests while waiting for an event.
1488    pub fn wait_for_event(
1489        &self,
1490        deadline: zx::MonotonicInstant,
1491    ) -> Result<PlayReadyFactoryStoreProviderEvent, fidl::Error> {
1492        PlayReadyFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
1493    }
1494
1495    pub fn r#get_factory_store(
1496        &self,
1497        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1498    ) -> Result<(), fidl::Error> {
1499        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1500            (dir,),
1501            0x21fa8e8bc0e1209e,
1502            fidl::encoding::DynamicFlags::empty(),
1503        )
1504    }
1505}
1506
1507#[derive(Debug, Clone)]
1508pub struct PlayReadyFactoryStoreProviderProxy {
1509    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1510}
1511
1512impl fidl::endpoints::Proxy for PlayReadyFactoryStoreProviderProxy {
1513    type Protocol = PlayReadyFactoryStoreProviderMarker;
1514
1515    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1516        Self::new(inner)
1517    }
1518
1519    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1520        self.client.into_channel().map_err(|client| Self { client })
1521    }
1522
1523    fn as_channel(&self) -> &::fidl::AsyncChannel {
1524        self.client.as_channel()
1525    }
1526}
1527
1528impl PlayReadyFactoryStoreProviderProxy {
1529    /// Create a new Proxy for fuchsia.factory/PlayReadyFactoryStoreProvider.
1530    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1531        let protocol_name =
1532            <PlayReadyFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1533        Self { client: fidl::client::Client::new(channel, protocol_name) }
1534    }
1535
1536    /// Get a Stream of events from the remote end of the protocol.
1537    ///
1538    /// # Panics
1539    ///
1540    /// Panics if the event stream was already taken.
1541    pub fn take_event_stream(&self) -> PlayReadyFactoryStoreProviderEventStream {
1542        PlayReadyFactoryStoreProviderEventStream {
1543            event_receiver: self.client.take_event_receiver(),
1544        }
1545    }
1546
1547    pub fn r#get_factory_store(
1548        &self,
1549        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1550    ) -> Result<(), fidl::Error> {
1551        PlayReadyFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
1552    }
1553}
1554
1555impl PlayReadyFactoryStoreProviderProxyInterface for PlayReadyFactoryStoreProviderProxy {
1556    fn r#get_factory_store(
1557        &self,
1558        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1559    ) -> Result<(), fidl::Error> {
1560        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1561            (dir,),
1562            0x21fa8e8bc0e1209e,
1563            fidl::encoding::DynamicFlags::empty(),
1564        )
1565    }
1566}
1567
1568pub struct PlayReadyFactoryStoreProviderEventStream {
1569    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1570}
1571
1572impl std::marker::Unpin for PlayReadyFactoryStoreProviderEventStream {}
1573
1574impl futures::stream::FusedStream for PlayReadyFactoryStoreProviderEventStream {
1575    fn is_terminated(&self) -> bool {
1576        self.event_receiver.is_terminated()
1577    }
1578}
1579
1580impl futures::Stream for PlayReadyFactoryStoreProviderEventStream {
1581    type Item = Result<PlayReadyFactoryStoreProviderEvent, fidl::Error>;
1582
1583    fn poll_next(
1584        mut self: std::pin::Pin<&mut Self>,
1585        cx: &mut std::task::Context<'_>,
1586    ) -> std::task::Poll<Option<Self::Item>> {
1587        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1588            &mut self.event_receiver,
1589            cx
1590        )?) {
1591            Some(buf) => {
1592                std::task::Poll::Ready(Some(PlayReadyFactoryStoreProviderEvent::decode(buf)))
1593            }
1594            None => std::task::Poll::Ready(None),
1595        }
1596    }
1597}
1598
1599#[derive(Debug)]
1600pub enum PlayReadyFactoryStoreProviderEvent {}
1601
1602impl PlayReadyFactoryStoreProviderEvent {
1603    /// Decodes a message buffer as a [`PlayReadyFactoryStoreProviderEvent`].
1604    fn decode(
1605        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1606    ) -> Result<PlayReadyFactoryStoreProviderEvent, fidl::Error> {
1607        let (bytes, _handles) = buf.split_mut();
1608        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1609        debug_assert_eq!(tx_header.tx_id, 0);
1610        match tx_header.ordinal {
1611            _ => Err(fidl::Error::UnknownOrdinal {
1612                ordinal: tx_header.ordinal,
1613                protocol_name: <PlayReadyFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1614            })
1615        }
1616    }
1617}
1618
1619/// A Stream of incoming requests for fuchsia.factory/PlayReadyFactoryStoreProvider.
1620pub struct PlayReadyFactoryStoreProviderRequestStream {
1621    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1622    is_terminated: bool,
1623}
1624
1625impl std::marker::Unpin for PlayReadyFactoryStoreProviderRequestStream {}
1626
1627impl futures::stream::FusedStream for PlayReadyFactoryStoreProviderRequestStream {
1628    fn is_terminated(&self) -> bool {
1629        self.is_terminated
1630    }
1631}
1632
1633impl fidl::endpoints::RequestStream for PlayReadyFactoryStoreProviderRequestStream {
1634    type Protocol = PlayReadyFactoryStoreProviderMarker;
1635    type ControlHandle = PlayReadyFactoryStoreProviderControlHandle;
1636
1637    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1638        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1639    }
1640
1641    fn control_handle(&self) -> Self::ControlHandle {
1642        PlayReadyFactoryStoreProviderControlHandle { inner: self.inner.clone() }
1643    }
1644
1645    fn into_inner(
1646        self,
1647    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1648    {
1649        (self.inner, self.is_terminated)
1650    }
1651
1652    fn from_inner(
1653        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1654        is_terminated: bool,
1655    ) -> Self {
1656        Self { inner, is_terminated }
1657    }
1658}
1659
1660impl futures::Stream for PlayReadyFactoryStoreProviderRequestStream {
1661    type Item = Result<PlayReadyFactoryStoreProviderRequest, fidl::Error>;
1662
1663    fn poll_next(
1664        mut self: std::pin::Pin<&mut Self>,
1665        cx: &mut std::task::Context<'_>,
1666    ) -> std::task::Poll<Option<Self::Item>> {
1667        let this = &mut *self;
1668        if this.inner.check_shutdown(cx) {
1669            this.is_terminated = true;
1670            return std::task::Poll::Ready(None);
1671        }
1672        if this.is_terminated {
1673            panic!("polled PlayReadyFactoryStoreProviderRequestStream after completion");
1674        }
1675        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1676            |bytes, handles| {
1677                match this.inner.channel().read_etc(cx, bytes, handles) {
1678                    std::task::Poll::Ready(Ok(())) => {}
1679                    std::task::Poll::Pending => return std::task::Poll::Pending,
1680                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1681                        this.is_terminated = true;
1682                        return std::task::Poll::Ready(None);
1683                    }
1684                    std::task::Poll::Ready(Err(e)) => {
1685                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1686                            e.into(),
1687                        ))))
1688                    }
1689                }
1690
1691                // A message has been received from the channel
1692                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1693
1694                std::task::Poll::Ready(Some(match header.ordinal {
1695                0x21fa8e8bc0e1209e => {
1696                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1697                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1698                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
1699                    let control_handle = PlayReadyFactoryStoreProviderControlHandle {
1700                        inner: this.inner.clone(),
1701                    };
1702                    Ok(PlayReadyFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
1703
1704                        control_handle,
1705                    })
1706                }
1707                _ => Err(fidl::Error::UnknownOrdinal {
1708                    ordinal: header.ordinal,
1709                    protocol_name: <PlayReadyFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1710                }),
1711            }))
1712            },
1713        )
1714    }
1715}
1716
1717/// This protocol exposes a method to connect to a directory containing
1718/// PlayReady-specific factory data: public certificates and keys for
1719/// authentication with PlayReady systems.
1720#[derive(Debug)]
1721pub enum PlayReadyFactoryStoreProviderRequest {
1722    GetFactoryStore {
1723        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1724        control_handle: PlayReadyFactoryStoreProviderControlHandle,
1725    },
1726}
1727
1728impl PlayReadyFactoryStoreProviderRequest {
1729    #[allow(irrefutable_let_patterns)]
1730    pub fn into_get_factory_store(
1731        self,
1732    ) -> Option<(
1733        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1734        PlayReadyFactoryStoreProviderControlHandle,
1735    )> {
1736        if let PlayReadyFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self
1737        {
1738            Some((dir, control_handle))
1739        } else {
1740            None
1741        }
1742    }
1743
1744    /// Name of the method defined in FIDL
1745    pub fn method_name(&self) -> &'static str {
1746        match *self {
1747            PlayReadyFactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
1748        }
1749    }
1750}
1751
1752#[derive(Debug, Clone)]
1753pub struct PlayReadyFactoryStoreProviderControlHandle {
1754    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1755}
1756
1757impl fidl::endpoints::ControlHandle for PlayReadyFactoryStoreProviderControlHandle {
1758    fn shutdown(&self) {
1759        self.inner.shutdown()
1760    }
1761    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1762        self.inner.shutdown_with_epitaph(status)
1763    }
1764
1765    fn is_closed(&self) -> bool {
1766        self.inner.channel().is_closed()
1767    }
1768    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1769        self.inner.channel().on_closed()
1770    }
1771
1772    #[cfg(target_os = "fuchsia")]
1773    fn signal_peer(
1774        &self,
1775        clear_mask: zx::Signals,
1776        set_mask: zx::Signals,
1777    ) -> Result<(), zx_status::Status> {
1778        use fidl::Peered;
1779        self.inner.channel().signal_peer(clear_mask, set_mask)
1780    }
1781}
1782
1783impl PlayReadyFactoryStoreProviderControlHandle {}
1784
1785#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1786pub struct WeaveFactoryStoreProviderMarker;
1787
1788impl fidl::endpoints::ProtocolMarker for WeaveFactoryStoreProviderMarker {
1789    type Proxy = WeaveFactoryStoreProviderProxy;
1790    type RequestStream = WeaveFactoryStoreProviderRequestStream;
1791    #[cfg(target_os = "fuchsia")]
1792    type SynchronousProxy = WeaveFactoryStoreProviderSynchronousProxy;
1793
1794    const DEBUG_NAME: &'static str = "fuchsia.factory.WeaveFactoryStoreProvider";
1795}
1796impl fidl::endpoints::DiscoverableProtocolMarker for WeaveFactoryStoreProviderMarker {}
1797
1798pub trait WeaveFactoryStoreProviderProxyInterface: Send + Sync {
1799    fn r#get_factory_store(
1800        &self,
1801        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1802    ) -> Result<(), fidl::Error>;
1803}
1804#[derive(Debug)]
1805#[cfg(target_os = "fuchsia")]
1806pub struct WeaveFactoryStoreProviderSynchronousProxy {
1807    client: fidl::client::sync::Client,
1808}
1809
1810#[cfg(target_os = "fuchsia")]
1811impl fidl::endpoints::SynchronousProxy for WeaveFactoryStoreProviderSynchronousProxy {
1812    type Proxy = WeaveFactoryStoreProviderProxy;
1813    type Protocol = WeaveFactoryStoreProviderMarker;
1814
1815    fn from_channel(inner: fidl::Channel) -> Self {
1816        Self::new(inner)
1817    }
1818
1819    fn into_channel(self) -> fidl::Channel {
1820        self.client.into_channel()
1821    }
1822
1823    fn as_channel(&self) -> &fidl::Channel {
1824        self.client.as_channel()
1825    }
1826}
1827
1828#[cfg(target_os = "fuchsia")]
1829impl WeaveFactoryStoreProviderSynchronousProxy {
1830    pub fn new(channel: fidl::Channel) -> Self {
1831        let protocol_name =
1832            <WeaveFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1833        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1834    }
1835
1836    pub fn into_channel(self) -> fidl::Channel {
1837        self.client.into_channel()
1838    }
1839
1840    /// Waits until an event arrives and returns it. It is safe for other
1841    /// threads to make concurrent requests while waiting for an event.
1842    pub fn wait_for_event(
1843        &self,
1844        deadline: zx::MonotonicInstant,
1845    ) -> Result<WeaveFactoryStoreProviderEvent, fidl::Error> {
1846        WeaveFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
1847    }
1848
1849    pub fn r#get_factory_store(
1850        &self,
1851        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1852    ) -> Result<(), fidl::Error> {
1853        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1854            (dir,),
1855            0x21fa8e8bc0e1209e,
1856            fidl::encoding::DynamicFlags::empty(),
1857        )
1858    }
1859}
1860
1861#[derive(Debug, Clone)]
1862pub struct WeaveFactoryStoreProviderProxy {
1863    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1864}
1865
1866impl fidl::endpoints::Proxy for WeaveFactoryStoreProviderProxy {
1867    type Protocol = WeaveFactoryStoreProviderMarker;
1868
1869    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1870        Self::new(inner)
1871    }
1872
1873    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1874        self.client.into_channel().map_err(|client| Self { client })
1875    }
1876
1877    fn as_channel(&self) -> &::fidl::AsyncChannel {
1878        self.client.as_channel()
1879    }
1880}
1881
1882impl WeaveFactoryStoreProviderProxy {
1883    /// Create a new Proxy for fuchsia.factory/WeaveFactoryStoreProvider.
1884    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1885        let protocol_name =
1886            <WeaveFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1887        Self { client: fidl::client::Client::new(channel, protocol_name) }
1888    }
1889
1890    /// Get a Stream of events from the remote end of the protocol.
1891    ///
1892    /// # Panics
1893    ///
1894    /// Panics if the event stream was already taken.
1895    pub fn take_event_stream(&self) -> WeaveFactoryStoreProviderEventStream {
1896        WeaveFactoryStoreProviderEventStream { event_receiver: self.client.take_event_receiver() }
1897    }
1898
1899    pub fn r#get_factory_store(
1900        &self,
1901        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1902    ) -> Result<(), fidl::Error> {
1903        WeaveFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
1904    }
1905}
1906
1907impl WeaveFactoryStoreProviderProxyInterface for WeaveFactoryStoreProviderProxy {
1908    fn r#get_factory_store(
1909        &self,
1910        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
1911    ) -> Result<(), fidl::Error> {
1912        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
1913            (dir,),
1914            0x21fa8e8bc0e1209e,
1915            fidl::encoding::DynamicFlags::empty(),
1916        )
1917    }
1918}
1919
1920pub struct WeaveFactoryStoreProviderEventStream {
1921    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1922}
1923
1924impl std::marker::Unpin for WeaveFactoryStoreProviderEventStream {}
1925
1926impl futures::stream::FusedStream for WeaveFactoryStoreProviderEventStream {
1927    fn is_terminated(&self) -> bool {
1928        self.event_receiver.is_terminated()
1929    }
1930}
1931
1932impl futures::Stream for WeaveFactoryStoreProviderEventStream {
1933    type Item = Result<WeaveFactoryStoreProviderEvent, fidl::Error>;
1934
1935    fn poll_next(
1936        mut self: std::pin::Pin<&mut Self>,
1937        cx: &mut std::task::Context<'_>,
1938    ) -> std::task::Poll<Option<Self::Item>> {
1939        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1940            &mut self.event_receiver,
1941            cx
1942        )?) {
1943            Some(buf) => std::task::Poll::Ready(Some(WeaveFactoryStoreProviderEvent::decode(buf))),
1944            None => std::task::Poll::Ready(None),
1945        }
1946    }
1947}
1948
1949#[derive(Debug)]
1950pub enum WeaveFactoryStoreProviderEvent {}
1951
1952impl WeaveFactoryStoreProviderEvent {
1953    /// Decodes a message buffer as a [`WeaveFactoryStoreProviderEvent`].
1954    fn decode(
1955        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1956    ) -> Result<WeaveFactoryStoreProviderEvent, fidl::Error> {
1957        let (bytes, _handles) = buf.split_mut();
1958        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1959        debug_assert_eq!(tx_header.tx_id, 0);
1960        match tx_header.ordinal {
1961            _ => Err(fidl::Error::UnknownOrdinal {
1962                ordinal: tx_header.ordinal,
1963                protocol_name:
1964                    <WeaveFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1965            }),
1966        }
1967    }
1968}
1969
1970/// A Stream of incoming requests for fuchsia.factory/WeaveFactoryStoreProvider.
1971pub struct WeaveFactoryStoreProviderRequestStream {
1972    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1973    is_terminated: bool,
1974}
1975
1976impl std::marker::Unpin for WeaveFactoryStoreProviderRequestStream {}
1977
1978impl futures::stream::FusedStream for WeaveFactoryStoreProviderRequestStream {
1979    fn is_terminated(&self) -> bool {
1980        self.is_terminated
1981    }
1982}
1983
1984impl fidl::endpoints::RequestStream for WeaveFactoryStoreProviderRequestStream {
1985    type Protocol = WeaveFactoryStoreProviderMarker;
1986    type ControlHandle = WeaveFactoryStoreProviderControlHandle;
1987
1988    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1989        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1990    }
1991
1992    fn control_handle(&self) -> Self::ControlHandle {
1993        WeaveFactoryStoreProviderControlHandle { inner: self.inner.clone() }
1994    }
1995
1996    fn into_inner(
1997        self,
1998    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1999    {
2000        (self.inner, self.is_terminated)
2001    }
2002
2003    fn from_inner(
2004        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2005        is_terminated: bool,
2006    ) -> Self {
2007        Self { inner, is_terminated }
2008    }
2009}
2010
2011impl futures::Stream for WeaveFactoryStoreProviderRequestStream {
2012    type Item = Result<WeaveFactoryStoreProviderRequest, fidl::Error>;
2013
2014    fn poll_next(
2015        mut self: std::pin::Pin<&mut Self>,
2016        cx: &mut std::task::Context<'_>,
2017    ) -> std::task::Poll<Option<Self::Item>> {
2018        let this = &mut *self;
2019        if this.inner.check_shutdown(cx) {
2020            this.is_terminated = true;
2021            return std::task::Poll::Ready(None);
2022        }
2023        if this.is_terminated {
2024            panic!("polled WeaveFactoryStoreProviderRequestStream after completion");
2025        }
2026        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2027            |bytes, handles| {
2028                match this.inner.channel().read_etc(cx, bytes, handles) {
2029                    std::task::Poll::Ready(Ok(())) => {}
2030                    std::task::Poll::Pending => return std::task::Poll::Pending,
2031                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2032                        this.is_terminated = true;
2033                        return std::task::Poll::Ready(None);
2034                    }
2035                    std::task::Poll::Ready(Err(e)) => {
2036                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2037                            e.into(),
2038                        ))))
2039                    }
2040                }
2041
2042                // A message has been received from the channel
2043                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2044
2045                std::task::Poll::Ready(Some(match header.ordinal {
2046                0x21fa8e8bc0e1209e => {
2047                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2048                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2049                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
2050                    let control_handle = WeaveFactoryStoreProviderControlHandle {
2051                        inner: this.inner.clone(),
2052                    };
2053                    Ok(WeaveFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
2054
2055                        control_handle,
2056                    })
2057                }
2058                _ => Err(fidl::Error::UnknownOrdinal {
2059                    ordinal: header.ordinal,
2060                    protocol_name: <WeaveFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2061                }),
2062            }))
2063            },
2064        )
2065    }
2066}
2067
2068/// This protocol  exposes a method to connect to a directory containing
2069/// Weave-specific factory data: public certificates, signing keys, and
2070/// identity files for interoperation with a Weave-based home-area-network.
2071#[derive(Debug)]
2072pub enum WeaveFactoryStoreProviderRequest {
2073    GetFactoryStore {
2074        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2075        control_handle: WeaveFactoryStoreProviderControlHandle,
2076    },
2077}
2078
2079impl WeaveFactoryStoreProviderRequest {
2080    #[allow(irrefutable_let_patterns)]
2081    pub fn into_get_factory_store(
2082        self,
2083    ) -> Option<(
2084        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2085        WeaveFactoryStoreProviderControlHandle,
2086    )> {
2087        if let WeaveFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self {
2088            Some((dir, control_handle))
2089        } else {
2090            None
2091        }
2092    }
2093
2094    /// Name of the method defined in FIDL
2095    pub fn method_name(&self) -> &'static str {
2096        match *self {
2097            WeaveFactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
2098        }
2099    }
2100}
2101
2102#[derive(Debug, Clone)]
2103pub struct WeaveFactoryStoreProviderControlHandle {
2104    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2105}
2106
2107impl fidl::endpoints::ControlHandle for WeaveFactoryStoreProviderControlHandle {
2108    fn shutdown(&self) {
2109        self.inner.shutdown()
2110    }
2111    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2112        self.inner.shutdown_with_epitaph(status)
2113    }
2114
2115    fn is_closed(&self) -> bool {
2116        self.inner.channel().is_closed()
2117    }
2118    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2119        self.inner.channel().on_closed()
2120    }
2121
2122    #[cfg(target_os = "fuchsia")]
2123    fn signal_peer(
2124        &self,
2125        clear_mask: zx::Signals,
2126        set_mask: zx::Signals,
2127    ) -> Result<(), zx_status::Status> {
2128        use fidl::Peered;
2129        self.inner.channel().signal_peer(clear_mask, set_mask)
2130    }
2131}
2132
2133impl WeaveFactoryStoreProviderControlHandle {}
2134
2135#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
2136pub struct WidevineFactoryStoreProviderMarker;
2137
2138impl fidl::endpoints::ProtocolMarker for WidevineFactoryStoreProviderMarker {
2139    type Proxy = WidevineFactoryStoreProviderProxy;
2140    type RequestStream = WidevineFactoryStoreProviderRequestStream;
2141    #[cfg(target_os = "fuchsia")]
2142    type SynchronousProxy = WidevineFactoryStoreProviderSynchronousProxy;
2143
2144    const DEBUG_NAME: &'static str = "fuchsia.factory.WidevineFactoryStoreProvider";
2145}
2146impl fidl::endpoints::DiscoverableProtocolMarker for WidevineFactoryStoreProviderMarker {}
2147
2148pub trait WidevineFactoryStoreProviderProxyInterface: Send + Sync {
2149    fn r#get_factory_store(
2150        &self,
2151        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2152    ) -> Result<(), fidl::Error>;
2153}
2154#[derive(Debug)]
2155#[cfg(target_os = "fuchsia")]
2156pub struct WidevineFactoryStoreProviderSynchronousProxy {
2157    client: fidl::client::sync::Client,
2158}
2159
2160#[cfg(target_os = "fuchsia")]
2161impl fidl::endpoints::SynchronousProxy for WidevineFactoryStoreProviderSynchronousProxy {
2162    type Proxy = WidevineFactoryStoreProviderProxy;
2163    type Protocol = WidevineFactoryStoreProviderMarker;
2164
2165    fn from_channel(inner: fidl::Channel) -> Self {
2166        Self::new(inner)
2167    }
2168
2169    fn into_channel(self) -> fidl::Channel {
2170        self.client.into_channel()
2171    }
2172
2173    fn as_channel(&self) -> &fidl::Channel {
2174        self.client.as_channel()
2175    }
2176}
2177
2178#[cfg(target_os = "fuchsia")]
2179impl WidevineFactoryStoreProviderSynchronousProxy {
2180    pub fn new(channel: fidl::Channel) -> Self {
2181        let protocol_name =
2182            <WidevineFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2183        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
2184    }
2185
2186    pub fn into_channel(self) -> fidl::Channel {
2187        self.client.into_channel()
2188    }
2189
2190    /// Waits until an event arrives and returns it. It is safe for other
2191    /// threads to make concurrent requests while waiting for an event.
2192    pub fn wait_for_event(
2193        &self,
2194        deadline: zx::MonotonicInstant,
2195    ) -> Result<WidevineFactoryStoreProviderEvent, fidl::Error> {
2196        WidevineFactoryStoreProviderEvent::decode(self.client.wait_for_event(deadline)?)
2197    }
2198
2199    pub fn r#get_factory_store(
2200        &self,
2201        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2202    ) -> Result<(), fidl::Error> {
2203        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
2204            (dir,),
2205            0x21fa8e8bc0e1209e,
2206            fidl::encoding::DynamicFlags::empty(),
2207        )
2208    }
2209}
2210
2211#[derive(Debug, Clone)]
2212pub struct WidevineFactoryStoreProviderProxy {
2213    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
2214}
2215
2216impl fidl::endpoints::Proxy for WidevineFactoryStoreProviderProxy {
2217    type Protocol = WidevineFactoryStoreProviderMarker;
2218
2219    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
2220        Self::new(inner)
2221    }
2222
2223    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
2224        self.client.into_channel().map_err(|client| Self { client })
2225    }
2226
2227    fn as_channel(&self) -> &::fidl::AsyncChannel {
2228        self.client.as_channel()
2229    }
2230}
2231
2232impl WidevineFactoryStoreProviderProxy {
2233    /// Create a new Proxy for fuchsia.factory/WidevineFactoryStoreProvider.
2234    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
2235        let protocol_name =
2236            <WidevineFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2237        Self { client: fidl::client::Client::new(channel, protocol_name) }
2238    }
2239
2240    /// Get a Stream of events from the remote end of the protocol.
2241    ///
2242    /// # Panics
2243    ///
2244    /// Panics if the event stream was already taken.
2245    pub fn take_event_stream(&self) -> WidevineFactoryStoreProviderEventStream {
2246        WidevineFactoryStoreProviderEventStream {
2247            event_receiver: self.client.take_event_receiver(),
2248        }
2249    }
2250
2251    pub fn r#get_factory_store(
2252        &self,
2253        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2254    ) -> Result<(), fidl::Error> {
2255        WidevineFactoryStoreProviderProxyInterface::r#get_factory_store(self, dir)
2256    }
2257}
2258
2259impl WidevineFactoryStoreProviderProxyInterface for WidevineFactoryStoreProviderProxy {
2260    fn r#get_factory_store(
2261        &self,
2262        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2263    ) -> Result<(), fidl::Error> {
2264        self.client.send::<FactoryStoreProviderGetFactoryStoreRequest>(
2265            (dir,),
2266            0x21fa8e8bc0e1209e,
2267            fidl::encoding::DynamicFlags::empty(),
2268        )
2269    }
2270}
2271
2272pub struct WidevineFactoryStoreProviderEventStream {
2273    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2274}
2275
2276impl std::marker::Unpin for WidevineFactoryStoreProviderEventStream {}
2277
2278impl futures::stream::FusedStream for WidevineFactoryStoreProviderEventStream {
2279    fn is_terminated(&self) -> bool {
2280        self.event_receiver.is_terminated()
2281    }
2282}
2283
2284impl futures::Stream for WidevineFactoryStoreProviderEventStream {
2285    type Item = Result<WidevineFactoryStoreProviderEvent, fidl::Error>;
2286
2287    fn poll_next(
2288        mut self: std::pin::Pin<&mut Self>,
2289        cx: &mut std::task::Context<'_>,
2290    ) -> std::task::Poll<Option<Self::Item>> {
2291        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2292            &mut self.event_receiver,
2293            cx
2294        )?) {
2295            Some(buf) => {
2296                std::task::Poll::Ready(Some(WidevineFactoryStoreProviderEvent::decode(buf)))
2297            }
2298            None => std::task::Poll::Ready(None),
2299        }
2300    }
2301}
2302
2303#[derive(Debug)]
2304pub enum WidevineFactoryStoreProviderEvent {}
2305
2306impl WidevineFactoryStoreProviderEvent {
2307    /// Decodes a message buffer as a [`WidevineFactoryStoreProviderEvent`].
2308    fn decode(
2309        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2310    ) -> Result<WidevineFactoryStoreProviderEvent, fidl::Error> {
2311        let (bytes, _handles) = buf.split_mut();
2312        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2313        debug_assert_eq!(tx_header.tx_id, 0);
2314        match tx_header.ordinal {
2315            _ => Err(fidl::Error::UnknownOrdinal {
2316                ordinal: tx_header.ordinal,
2317                protocol_name: <WidevineFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2318            })
2319        }
2320    }
2321}
2322
2323/// A Stream of incoming requests for fuchsia.factory/WidevineFactoryStoreProvider.
2324pub struct WidevineFactoryStoreProviderRequestStream {
2325    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2326    is_terminated: bool,
2327}
2328
2329impl std::marker::Unpin for WidevineFactoryStoreProviderRequestStream {}
2330
2331impl futures::stream::FusedStream for WidevineFactoryStoreProviderRequestStream {
2332    fn is_terminated(&self) -> bool {
2333        self.is_terminated
2334    }
2335}
2336
2337impl fidl::endpoints::RequestStream for WidevineFactoryStoreProviderRequestStream {
2338    type Protocol = WidevineFactoryStoreProviderMarker;
2339    type ControlHandle = WidevineFactoryStoreProviderControlHandle;
2340
2341    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2342        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2343    }
2344
2345    fn control_handle(&self) -> Self::ControlHandle {
2346        WidevineFactoryStoreProviderControlHandle { inner: self.inner.clone() }
2347    }
2348
2349    fn into_inner(
2350        self,
2351    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2352    {
2353        (self.inner, self.is_terminated)
2354    }
2355
2356    fn from_inner(
2357        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2358        is_terminated: bool,
2359    ) -> Self {
2360        Self { inner, is_terminated }
2361    }
2362}
2363
2364impl futures::Stream for WidevineFactoryStoreProviderRequestStream {
2365    type Item = Result<WidevineFactoryStoreProviderRequest, fidl::Error>;
2366
2367    fn poll_next(
2368        mut self: std::pin::Pin<&mut Self>,
2369        cx: &mut std::task::Context<'_>,
2370    ) -> std::task::Poll<Option<Self::Item>> {
2371        let this = &mut *self;
2372        if this.inner.check_shutdown(cx) {
2373            this.is_terminated = true;
2374            return std::task::Poll::Ready(None);
2375        }
2376        if this.is_terminated {
2377            panic!("polled WidevineFactoryStoreProviderRequestStream after completion");
2378        }
2379        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2380            |bytes, handles| {
2381                match this.inner.channel().read_etc(cx, bytes, handles) {
2382                    std::task::Poll::Ready(Ok(())) => {}
2383                    std::task::Poll::Pending => return std::task::Poll::Pending,
2384                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2385                        this.is_terminated = true;
2386                        return std::task::Poll::Ready(None);
2387                    }
2388                    std::task::Poll::Ready(Err(e)) => {
2389                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2390                            e.into(),
2391                        ))))
2392                    }
2393                }
2394
2395                // A message has been received from the channel
2396                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2397
2398                std::task::Poll::Ready(Some(match header.ordinal {
2399                0x21fa8e8bc0e1209e => {
2400                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2401                    let mut req = fidl::new_empty!(FactoryStoreProviderGetFactoryStoreRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2402                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryStoreProviderGetFactoryStoreRequest>(&header, _body_bytes, handles, &mut req)?;
2403                    let control_handle = WidevineFactoryStoreProviderControlHandle {
2404                        inner: this.inner.clone(),
2405                    };
2406                    Ok(WidevineFactoryStoreProviderRequest::GetFactoryStore {dir: req.dir,
2407
2408                        control_handle,
2409                    })
2410                }
2411                _ => Err(fidl::Error::UnknownOrdinal {
2412                    ordinal: header.ordinal,
2413                    protocol_name: <WidevineFactoryStoreProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2414                }),
2415            }))
2416            },
2417        )
2418    }
2419}
2420
2421/// This protocol exposes a method to connect to a directory containing
2422/// Widevine-specific factory data: public certificates and keys for
2423/// authentication with Widevine systems.
2424#[derive(Debug)]
2425pub enum WidevineFactoryStoreProviderRequest {
2426    GetFactoryStore {
2427        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2428        control_handle: WidevineFactoryStoreProviderControlHandle,
2429    },
2430}
2431
2432impl WidevineFactoryStoreProviderRequest {
2433    #[allow(irrefutable_let_patterns)]
2434    pub fn into_get_factory_store(
2435        self,
2436    ) -> Option<(
2437        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2438        WidevineFactoryStoreProviderControlHandle,
2439    )> {
2440        if let WidevineFactoryStoreProviderRequest::GetFactoryStore { dir, control_handle } = self {
2441            Some((dir, control_handle))
2442        } else {
2443            None
2444        }
2445    }
2446
2447    /// Name of the method defined in FIDL
2448    pub fn method_name(&self) -> &'static str {
2449        match *self {
2450            WidevineFactoryStoreProviderRequest::GetFactoryStore { .. } => "get_factory_store",
2451        }
2452    }
2453}
2454
2455#[derive(Debug, Clone)]
2456pub struct WidevineFactoryStoreProviderControlHandle {
2457    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2458}
2459
2460impl fidl::endpoints::ControlHandle for WidevineFactoryStoreProviderControlHandle {
2461    fn shutdown(&self) {
2462        self.inner.shutdown()
2463    }
2464    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2465        self.inner.shutdown_with_epitaph(status)
2466    }
2467
2468    fn is_closed(&self) -> bool {
2469        self.inner.channel().is_closed()
2470    }
2471    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2472        self.inner.channel().on_closed()
2473    }
2474
2475    #[cfg(target_os = "fuchsia")]
2476    fn signal_peer(
2477        &self,
2478        clear_mask: zx::Signals,
2479        set_mask: zx::Signals,
2480    ) -> Result<(), zx_status::Status> {
2481        use fidl::Peered;
2482        self.inner.channel().signal_peer(clear_mask, set_mask)
2483    }
2484}
2485
2486impl WidevineFactoryStoreProviderControlHandle {}
2487
2488mod internal {
2489    use super::*;
2490
2491    impl fidl::encoding::ResourceTypeMarker for FactoryStoreProviderGetFactoryStoreRequest {
2492        type Borrowed<'a> = &'a mut Self;
2493        fn take_or_borrow<'a>(
2494            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2495        ) -> Self::Borrowed<'a> {
2496            value
2497        }
2498    }
2499
2500    unsafe impl fidl::encoding::TypeMarker for FactoryStoreProviderGetFactoryStoreRequest {
2501        type Owned = Self;
2502
2503        #[inline(always)]
2504        fn inline_align(_context: fidl::encoding::Context) -> usize {
2505            4
2506        }
2507
2508        #[inline(always)]
2509        fn inline_size(_context: fidl::encoding::Context) -> usize {
2510            4
2511        }
2512    }
2513
2514    unsafe impl
2515        fidl::encoding::Encode<
2516            FactoryStoreProviderGetFactoryStoreRequest,
2517            fidl::encoding::DefaultFuchsiaResourceDialect,
2518        > for &mut FactoryStoreProviderGetFactoryStoreRequest
2519    {
2520        #[inline]
2521        unsafe fn encode(
2522            self,
2523            encoder: &mut fidl::encoding::Encoder<
2524                '_,
2525                fidl::encoding::DefaultFuchsiaResourceDialect,
2526            >,
2527            offset: usize,
2528            _depth: fidl::encoding::Depth,
2529        ) -> fidl::Result<()> {
2530            encoder.debug_check_bounds::<FactoryStoreProviderGetFactoryStoreRequest>(offset);
2531            // Delegate to tuple encoding.
2532            fidl::encoding::Encode::<
2533                FactoryStoreProviderGetFactoryStoreRequest,
2534                fidl::encoding::DefaultFuchsiaResourceDialect,
2535            >::encode(
2536                (<fidl::encoding::Endpoint<
2537                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2538                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
2539                    &mut self.dir
2540                ),),
2541                encoder,
2542                offset,
2543                _depth,
2544            )
2545        }
2546    }
2547    unsafe impl<
2548            T0: fidl::encoding::Encode<
2549                fidl::encoding::Endpoint<
2550                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2551                >,
2552                fidl::encoding::DefaultFuchsiaResourceDialect,
2553            >,
2554        >
2555        fidl::encoding::Encode<
2556            FactoryStoreProviderGetFactoryStoreRequest,
2557            fidl::encoding::DefaultFuchsiaResourceDialect,
2558        > for (T0,)
2559    {
2560        #[inline]
2561        unsafe fn encode(
2562            self,
2563            encoder: &mut fidl::encoding::Encoder<
2564                '_,
2565                fidl::encoding::DefaultFuchsiaResourceDialect,
2566            >,
2567            offset: usize,
2568            depth: fidl::encoding::Depth,
2569        ) -> fidl::Result<()> {
2570            encoder.debug_check_bounds::<FactoryStoreProviderGetFactoryStoreRequest>(offset);
2571            // Zero out padding regions. There's no need to apply masks
2572            // because the unmasked parts will be overwritten by fields.
2573            // Write the fields.
2574            self.0.encode(encoder, offset + 0, depth)?;
2575            Ok(())
2576        }
2577    }
2578
2579    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2580        for FactoryStoreProviderGetFactoryStoreRequest
2581    {
2582        #[inline(always)]
2583        fn new_empty() -> Self {
2584            Self {
2585                dir: fidl::new_empty!(
2586                    fidl::encoding::Endpoint<
2587                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2588                    >,
2589                    fidl::encoding::DefaultFuchsiaResourceDialect
2590                ),
2591            }
2592        }
2593
2594        #[inline]
2595        unsafe fn decode(
2596            &mut self,
2597            decoder: &mut fidl::encoding::Decoder<
2598                '_,
2599                fidl::encoding::DefaultFuchsiaResourceDialect,
2600            >,
2601            offset: usize,
2602            _depth: fidl::encoding::Depth,
2603        ) -> fidl::Result<()> {
2604            decoder.debug_check_bounds::<Self>(offset);
2605            // Verify that padding bytes are zero.
2606            fidl::decode!(
2607                fidl::encoding::Endpoint<
2608                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2609                >,
2610                fidl::encoding::DefaultFuchsiaResourceDialect,
2611                &mut self.dir,
2612                decoder,
2613                offset + 0,
2614                _depth
2615            )?;
2616            Ok(())
2617        }
2618    }
2619}