1#![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 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 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 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 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
209pub 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 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 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 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 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 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 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
559pub 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 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#[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 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 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 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 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 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
912pub 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 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#[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 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 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 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 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 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
1265pub 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 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#[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 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 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 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 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 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
1620pub 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 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#[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 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 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 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 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 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
1971pub 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 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#[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 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 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 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 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 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
2324pub 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 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#[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 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 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 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 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}