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