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_ui_app_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ViewProviderCreateView2Request {
16 pub args: CreateView2Args,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20 for ViewProviderCreateView2Request
21{
22}
23
24#[derive(Debug, PartialEq)]
25pub struct ViewProviderCreateViewWithViewRefRequest {
26 pub token: fidl::EventPair,
27 pub view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
28 pub view_ref: fidl_fuchsia_ui_views::ViewRef,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
32 for ViewProviderCreateViewWithViewRefRequest
33{
34}
35
36#[derive(Debug, Default, PartialEq)]
37pub struct CreateView2Args {
38 pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
41 #[doc(hidden)]
42 pub __source_breaking: fidl::marker::SourceBreaking,
43}
44
45impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateView2Args {}
46
47#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
48pub struct ViewProviderMarker;
49
50impl fidl::endpoints::ProtocolMarker for ViewProviderMarker {
51 type Proxy = ViewProviderProxy;
52 type RequestStream = ViewProviderRequestStream;
53 #[cfg(target_os = "fuchsia")]
54 type SynchronousProxy = ViewProviderSynchronousProxy;
55
56 const DEBUG_NAME: &'static str = "fuchsia.ui.app.ViewProvider";
57}
58impl fidl::endpoints::DiscoverableProtocolMarker for ViewProviderMarker {}
59
60pub trait ViewProviderProxyInterface: Send + Sync {
61 fn r#create_view_with_view_ref(
62 &self,
63 token: fidl::EventPair,
64 view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
65 view_ref: fidl_fuchsia_ui_views::ViewRef,
66 ) -> Result<(), fidl::Error>;
67 fn r#create_view2(&self, args: CreateView2Args) -> Result<(), fidl::Error>;
68}
69#[derive(Debug)]
70#[cfg(target_os = "fuchsia")]
71pub struct ViewProviderSynchronousProxy {
72 client: fidl::client::sync::Client,
73}
74
75#[cfg(target_os = "fuchsia")]
76impl fidl::endpoints::SynchronousProxy for ViewProviderSynchronousProxy {
77 type Proxy = ViewProviderProxy;
78 type Protocol = ViewProviderMarker;
79
80 fn from_channel(inner: fidl::Channel) -> Self {
81 Self::new(inner)
82 }
83
84 fn into_channel(self) -> fidl::Channel {
85 self.client.into_channel()
86 }
87
88 fn as_channel(&self) -> &fidl::Channel {
89 self.client.as_channel()
90 }
91}
92
93#[cfg(target_os = "fuchsia")]
94impl ViewProviderSynchronousProxy {
95 pub fn new(channel: fidl::Channel) -> Self {
96 let protocol_name = <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
97 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
98 }
99
100 pub fn into_channel(self) -> fidl::Channel {
101 self.client.into_channel()
102 }
103
104 pub fn wait_for_event(
107 &self,
108 deadline: zx::MonotonicInstant,
109 ) -> Result<ViewProviderEvent, fidl::Error> {
110 ViewProviderEvent::decode(self.client.wait_for_event(deadline)?)
111 }
112
113 pub fn r#create_view_with_view_ref(
127 &self,
128 mut token: fidl::EventPair,
129 mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
130 mut view_ref: fidl_fuchsia_ui_views::ViewRef,
131 ) -> Result<(), fidl::Error> {
132 self.client.send::<ViewProviderCreateViewWithViewRefRequest>(
133 (token, &mut view_ref_control, &mut view_ref),
134 0x586d23a5e4f69a86,
135 fidl::encoding::DynamicFlags::empty(),
136 )
137 }
138
139 pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
144 self.client.send::<ViewProviderCreateView2Request>(
145 (&mut args,),
146 0x78b4a51b5e630482,
147 fidl::encoding::DynamicFlags::empty(),
148 )
149 }
150}
151
152#[derive(Debug, Clone)]
153pub struct ViewProviderProxy {
154 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
155}
156
157impl fidl::endpoints::Proxy for ViewProviderProxy {
158 type Protocol = ViewProviderMarker;
159
160 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
161 Self::new(inner)
162 }
163
164 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
165 self.client.into_channel().map_err(|client| Self { client })
166 }
167
168 fn as_channel(&self) -> &::fidl::AsyncChannel {
169 self.client.as_channel()
170 }
171}
172
173impl ViewProviderProxy {
174 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
176 let protocol_name = <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
177 Self { client: fidl::client::Client::new(channel, protocol_name) }
178 }
179
180 pub fn take_event_stream(&self) -> ViewProviderEventStream {
186 ViewProviderEventStream { event_receiver: self.client.take_event_receiver() }
187 }
188
189 pub fn r#create_view_with_view_ref(
203 &self,
204 mut token: fidl::EventPair,
205 mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
206 mut view_ref: fidl_fuchsia_ui_views::ViewRef,
207 ) -> Result<(), fidl::Error> {
208 ViewProviderProxyInterface::r#create_view_with_view_ref(
209 self,
210 token,
211 view_ref_control,
212 view_ref,
213 )
214 }
215
216 pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
221 ViewProviderProxyInterface::r#create_view2(self, args)
222 }
223}
224
225impl ViewProviderProxyInterface for ViewProviderProxy {
226 fn r#create_view_with_view_ref(
227 &self,
228 mut token: fidl::EventPair,
229 mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
230 mut view_ref: fidl_fuchsia_ui_views::ViewRef,
231 ) -> Result<(), fidl::Error> {
232 self.client.send::<ViewProviderCreateViewWithViewRefRequest>(
233 (token, &mut view_ref_control, &mut view_ref),
234 0x586d23a5e4f69a86,
235 fidl::encoding::DynamicFlags::empty(),
236 )
237 }
238
239 fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
240 self.client.send::<ViewProviderCreateView2Request>(
241 (&mut args,),
242 0x78b4a51b5e630482,
243 fidl::encoding::DynamicFlags::empty(),
244 )
245 }
246}
247
248pub struct ViewProviderEventStream {
249 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
250}
251
252impl std::marker::Unpin for ViewProviderEventStream {}
253
254impl futures::stream::FusedStream for ViewProviderEventStream {
255 fn is_terminated(&self) -> bool {
256 self.event_receiver.is_terminated()
257 }
258}
259
260impl futures::Stream for ViewProviderEventStream {
261 type Item = Result<ViewProviderEvent, fidl::Error>;
262
263 fn poll_next(
264 mut self: std::pin::Pin<&mut Self>,
265 cx: &mut std::task::Context<'_>,
266 ) -> std::task::Poll<Option<Self::Item>> {
267 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
268 &mut self.event_receiver,
269 cx
270 )?) {
271 Some(buf) => std::task::Poll::Ready(Some(ViewProviderEvent::decode(buf))),
272 None => std::task::Poll::Ready(None),
273 }
274 }
275}
276
277#[derive(Debug)]
278pub enum ViewProviderEvent {}
279
280impl ViewProviderEvent {
281 fn decode(
283 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
284 ) -> Result<ViewProviderEvent, fidl::Error> {
285 let (bytes, _handles) = buf.split_mut();
286 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
287 debug_assert_eq!(tx_header.tx_id, 0);
288 match tx_header.ordinal {
289 _ => Err(fidl::Error::UnknownOrdinal {
290 ordinal: tx_header.ordinal,
291 protocol_name: <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
292 }),
293 }
294 }
295}
296
297pub struct ViewProviderRequestStream {
299 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
300 is_terminated: bool,
301}
302
303impl std::marker::Unpin for ViewProviderRequestStream {}
304
305impl futures::stream::FusedStream for ViewProviderRequestStream {
306 fn is_terminated(&self) -> bool {
307 self.is_terminated
308 }
309}
310
311impl fidl::endpoints::RequestStream for ViewProviderRequestStream {
312 type Protocol = ViewProviderMarker;
313 type ControlHandle = ViewProviderControlHandle;
314
315 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
316 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
317 }
318
319 fn control_handle(&self) -> Self::ControlHandle {
320 ViewProviderControlHandle { inner: self.inner.clone() }
321 }
322
323 fn into_inner(
324 self,
325 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
326 {
327 (self.inner, self.is_terminated)
328 }
329
330 fn from_inner(
331 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
332 is_terminated: bool,
333 ) -> Self {
334 Self { inner, is_terminated }
335 }
336}
337
338impl futures::Stream for ViewProviderRequestStream {
339 type Item = Result<ViewProviderRequest, fidl::Error>;
340
341 fn poll_next(
342 mut self: std::pin::Pin<&mut Self>,
343 cx: &mut std::task::Context<'_>,
344 ) -> std::task::Poll<Option<Self::Item>> {
345 let this = &mut *self;
346 if this.inner.check_shutdown(cx) {
347 this.is_terminated = true;
348 return std::task::Poll::Ready(None);
349 }
350 if this.is_terminated {
351 panic!("polled ViewProviderRequestStream after completion");
352 }
353 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
354 |bytes, handles| {
355 match this.inner.channel().read_etc(cx, bytes, handles) {
356 std::task::Poll::Ready(Ok(())) => {}
357 std::task::Poll::Pending => return std::task::Poll::Pending,
358 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
359 this.is_terminated = true;
360 return std::task::Poll::Ready(None);
361 }
362 std::task::Poll::Ready(Err(e)) => {
363 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
364 e.into(),
365 ))))
366 }
367 }
368
369 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
371
372 std::task::Poll::Ready(Some(match header.ordinal {
373 0x586d23a5e4f69a86 => {
374 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
375 let mut req = fidl::new_empty!(
376 ViewProviderCreateViewWithViewRefRequest,
377 fidl::encoding::DefaultFuchsiaResourceDialect
378 );
379 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ViewProviderCreateViewWithViewRefRequest>(&header, _body_bytes, handles, &mut req)?;
380 let control_handle =
381 ViewProviderControlHandle { inner: this.inner.clone() };
382 Ok(ViewProviderRequest::CreateViewWithViewRef {
383 token: req.token,
384 view_ref_control: req.view_ref_control,
385 view_ref: req.view_ref,
386
387 control_handle,
388 })
389 }
390 0x78b4a51b5e630482 => {
391 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
392 let mut req = fidl::new_empty!(
393 ViewProviderCreateView2Request,
394 fidl::encoding::DefaultFuchsiaResourceDialect
395 );
396 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ViewProviderCreateView2Request>(&header, _body_bytes, handles, &mut req)?;
397 let control_handle =
398 ViewProviderControlHandle { inner: this.inner.clone() };
399 Ok(ViewProviderRequest::CreateView2 { args: req.args, control_handle })
400 }
401 _ => Err(fidl::Error::UnknownOrdinal {
402 ordinal: header.ordinal,
403 protocol_name:
404 <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
405 }),
406 }))
407 },
408 )
409 }
410}
411
412#[derive(Debug)]
422pub enum ViewProviderRequest {
423 CreateViewWithViewRef {
437 token: fidl::EventPair,
438 view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
439 view_ref: fidl_fuchsia_ui_views::ViewRef,
440 control_handle: ViewProviderControlHandle,
441 },
442 CreateView2 { args: CreateView2Args, control_handle: ViewProviderControlHandle },
447}
448
449impl ViewProviderRequest {
450 #[allow(irrefutable_let_patterns)]
451 pub fn into_create_view_with_view_ref(
452 self,
453 ) -> Option<(
454 fidl::EventPair,
455 fidl_fuchsia_ui_views::ViewRefControl,
456 fidl_fuchsia_ui_views::ViewRef,
457 ViewProviderControlHandle,
458 )> {
459 if let ViewProviderRequest::CreateViewWithViewRef {
460 token,
461 view_ref_control,
462 view_ref,
463 control_handle,
464 } = self
465 {
466 Some((token, view_ref_control, view_ref, control_handle))
467 } else {
468 None
469 }
470 }
471
472 #[allow(irrefutable_let_patterns)]
473 pub fn into_create_view2(self) -> Option<(CreateView2Args, ViewProviderControlHandle)> {
474 if let ViewProviderRequest::CreateView2 { args, control_handle } = self {
475 Some((args, control_handle))
476 } else {
477 None
478 }
479 }
480
481 pub fn method_name(&self) -> &'static str {
483 match *self {
484 ViewProviderRequest::CreateViewWithViewRef { .. } => "create_view_with_view_ref",
485 ViewProviderRequest::CreateView2 { .. } => "create_view2",
486 }
487 }
488}
489
490#[derive(Debug, Clone)]
491pub struct ViewProviderControlHandle {
492 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
493}
494
495impl fidl::endpoints::ControlHandle for ViewProviderControlHandle {
496 fn shutdown(&self) {
497 self.inner.shutdown()
498 }
499 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
500 self.inner.shutdown_with_epitaph(status)
501 }
502
503 fn is_closed(&self) -> bool {
504 self.inner.channel().is_closed()
505 }
506 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
507 self.inner.channel().on_closed()
508 }
509
510 #[cfg(target_os = "fuchsia")]
511 fn signal_peer(
512 &self,
513 clear_mask: zx::Signals,
514 set_mask: zx::Signals,
515 ) -> Result<(), zx_status::Status> {
516 use fidl::Peered;
517 self.inner.channel().signal_peer(clear_mask, set_mask)
518 }
519}
520
521impl ViewProviderControlHandle {}
522
523mod internal {
524 use super::*;
525
526 impl fidl::encoding::ResourceTypeMarker for ViewProviderCreateView2Request {
527 type Borrowed<'a> = &'a mut Self;
528 fn take_or_borrow<'a>(
529 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
530 ) -> Self::Borrowed<'a> {
531 value
532 }
533 }
534
535 unsafe impl fidl::encoding::TypeMarker for ViewProviderCreateView2Request {
536 type Owned = Self;
537
538 #[inline(always)]
539 fn inline_align(_context: fidl::encoding::Context) -> usize {
540 8
541 }
542
543 #[inline(always)]
544 fn inline_size(_context: fidl::encoding::Context) -> usize {
545 16
546 }
547 }
548
549 unsafe impl
550 fidl::encoding::Encode<
551 ViewProviderCreateView2Request,
552 fidl::encoding::DefaultFuchsiaResourceDialect,
553 > for &mut ViewProviderCreateView2Request
554 {
555 #[inline]
556 unsafe fn encode(
557 self,
558 encoder: &mut fidl::encoding::Encoder<
559 '_,
560 fidl::encoding::DefaultFuchsiaResourceDialect,
561 >,
562 offset: usize,
563 _depth: fidl::encoding::Depth,
564 ) -> fidl::Result<()> {
565 encoder.debug_check_bounds::<ViewProviderCreateView2Request>(offset);
566 fidl::encoding::Encode::<
568 ViewProviderCreateView2Request,
569 fidl::encoding::DefaultFuchsiaResourceDialect,
570 >::encode(
571 (<CreateView2Args as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
572 &mut self.args,
573 ),),
574 encoder,
575 offset,
576 _depth,
577 )
578 }
579 }
580 unsafe impl<
581 T0: fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>,
582 >
583 fidl::encoding::Encode<
584 ViewProviderCreateView2Request,
585 fidl::encoding::DefaultFuchsiaResourceDialect,
586 > for (T0,)
587 {
588 #[inline]
589 unsafe fn encode(
590 self,
591 encoder: &mut fidl::encoding::Encoder<
592 '_,
593 fidl::encoding::DefaultFuchsiaResourceDialect,
594 >,
595 offset: usize,
596 depth: fidl::encoding::Depth,
597 ) -> fidl::Result<()> {
598 encoder.debug_check_bounds::<ViewProviderCreateView2Request>(offset);
599 self.0.encode(encoder, offset + 0, depth)?;
603 Ok(())
604 }
605 }
606
607 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
608 for ViewProviderCreateView2Request
609 {
610 #[inline(always)]
611 fn new_empty() -> Self {
612 Self {
613 args: fidl::new_empty!(
614 CreateView2Args,
615 fidl::encoding::DefaultFuchsiaResourceDialect
616 ),
617 }
618 }
619
620 #[inline]
621 unsafe fn decode(
622 &mut self,
623 decoder: &mut fidl::encoding::Decoder<
624 '_,
625 fidl::encoding::DefaultFuchsiaResourceDialect,
626 >,
627 offset: usize,
628 _depth: fidl::encoding::Depth,
629 ) -> fidl::Result<()> {
630 decoder.debug_check_bounds::<Self>(offset);
631 fidl::decode!(
633 CreateView2Args,
634 fidl::encoding::DefaultFuchsiaResourceDialect,
635 &mut self.args,
636 decoder,
637 offset + 0,
638 _depth
639 )?;
640 Ok(())
641 }
642 }
643
644 impl fidl::encoding::ResourceTypeMarker for ViewProviderCreateViewWithViewRefRequest {
645 type Borrowed<'a> = &'a mut Self;
646 fn take_or_borrow<'a>(
647 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
648 ) -> Self::Borrowed<'a> {
649 value
650 }
651 }
652
653 unsafe impl fidl::encoding::TypeMarker for ViewProviderCreateViewWithViewRefRequest {
654 type Owned = Self;
655
656 #[inline(always)]
657 fn inline_align(_context: fidl::encoding::Context) -> usize {
658 4
659 }
660
661 #[inline(always)]
662 fn inline_size(_context: fidl::encoding::Context) -> usize {
663 12
664 }
665 }
666
667 unsafe impl
668 fidl::encoding::Encode<
669 ViewProviderCreateViewWithViewRefRequest,
670 fidl::encoding::DefaultFuchsiaResourceDialect,
671 > for &mut ViewProviderCreateViewWithViewRefRequest
672 {
673 #[inline]
674 unsafe fn encode(
675 self,
676 encoder: &mut fidl::encoding::Encoder<
677 '_,
678 fidl::encoding::DefaultFuchsiaResourceDialect,
679 >,
680 offset: usize,
681 _depth: fidl::encoding::Depth,
682 ) -> fidl::Result<()> {
683 encoder.debug_check_bounds::<ViewProviderCreateViewWithViewRefRequest>(offset);
684 fidl::encoding::Encode::<ViewProviderCreateViewWithViewRefRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
686 (
687 <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
688 <fidl_fuchsia_ui_views::ViewRefControl as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref_control),
689 <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref),
690 ),
691 encoder, offset, _depth
692 )
693 }
694 }
695 unsafe impl<
696 T0: fidl::encoding::Encode<
697 fidl::encoding::HandleType<
698 fidl::EventPair,
699 { fidl::ObjectType::EVENTPAIR.into_raw() },
700 2147483648,
701 >,
702 fidl::encoding::DefaultFuchsiaResourceDialect,
703 >,
704 T1: fidl::encoding::Encode<
705 fidl_fuchsia_ui_views::ViewRefControl,
706 fidl::encoding::DefaultFuchsiaResourceDialect,
707 >,
708 T2: fidl::encoding::Encode<
709 fidl_fuchsia_ui_views::ViewRef,
710 fidl::encoding::DefaultFuchsiaResourceDialect,
711 >,
712 >
713 fidl::encoding::Encode<
714 ViewProviderCreateViewWithViewRefRequest,
715 fidl::encoding::DefaultFuchsiaResourceDialect,
716 > for (T0, T1, T2)
717 {
718 #[inline]
719 unsafe fn encode(
720 self,
721 encoder: &mut fidl::encoding::Encoder<
722 '_,
723 fidl::encoding::DefaultFuchsiaResourceDialect,
724 >,
725 offset: usize,
726 depth: fidl::encoding::Depth,
727 ) -> fidl::Result<()> {
728 encoder.debug_check_bounds::<ViewProviderCreateViewWithViewRefRequest>(offset);
729 self.0.encode(encoder, offset + 0, depth)?;
733 self.1.encode(encoder, offset + 4, depth)?;
734 self.2.encode(encoder, offset + 8, depth)?;
735 Ok(())
736 }
737 }
738
739 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
740 for ViewProviderCreateViewWithViewRefRequest
741 {
742 #[inline(always)]
743 fn new_empty() -> Self {
744 Self {
745 token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
746 view_ref_control: fidl::new_empty!(
747 fidl_fuchsia_ui_views::ViewRefControl,
748 fidl::encoding::DefaultFuchsiaResourceDialect
749 ),
750 view_ref: fidl::new_empty!(
751 fidl_fuchsia_ui_views::ViewRef,
752 fidl::encoding::DefaultFuchsiaResourceDialect
753 ),
754 }
755 }
756
757 #[inline]
758 unsafe fn decode(
759 &mut self,
760 decoder: &mut fidl::encoding::Decoder<
761 '_,
762 fidl::encoding::DefaultFuchsiaResourceDialect,
763 >,
764 offset: usize,
765 _depth: fidl::encoding::Depth,
766 ) -> fidl::Result<()> {
767 decoder.debug_check_bounds::<Self>(offset);
768 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.token, decoder, offset + 0, _depth)?;
770 fidl::decode!(
771 fidl_fuchsia_ui_views::ViewRefControl,
772 fidl::encoding::DefaultFuchsiaResourceDialect,
773 &mut self.view_ref_control,
774 decoder,
775 offset + 4,
776 _depth
777 )?;
778 fidl::decode!(
779 fidl_fuchsia_ui_views::ViewRef,
780 fidl::encoding::DefaultFuchsiaResourceDialect,
781 &mut self.view_ref,
782 decoder,
783 offset + 8,
784 _depth
785 )?;
786 Ok(())
787 }
788 }
789
790 impl CreateView2Args {
791 #[inline(always)]
792 fn max_ordinal_present(&self) -> u64 {
793 if let Some(_) = self.view_creation_token {
794 return 1;
795 }
796 0
797 }
798 }
799
800 impl fidl::encoding::ResourceTypeMarker for CreateView2Args {
801 type Borrowed<'a> = &'a mut Self;
802 fn take_or_borrow<'a>(
803 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
804 ) -> Self::Borrowed<'a> {
805 value
806 }
807 }
808
809 unsafe impl fidl::encoding::TypeMarker for CreateView2Args {
810 type Owned = Self;
811
812 #[inline(always)]
813 fn inline_align(_context: fidl::encoding::Context) -> usize {
814 8
815 }
816
817 #[inline(always)]
818 fn inline_size(_context: fidl::encoding::Context) -> usize {
819 16
820 }
821 }
822
823 unsafe impl
824 fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>
825 for &mut CreateView2Args
826 {
827 unsafe fn encode(
828 self,
829 encoder: &mut fidl::encoding::Encoder<
830 '_,
831 fidl::encoding::DefaultFuchsiaResourceDialect,
832 >,
833 offset: usize,
834 mut depth: fidl::encoding::Depth,
835 ) -> fidl::Result<()> {
836 encoder.debug_check_bounds::<CreateView2Args>(offset);
837 let max_ordinal: u64 = self.max_ordinal_present();
839 encoder.write_num(max_ordinal, offset);
840 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
841 if max_ordinal == 0 {
843 return Ok(());
844 }
845 depth.increment()?;
846 let envelope_size = 8;
847 let bytes_len = max_ordinal as usize * envelope_size;
848 #[allow(unused_variables)]
849 let offset = encoder.out_of_line_offset(bytes_len);
850 let mut _prev_end_offset: usize = 0;
851 if 1 > max_ordinal {
852 return Ok(());
853 }
854
855 let cur_offset: usize = (1 - 1) * envelope_size;
858
859 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
861
862 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
867 self.view_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
868 encoder, offset + cur_offset, depth
869 )?;
870
871 _prev_end_offset = cur_offset + envelope_size;
872
873 Ok(())
874 }
875 }
876
877 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
878 for CreateView2Args
879 {
880 #[inline(always)]
881 fn new_empty() -> Self {
882 Self::default()
883 }
884
885 unsafe fn decode(
886 &mut self,
887 decoder: &mut fidl::encoding::Decoder<
888 '_,
889 fidl::encoding::DefaultFuchsiaResourceDialect,
890 >,
891 offset: usize,
892 mut depth: fidl::encoding::Depth,
893 ) -> fidl::Result<()> {
894 decoder.debug_check_bounds::<Self>(offset);
895 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
896 None => return Err(fidl::Error::NotNullable),
897 Some(len) => len,
898 };
899 if len == 0 {
901 return Ok(());
902 };
903 depth.increment()?;
904 let envelope_size = 8;
905 let bytes_len = len * envelope_size;
906 let offset = decoder.out_of_line_offset(bytes_len)?;
907 let mut _next_ordinal_to_read = 0;
909 let mut next_offset = offset;
910 let end_offset = offset + bytes_len;
911 _next_ordinal_to_read += 1;
912 if next_offset >= end_offset {
913 return Ok(());
914 }
915
916 while _next_ordinal_to_read < 1 {
918 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
919 _next_ordinal_to_read += 1;
920 next_offset += envelope_size;
921 }
922
923 let next_out_of_line = decoder.next_out_of_line();
924 let handles_before = decoder.remaining_handles();
925 if let Some((inlined, num_bytes, num_handles)) =
926 fidl::encoding::decode_envelope_header(decoder, next_offset)?
927 {
928 let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
929 if inlined != (member_inline_size <= 4) {
930 return Err(fidl::Error::InvalidInlineBitInEnvelope);
931 }
932 let inner_offset;
933 let mut inner_depth = depth.clone();
934 if inlined {
935 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
936 inner_offset = next_offset;
937 } else {
938 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
939 inner_depth.increment()?;
940 }
941 let val_ref = self.view_creation_token.get_or_insert_with(|| {
942 fidl::new_empty!(
943 fidl_fuchsia_ui_views::ViewCreationToken,
944 fidl::encoding::DefaultFuchsiaResourceDialect
945 )
946 });
947 fidl::decode!(
948 fidl_fuchsia_ui_views::ViewCreationToken,
949 fidl::encoding::DefaultFuchsiaResourceDialect,
950 val_ref,
951 decoder,
952 inner_offset,
953 inner_depth
954 )?;
955 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
956 {
957 return Err(fidl::Error::InvalidNumBytesInEnvelope);
958 }
959 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
960 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
961 }
962 }
963
964 next_offset += envelope_size;
965
966 while next_offset < end_offset {
968 _next_ordinal_to_read += 1;
969 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
970 next_offset += envelope_size;
971 }
972
973 Ok(())
974 }
975 }
976}