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