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
13pub const MAX_RECTS_PER_IMAGE: u32 = 1024;
15
16#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21pub enum Color {
22 Black,
24 Red,
26 Green,
28 Blue,
30 Yellow,
32 Magenta,
34 Cyan,
36 White,
38 #[doc(hidden)]
39 __SourceBreaking { unknown_ordinal: u32 },
40}
41
42#[macro_export]
44macro_rules! ColorUnknown {
45 () => {
46 _
47 };
48}
49
50impl Color {
51 #[inline]
52 pub fn from_primitive(prim: u32) -> Option<Self> {
53 match prim {
54 1 => Some(Self::Black),
55 2 => Some(Self::Red),
56 3 => Some(Self::Green),
57 4 => Some(Self::Blue),
58 5 => Some(Self::Yellow),
59 6 => Some(Self::Magenta),
60 7 => Some(Self::Cyan),
61 8 => Some(Self::White),
62 _ => None,
63 }
64 }
65
66 #[inline]
67 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
68 match prim {
69 1 => Self::Black,
70 2 => Self::Red,
71 3 => Self::Green,
72 4 => Self::Blue,
73 5 => Self::Yellow,
74 6 => Self::Magenta,
75 7 => Self::Cyan,
76 8 => Self::White,
77 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
78 }
79 }
80
81 #[inline]
82 pub fn unknown() -> Self {
83 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
84 }
85
86 #[inline]
87 pub const fn into_primitive(self) -> u32 {
88 match self {
89 Self::Black => 1,
90 Self::Red => 2,
91 Self::Green => 3,
92 Self::Blue => 4,
93 Self::Yellow => 5,
94 Self::Magenta => 6,
95 Self::Cyan => 7,
96 Self::White => 8,
97 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
98 }
99 }
100
101 #[inline]
102 pub fn is_unknown(&self) -> bool {
103 match self {
104 Self::__SourceBreaking { unknown_ordinal: _ } => true,
105 _ => false,
106 }
107 }
108}
109
110#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112pub enum Result_ {
113 Unsupported,
126 Success,
128 Error,
130 #[doc(hidden)]
131 __SourceBreaking { unknown_ordinal: u32 },
132}
133
134#[macro_export]
136macro_rules! Result_Unknown {
137 () => {
138 _
139 };
140}
141
142impl Result_ {
143 #[inline]
144 pub fn from_primitive(prim: u32) -> Option<Self> {
145 match prim {
146 0 => Some(Self::Unsupported),
147 1 => Some(Self::Success),
148 2 => Some(Self::Error),
149 _ => None,
150 }
151 }
152
153 #[inline]
154 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
155 match prim {
156 0 => Self::Unsupported,
157 1 => Self::Success,
158 2 => Self::Error,
159 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
160 }
161 }
162
163 #[inline]
164 pub fn unknown() -> Self {
165 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
166 }
167
168 #[inline]
169 pub const fn into_primitive(self) -> u32 {
170 match self {
171 Self::Unsupported => 0,
172 Self::Success => 1,
173 Self::Error => 2,
174 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
175 }
176 }
177
178 #[inline]
179 pub fn is_unknown(&self) -> bool {
180 match self {
181 Self::__SourceBreaking { unknown_ordinal: _ } => true,
182 _ => false,
183 }
184 }
185}
186
187#[derive(Clone, Debug, Default, PartialEq)]
191pub struct ContentBounds {
192 pub size: Option<fidl_fuchsia_math::SizeU>,
198 pub origin: Option<fidl_fuchsia_math::Vec_>,
205 #[doc(hidden)]
206 pub __source_breaking: fidl::marker::SourceBreaking,
207}
208
209impl fidl::Persistable for ContentBounds {}
210
211#[derive(Clone, Debug, Default, PartialEq)]
213pub struct EmbeddedViewProperties {
214 pub bounds: Option<ContentBounds>,
217 #[doc(hidden)]
218 pub __source_breaking: fidl::marker::SourceBreaking,
219}
220
221impl fidl::Persistable for EmbeddedViewProperties {}
222
223#[derive(Clone, Debug, Default, PartialEq)]
225pub struct FilledRect {
226 pub color: Option<Color>,
228 pub bounds: Option<ContentBounds>,
230 #[doc(hidden)]
231 pub __source_breaking: fidl::marker::SourceBreaking,
232}
233
234impl fidl::Persistable for FilledRect {}
235
236#[derive(Clone, Debug, Default, PartialEq)]
238pub struct ImageProperties {
239 pub bounds: Option<ContentBounds>,
241 pub filled_rects: Option<Vec<FilledRect>>,
245 #[doc(hidden)]
246 pub __source_breaking: fidl::marker::SourceBreaking,
247}
248
249impl fidl::Persistable for ImageProperties {}
250
251#[derive(Debug, Default, PartialEq)]
253pub struct PuppetCreationArgs {
254 pub server_end: Option<fidl::endpoints::ServerEnd<PuppetMarker>>,
255 pub view_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
256 pub touch_listener:
257 Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::TouchInputListenerMarker>>,
258 pub mouse_listener:
259 Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::MouseInputListenerMarker>>,
260 pub keyboard_listener:
261 Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker>>,
262 pub flatland_client:
263 Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>>,
264 pub keyboard_client: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>>,
265 pub device_pixel_ratio: Option<f32>,
266 pub focuser: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>>,
267 #[doc(hidden)]
268 pub __source_breaking: fidl::marker::SourceBreaking,
269}
270
271impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for PuppetCreationArgs {}
272
273#[derive(Clone, Debug, Default, PartialEq)]
274pub struct PuppetDrawImageRequest {
275 pub id: Option<u64>,
276 pub properties: Option<ImageProperties>,
277 #[doc(hidden)]
278 pub __source_breaking: fidl::marker::SourceBreaking,
279}
280
281impl fidl::Persistable for PuppetDrawImageRequest {}
282
283#[derive(Clone, Debug, Default, PartialEq)]
284pub struct PuppetDrawImageResponse {
285 pub result: Option<Result_>,
286 #[doc(hidden)]
287 pub __source_breaking: fidl::marker::SourceBreaking,
288}
289
290impl fidl::Persistable for PuppetDrawImageResponse {}
291
292#[derive(Clone, Debug, Default, PartialEq)]
293pub struct PuppetEmbedRemoteViewRequest {
294 pub id: Option<u64>,
295 pub properties: Option<EmbeddedViewProperties>,
296 #[doc(hidden)]
297 pub __source_breaking: fidl::marker::SourceBreaking,
298}
299
300impl fidl::Persistable for PuppetEmbedRemoteViewRequest {}
301
302#[derive(Debug, Default, PartialEq)]
303pub struct PuppetEmbedRemoteViewResponse {
304 pub result: Option<Result_>,
305 pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
306 #[doc(hidden)]
307 pub __source_breaking: fidl::marker::SourceBreaking,
308}
309
310impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
311 for PuppetEmbedRemoteViewResponse
312{
313}
314
315#[derive(Debug, Default, PartialEq)]
316pub struct PuppetFactoryCreateResponse {
317 pub result: Option<Result_>,
318 pub view_ref: Option<fidl_fuchsia_ui_views::ViewRef>,
320 #[doc(hidden)]
321 pub __source_breaking: fidl::marker::SourceBreaking,
322}
323
324impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
325 for PuppetFactoryCreateResponse
326{
327}
328
329#[derive(Clone, Debug, Default, PartialEq)]
330pub struct PuppetSetEmbeddedViewPropertiesRequest {
331 pub id: Option<u64>,
332 pub properties: Option<EmbeddedViewProperties>,
333 #[doc(hidden)]
334 pub __source_breaking: fidl::marker::SourceBreaking,
335}
336
337impl fidl::Persistable for PuppetSetEmbeddedViewPropertiesRequest {}
338
339#[derive(Clone, Debug, Default, PartialEq)]
340pub struct PuppetSetEmbeddedViewPropertiesResponse {
341 pub result: Option<Result_>,
342 #[doc(hidden)]
343 pub __source_breaking: fidl::marker::SourceBreaking,
344}
345
346impl fidl::Persistable for PuppetSetEmbeddedViewPropertiesResponse {}
347
348#[derive(Clone, Debug, Default, PartialEq)]
349pub struct PuppetSetImagePropertiesRequest {
350 pub id: Option<u64>,
351 pub properties: Option<ImageProperties>,
352 #[doc(hidden)]
353 pub __source_breaking: fidl::marker::SourceBreaking,
354}
355
356impl fidl::Persistable for PuppetSetImagePropertiesRequest {}
357
358#[derive(Clone, Debug, Default, PartialEq)]
359pub struct PuppetSetImagePropertiesResponse {
360 pub result: Option<Result_>,
361 #[doc(hidden)]
362 pub __source_breaking: fidl::marker::SourceBreaking,
363}
364
365impl fidl::Persistable for PuppetSetImagePropertiesResponse {}
366
367#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
368pub struct PuppetMarker;
369
370impl fidl::endpoints::ProtocolMarker for PuppetMarker {
371 type Proxy = PuppetProxy;
372 type RequestStream = PuppetRequestStream;
373 #[cfg(target_os = "fuchsia")]
374 type SynchronousProxy = PuppetSynchronousProxy;
375
376 const DEBUG_NAME: &'static str = "(anonymous) Puppet";
377}
378
379pub trait PuppetProxyInterface: Send + Sync {
380 type EmbedRemoteViewResponseFut: std::future::Future<Output = Result<PuppetEmbedRemoteViewResponse, fidl::Error>>
381 + Send;
382 fn r#embed_remote_view(
383 &self,
384 payload: &PuppetEmbedRemoteViewRequest,
385 ) -> Self::EmbedRemoteViewResponseFut;
386 type SetEmbeddedViewPropertiesResponseFut: std::future::Future<Output = Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error>>
387 + Send;
388 fn r#set_embedded_view_properties(
389 &self,
390 payload: &PuppetSetEmbeddedViewPropertiesRequest,
391 ) -> Self::SetEmbeddedViewPropertiesResponseFut;
392 type DrawImageResponseFut: std::future::Future<Output = Result<PuppetDrawImageResponse, fidl::Error>>
393 + Send;
394 fn r#draw_image(&self, payload: &PuppetDrawImageRequest) -> Self::DrawImageResponseFut;
395 type SetImagePropertiesResponseFut: std::future::Future<Output = Result<PuppetSetImagePropertiesResponse, fidl::Error>>
396 + Send;
397 fn r#set_image_properties(
398 &self,
399 payload: &PuppetSetImagePropertiesRequest,
400 ) -> Self::SetImagePropertiesResponseFut;
401}
402#[derive(Debug)]
403#[cfg(target_os = "fuchsia")]
404pub struct PuppetSynchronousProxy {
405 client: fidl::client::sync::Client,
406}
407
408#[cfg(target_os = "fuchsia")]
409impl fidl::endpoints::SynchronousProxy for PuppetSynchronousProxy {
410 type Proxy = PuppetProxy;
411 type Protocol = PuppetMarker;
412
413 fn from_channel(inner: fidl::Channel) -> Self {
414 Self::new(inner)
415 }
416
417 fn into_channel(self) -> fidl::Channel {
418 self.client.into_channel()
419 }
420
421 fn as_channel(&self) -> &fidl::Channel {
422 self.client.as_channel()
423 }
424}
425
426#[cfg(target_os = "fuchsia")]
427impl PuppetSynchronousProxy {
428 pub fn new(channel: fidl::Channel) -> Self {
429 let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
430 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
431 }
432
433 pub fn into_channel(self) -> fidl::Channel {
434 self.client.into_channel()
435 }
436
437 pub fn wait_for_event(
440 &self,
441 deadline: zx::MonotonicInstant,
442 ) -> Result<PuppetEvent, fidl::Error> {
443 PuppetEvent::decode(self.client.wait_for_event(deadline)?)
444 }
445
446 pub fn r#embed_remote_view(
453 &self,
454 mut payload: &PuppetEmbedRemoteViewRequest,
455 ___deadline: zx::MonotonicInstant,
456 ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
457 let _response =
458 self.client.send_query::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
459 payload,
460 0x5bb2325a988aa137,
461 fidl::encoding::DynamicFlags::empty(),
462 ___deadline,
463 )?;
464 Ok(_response)
465 }
466
467 pub fn r#set_embedded_view_properties(
469 &self,
470 mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
471 ___deadline: zx::MonotonicInstant,
472 ) -> Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error> {
473 let _response = self.client.send_query::<
474 PuppetSetEmbeddedViewPropertiesRequest,
475 PuppetSetEmbeddedViewPropertiesResponse,
476 >(
477 payload,
478 0x409a7f3de135c709,
479 fidl::encoding::DynamicFlags::empty(),
480 ___deadline,
481 )?;
482 Ok(_response)
483 }
484
485 pub fn r#draw_image(
487 &self,
488 mut payload: &PuppetDrawImageRequest,
489 ___deadline: zx::MonotonicInstant,
490 ) -> Result<PuppetDrawImageResponse, fidl::Error> {
491 let _response = self.client.send_query::<PuppetDrawImageRequest, PuppetDrawImageResponse>(
492 payload,
493 0x6d736daa48b835cc,
494 fidl::encoding::DynamicFlags::empty(),
495 ___deadline,
496 )?;
497 Ok(_response)
498 }
499
500 pub fn r#set_image_properties(
502 &self,
503 mut payload: &PuppetSetImagePropertiesRequest,
504 ___deadline: zx::MonotonicInstant,
505 ) -> Result<PuppetSetImagePropertiesResponse, fidl::Error> {
506 let _response = self
507 .client
508 .send_query::<PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponse>(
509 payload,
510 0x2683795408d033ff,
511 fidl::encoding::DynamicFlags::empty(),
512 ___deadline,
513 )?;
514 Ok(_response)
515 }
516}
517
518#[derive(Debug, Clone)]
519pub struct PuppetProxy {
520 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
521}
522
523impl fidl::endpoints::Proxy for PuppetProxy {
524 type Protocol = PuppetMarker;
525
526 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
527 Self::new(inner)
528 }
529
530 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
531 self.client.into_channel().map_err(|client| Self { client })
532 }
533
534 fn as_channel(&self) -> &::fidl::AsyncChannel {
535 self.client.as_channel()
536 }
537}
538
539impl PuppetProxy {
540 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
542 let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
543 Self { client: fidl::client::Client::new(channel, protocol_name) }
544 }
545
546 pub fn take_event_stream(&self) -> PuppetEventStream {
552 PuppetEventStream { event_receiver: self.client.take_event_receiver() }
553 }
554
555 pub fn r#embed_remote_view(
562 &self,
563 mut payload: &PuppetEmbedRemoteViewRequest,
564 ) -> fidl::client::QueryResponseFut<
565 PuppetEmbedRemoteViewResponse,
566 fidl::encoding::DefaultFuchsiaResourceDialect,
567 > {
568 PuppetProxyInterface::r#embed_remote_view(self, payload)
569 }
570
571 pub fn r#set_embedded_view_properties(
573 &self,
574 mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
575 ) -> fidl::client::QueryResponseFut<
576 PuppetSetEmbeddedViewPropertiesResponse,
577 fidl::encoding::DefaultFuchsiaResourceDialect,
578 > {
579 PuppetProxyInterface::r#set_embedded_view_properties(self, payload)
580 }
581
582 pub fn r#draw_image(
584 &self,
585 mut payload: &PuppetDrawImageRequest,
586 ) -> fidl::client::QueryResponseFut<
587 PuppetDrawImageResponse,
588 fidl::encoding::DefaultFuchsiaResourceDialect,
589 > {
590 PuppetProxyInterface::r#draw_image(self, payload)
591 }
592
593 pub fn r#set_image_properties(
595 &self,
596 mut payload: &PuppetSetImagePropertiesRequest,
597 ) -> fidl::client::QueryResponseFut<
598 PuppetSetImagePropertiesResponse,
599 fidl::encoding::DefaultFuchsiaResourceDialect,
600 > {
601 PuppetProxyInterface::r#set_image_properties(self, payload)
602 }
603}
604
605impl PuppetProxyInterface for PuppetProxy {
606 type EmbedRemoteViewResponseFut = fidl::client::QueryResponseFut<
607 PuppetEmbedRemoteViewResponse,
608 fidl::encoding::DefaultFuchsiaResourceDialect,
609 >;
610 fn r#embed_remote_view(
611 &self,
612 mut payload: &PuppetEmbedRemoteViewRequest,
613 ) -> Self::EmbedRemoteViewResponseFut {
614 fn _decode(
615 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
616 ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
617 let _response = fidl::client::decode_transaction_body::<
618 PuppetEmbedRemoteViewResponse,
619 fidl::encoding::DefaultFuchsiaResourceDialect,
620 0x5bb2325a988aa137,
621 >(_buf?)?;
622 Ok(_response)
623 }
624 self.client
625 .send_query_and_decode::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
626 payload,
627 0x5bb2325a988aa137,
628 fidl::encoding::DynamicFlags::empty(),
629 _decode,
630 )
631 }
632
633 type SetEmbeddedViewPropertiesResponseFut = fidl::client::QueryResponseFut<
634 PuppetSetEmbeddedViewPropertiesResponse,
635 fidl::encoding::DefaultFuchsiaResourceDialect,
636 >;
637 fn r#set_embedded_view_properties(
638 &self,
639 mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
640 ) -> Self::SetEmbeddedViewPropertiesResponseFut {
641 fn _decode(
642 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
643 ) -> Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error> {
644 let _response = fidl::client::decode_transaction_body::<
645 PuppetSetEmbeddedViewPropertiesResponse,
646 fidl::encoding::DefaultFuchsiaResourceDialect,
647 0x409a7f3de135c709,
648 >(_buf?)?;
649 Ok(_response)
650 }
651 self.client.send_query_and_decode::<
652 PuppetSetEmbeddedViewPropertiesRequest,
653 PuppetSetEmbeddedViewPropertiesResponse,
654 >(
655 payload,
656 0x409a7f3de135c709,
657 fidl::encoding::DynamicFlags::empty(),
658 _decode,
659 )
660 }
661
662 type DrawImageResponseFut = fidl::client::QueryResponseFut<
663 PuppetDrawImageResponse,
664 fidl::encoding::DefaultFuchsiaResourceDialect,
665 >;
666 fn r#draw_image(&self, mut payload: &PuppetDrawImageRequest) -> Self::DrawImageResponseFut {
667 fn _decode(
668 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
669 ) -> Result<PuppetDrawImageResponse, fidl::Error> {
670 let _response = fidl::client::decode_transaction_body::<
671 PuppetDrawImageResponse,
672 fidl::encoding::DefaultFuchsiaResourceDialect,
673 0x6d736daa48b835cc,
674 >(_buf?)?;
675 Ok(_response)
676 }
677 self.client.send_query_and_decode::<PuppetDrawImageRequest, PuppetDrawImageResponse>(
678 payload,
679 0x6d736daa48b835cc,
680 fidl::encoding::DynamicFlags::empty(),
681 _decode,
682 )
683 }
684
685 type SetImagePropertiesResponseFut = fidl::client::QueryResponseFut<
686 PuppetSetImagePropertiesResponse,
687 fidl::encoding::DefaultFuchsiaResourceDialect,
688 >;
689 fn r#set_image_properties(
690 &self,
691 mut payload: &PuppetSetImagePropertiesRequest,
692 ) -> Self::SetImagePropertiesResponseFut {
693 fn _decode(
694 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
695 ) -> Result<PuppetSetImagePropertiesResponse, fidl::Error> {
696 let _response = fidl::client::decode_transaction_body::<
697 PuppetSetImagePropertiesResponse,
698 fidl::encoding::DefaultFuchsiaResourceDialect,
699 0x2683795408d033ff,
700 >(_buf?)?;
701 Ok(_response)
702 }
703 self.client.send_query_and_decode::<
704 PuppetSetImagePropertiesRequest,
705 PuppetSetImagePropertiesResponse,
706 >(
707 payload,
708 0x2683795408d033ff,
709 fidl::encoding::DynamicFlags::empty(),
710 _decode,
711 )
712 }
713}
714
715pub struct PuppetEventStream {
716 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
717}
718
719impl std::marker::Unpin for PuppetEventStream {}
720
721impl futures::stream::FusedStream for PuppetEventStream {
722 fn is_terminated(&self) -> bool {
723 self.event_receiver.is_terminated()
724 }
725}
726
727impl futures::Stream for PuppetEventStream {
728 type Item = Result<PuppetEvent, fidl::Error>;
729
730 fn poll_next(
731 mut self: std::pin::Pin<&mut Self>,
732 cx: &mut std::task::Context<'_>,
733 ) -> std::task::Poll<Option<Self::Item>> {
734 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
735 &mut self.event_receiver,
736 cx
737 )?) {
738 Some(buf) => std::task::Poll::Ready(Some(PuppetEvent::decode(buf))),
739 None => std::task::Poll::Ready(None),
740 }
741 }
742}
743
744#[derive(Debug)]
745pub enum PuppetEvent {}
746
747impl PuppetEvent {
748 fn decode(
750 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
751 ) -> Result<PuppetEvent, fidl::Error> {
752 let (bytes, _handles) = buf.split_mut();
753 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
754 debug_assert_eq!(tx_header.tx_id, 0);
755 match tx_header.ordinal {
756 _ => Err(fidl::Error::UnknownOrdinal {
757 ordinal: tx_header.ordinal,
758 protocol_name: <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
759 }),
760 }
761 }
762}
763
764pub struct PuppetRequestStream {
766 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
767 is_terminated: bool,
768}
769
770impl std::marker::Unpin for PuppetRequestStream {}
771
772impl futures::stream::FusedStream for PuppetRequestStream {
773 fn is_terminated(&self) -> bool {
774 self.is_terminated
775 }
776}
777
778impl fidl::endpoints::RequestStream for PuppetRequestStream {
779 type Protocol = PuppetMarker;
780 type ControlHandle = PuppetControlHandle;
781
782 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
783 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
784 }
785
786 fn control_handle(&self) -> Self::ControlHandle {
787 PuppetControlHandle { inner: self.inner.clone() }
788 }
789
790 fn into_inner(
791 self,
792 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
793 {
794 (self.inner, self.is_terminated)
795 }
796
797 fn from_inner(
798 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
799 is_terminated: bool,
800 ) -> Self {
801 Self { inner, is_terminated }
802 }
803}
804
805impl futures::Stream for PuppetRequestStream {
806 type Item = Result<PuppetRequest, fidl::Error>;
807
808 fn poll_next(
809 mut self: std::pin::Pin<&mut Self>,
810 cx: &mut std::task::Context<'_>,
811 ) -> std::task::Poll<Option<Self::Item>> {
812 let this = &mut *self;
813 if this.inner.check_shutdown(cx) {
814 this.is_terminated = true;
815 return std::task::Poll::Ready(None);
816 }
817 if this.is_terminated {
818 panic!("polled PuppetRequestStream after completion");
819 }
820 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
821 |bytes, handles| {
822 match this.inner.channel().read_etc(cx, bytes, handles) {
823 std::task::Poll::Ready(Ok(())) => {}
824 std::task::Poll::Pending => return std::task::Poll::Pending,
825 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
826 this.is_terminated = true;
827 return std::task::Poll::Ready(None);
828 }
829 std::task::Poll::Ready(Err(e)) => {
830 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
831 e.into(),
832 ))))
833 }
834 }
835
836 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
838
839 std::task::Poll::Ready(Some(match header.ordinal {
840 0x5bb2325a988aa137 => {
841 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
842 let mut req = fidl::new_empty!(
843 PuppetEmbedRemoteViewRequest,
844 fidl::encoding::DefaultFuchsiaResourceDialect
845 );
846 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetEmbedRemoteViewRequest>(&header, _body_bytes, handles, &mut req)?;
847 let control_handle = PuppetControlHandle { inner: this.inner.clone() };
848 Ok(PuppetRequest::EmbedRemoteView {
849 payload: req,
850 responder: PuppetEmbedRemoteViewResponder {
851 control_handle: std::mem::ManuallyDrop::new(control_handle),
852 tx_id: header.tx_id,
853 },
854 })
855 }
856 0x409a7f3de135c709 => {
857 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
858 let mut req = fidl::new_empty!(
859 PuppetSetEmbeddedViewPropertiesRequest,
860 fidl::encoding::DefaultFuchsiaResourceDialect
861 );
862 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetEmbeddedViewPropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
863 let control_handle = PuppetControlHandle { inner: this.inner.clone() };
864 Ok(PuppetRequest::SetEmbeddedViewProperties {
865 payload: req,
866 responder: PuppetSetEmbeddedViewPropertiesResponder {
867 control_handle: std::mem::ManuallyDrop::new(control_handle),
868 tx_id: header.tx_id,
869 },
870 })
871 }
872 0x6d736daa48b835cc => {
873 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
874 let mut req = fidl::new_empty!(
875 PuppetDrawImageRequest,
876 fidl::encoding::DefaultFuchsiaResourceDialect
877 );
878 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetDrawImageRequest>(&header, _body_bytes, handles, &mut req)?;
879 let control_handle = PuppetControlHandle { inner: this.inner.clone() };
880 Ok(PuppetRequest::DrawImage {
881 payload: req,
882 responder: PuppetDrawImageResponder {
883 control_handle: std::mem::ManuallyDrop::new(control_handle),
884 tx_id: header.tx_id,
885 },
886 })
887 }
888 0x2683795408d033ff => {
889 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
890 let mut req = fidl::new_empty!(
891 PuppetSetImagePropertiesRequest,
892 fidl::encoding::DefaultFuchsiaResourceDialect
893 );
894 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetImagePropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
895 let control_handle = PuppetControlHandle { inner: this.inner.clone() };
896 Ok(PuppetRequest::SetImageProperties {
897 payload: req,
898 responder: PuppetSetImagePropertiesResponder {
899 control_handle: std::mem::ManuallyDrop::new(control_handle),
900 tx_id: header.tx_id,
901 },
902 })
903 }
904 _ => Err(fidl::Error::UnknownOrdinal {
905 ordinal: header.ordinal,
906 protocol_name:
907 <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
908 }),
909 }))
910 },
911 )
912 }
913}
914
915#[derive(Debug)]
957pub enum PuppetRequest {
958 EmbedRemoteView {
965 payload: PuppetEmbedRemoteViewRequest,
966 responder: PuppetEmbedRemoteViewResponder,
967 },
968 SetEmbeddedViewProperties {
970 payload: PuppetSetEmbeddedViewPropertiesRequest,
971 responder: PuppetSetEmbeddedViewPropertiesResponder,
972 },
973 DrawImage { payload: PuppetDrawImageRequest, responder: PuppetDrawImageResponder },
975 SetImageProperties {
977 payload: PuppetSetImagePropertiesRequest,
978 responder: PuppetSetImagePropertiesResponder,
979 },
980}
981
982impl PuppetRequest {
983 #[allow(irrefutable_let_patterns)]
984 pub fn into_embed_remote_view(
985 self,
986 ) -> Option<(PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponder)> {
987 if let PuppetRequest::EmbedRemoteView { payload, responder } = self {
988 Some((payload, responder))
989 } else {
990 None
991 }
992 }
993
994 #[allow(irrefutable_let_patterns)]
995 pub fn into_set_embedded_view_properties(
996 self,
997 ) -> Option<(PuppetSetEmbeddedViewPropertiesRequest, PuppetSetEmbeddedViewPropertiesResponder)>
998 {
999 if let PuppetRequest::SetEmbeddedViewProperties { payload, responder } = self {
1000 Some((payload, responder))
1001 } else {
1002 None
1003 }
1004 }
1005
1006 #[allow(irrefutable_let_patterns)]
1007 pub fn into_draw_image(self) -> Option<(PuppetDrawImageRequest, PuppetDrawImageResponder)> {
1008 if let PuppetRequest::DrawImage { payload, responder } = self {
1009 Some((payload, responder))
1010 } else {
1011 None
1012 }
1013 }
1014
1015 #[allow(irrefutable_let_patterns)]
1016 pub fn into_set_image_properties(
1017 self,
1018 ) -> Option<(PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponder)> {
1019 if let PuppetRequest::SetImageProperties { payload, responder } = self {
1020 Some((payload, responder))
1021 } else {
1022 None
1023 }
1024 }
1025
1026 pub fn method_name(&self) -> &'static str {
1028 match *self {
1029 PuppetRequest::EmbedRemoteView { .. } => "embed_remote_view",
1030 PuppetRequest::SetEmbeddedViewProperties { .. } => "set_embedded_view_properties",
1031 PuppetRequest::DrawImage { .. } => "draw_image",
1032 PuppetRequest::SetImageProperties { .. } => "set_image_properties",
1033 }
1034 }
1035}
1036
1037#[derive(Debug, Clone)]
1038pub struct PuppetControlHandle {
1039 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1040}
1041
1042impl fidl::endpoints::ControlHandle for PuppetControlHandle {
1043 fn shutdown(&self) {
1044 self.inner.shutdown()
1045 }
1046 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1047 self.inner.shutdown_with_epitaph(status)
1048 }
1049
1050 fn is_closed(&self) -> bool {
1051 self.inner.channel().is_closed()
1052 }
1053 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1054 self.inner.channel().on_closed()
1055 }
1056
1057 #[cfg(target_os = "fuchsia")]
1058 fn signal_peer(
1059 &self,
1060 clear_mask: zx::Signals,
1061 set_mask: zx::Signals,
1062 ) -> Result<(), zx_status::Status> {
1063 use fidl::Peered;
1064 self.inner.channel().signal_peer(clear_mask, set_mask)
1065 }
1066}
1067
1068impl PuppetControlHandle {}
1069
1070#[must_use = "FIDL methods require a response to be sent"]
1071#[derive(Debug)]
1072pub struct PuppetEmbedRemoteViewResponder {
1073 control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1074 tx_id: u32,
1075}
1076
1077impl std::ops::Drop for PuppetEmbedRemoteViewResponder {
1081 fn drop(&mut self) {
1082 self.control_handle.shutdown();
1083 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1085 }
1086}
1087
1088impl fidl::endpoints::Responder for PuppetEmbedRemoteViewResponder {
1089 type ControlHandle = PuppetControlHandle;
1090
1091 fn control_handle(&self) -> &PuppetControlHandle {
1092 &self.control_handle
1093 }
1094
1095 fn drop_without_shutdown(mut self) {
1096 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1098 std::mem::forget(self);
1100 }
1101}
1102
1103impl PuppetEmbedRemoteViewResponder {
1104 pub fn send(self, mut payload: PuppetEmbedRemoteViewResponse) -> Result<(), fidl::Error> {
1108 let _result = self.send_raw(payload);
1109 if _result.is_err() {
1110 self.control_handle.shutdown();
1111 }
1112 self.drop_without_shutdown();
1113 _result
1114 }
1115
1116 pub fn send_no_shutdown_on_err(
1118 self,
1119 mut payload: PuppetEmbedRemoteViewResponse,
1120 ) -> Result<(), fidl::Error> {
1121 let _result = self.send_raw(payload);
1122 self.drop_without_shutdown();
1123 _result
1124 }
1125
1126 fn send_raw(&self, mut payload: PuppetEmbedRemoteViewResponse) -> Result<(), fidl::Error> {
1127 self.control_handle.inner.send::<PuppetEmbedRemoteViewResponse>(
1128 &mut payload,
1129 self.tx_id,
1130 0x5bb2325a988aa137,
1131 fidl::encoding::DynamicFlags::empty(),
1132 )
1133 }
1134}
1135
1136#[must_use = "FIDL methods require a response to be sent"]
1137#[derive(Debug)]
1138pub struct PuppetSetEmbeddedViewPropertiesResponder {
1139 control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1140 tx_id: u32,
1141}
1142
1143impl std::ops::Drop for PuppetSetEmbeddedViewPropertiesResponder {
1147 fn drop(&mut self) {
1148 self.control_handle.shutdown();
1149 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1151 }
1152}
1153
1154impl fidl::endpoints::Responder for PuppetSetEmbeddedViewPropertiesResponder {
1155 type ControlHandle = PuppetControlHandle;
1156
1157 fn control_handle(&self) -> &PuppetControlHandle {
1158 &self.control_handle
1159 }
1160
1161 fn drop_without_shutdown(mut self) {
1162 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1164 std::mem::forget(self);
1166 }
1167}
1168
1169impl PuppetSetEmbeddedViewPropertiesResponder {
1170 pub fn send(
1174 self,
1175 mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1176 ) -> Result<(), fidl::Error> {
1177 let _result = self.send_raw(payload);
1178 if _result.is_err() {
1179 self.control_handle.shutdown();
1180 }
1181 self.drop_without_shutdown();
1182 _result
1183 }
1184
1185 pub fn send_no_shutdown_on_err(
1187 self,
1188 mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1189 ) -> Result<(), fidl::Error> {
1190 let _result = self.send_raw(payload);
1191 self.drop_without_shutdown();
1192 _result
1193 }
1194
1195 fn send_raw(
1196 &self,
1197 mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1198 ) -> Result<(), fidl::Error> {
1199 self.control_handle.inner.send::<PuppetSetEmbeddedViewPropertiesResponse>(
1200 payload,
1201 self.tx_id,
1202 0x409a7f3de135c709,
1203 fidl::encoding::DynamicFlags::empty(),
1204 )
1205 }
1206}
1207
1208#[must_use = "FIDL methods require a response to be sent"]
1209#[derive(Debug)]
1210pub struct PuppetDrawImageResponder {
1211 control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1212 tx_id: u32,
1213}
1214
1215impl std::ops::Drop for PuppetDrawImageResponder {
1219 fn drop(&mut self) {
1220 self.control_handle.shutdown();
1221 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1223 }
1224}
1225
1226impl fidl::endpoints::Responder for PuppetDrawImageResponder {
1227 type ControlHandle = PuppetControlHandle;
1228
1229 fn control_handle(&self) -> &PuppetControlHandle {
1230 &self.control_handle
1231 }
1232
1233 fn drop_without_shutdown(mut self) {
1234 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1236 std::mem::forget(self);
1238 }
1239}
1240
1241impl PuppetDrawImageResponder {
1242 pub fn send(self, mut payload: &PuppetDrawImageResponse) -> Result<(), fidl::Error> {
1246 let _result = self.send_raw(payload);
1247 if _result.is_err() {
1248 self.control_handle.shutdown();
1249 }
1250 self.drop_without_shutdown();
1251 _result
1252 }
1253
1254 pub fn send_no_shutdown_on_err(
1256 self,
1257 mut payload: &PuppetDrawImageResponse,
1258 ) -> Result<(), fidl::Error> {
1259 let _result = self.send_raw(payload);
1260 self.drop_without_shutdown();
1261 _result
1262 }
1263
1264 fn send_raw(&self, mut payload: &PuppetDrawImageResponse) -> Result<(), fidl::Error> {
1265 self.control_handle.inner.send::<PuppetDrawImageResponse>(
1266 payload,
1267 self.tx_id,
1268 0x6d736daa48b835cc,
1269 fidl::encoding::DynamicFlags::empty(),
1270 )
1271 }
1272}
1273
1274#[must_use = "FIDL methods require a response to be sent"]
1275#[derive(Debug)]
1276pub struct PuppetSetImagePropertiesResponder {
1277 control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1278 tx_id: u32,
1279}
1280
1281impl std::ops::Drop for PuppetSetImagePropertiesResponder {
1285 fn drop(&mut self) {
1286 self.control_handle.shutdown();
1287 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1289 }
1290}
1291
1292impl fidl::endpoints::Responder for PuppetSetImagePropertiesResponder {
1293 type ControlHandle = PuppetControlHandle;
1294
1295 fn control_handle(&self) -> &PuppetControlHandle {
1296 &self.control_handle
1297 }
1298
1299 fn drop_without_shutdown(mut self) {
1300 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1302 std::mem::forget(self);
1304 }
1305}
1306
1307impl PuppetSetImagePropertiesResponder {
1308 pub fn send(self, mut payload: &PuppetSetImagePropertiesResponse) -> Result<(), fidl::Error> {
1312 let _result = self.send_raw(payload);
1313 if _result.is_err() {
1314 self.control_handle.shutdown();
1315 }
1316 self.drop_without_shutdown();
1317 _result
1318 }
1319
1320 pub fn send_no_shutdown_on_err(
1322 self,
1323 mut payload: &PuppetSetImagePropertiesResponse,
1324 ) -> Result<(), fidl::Error> {
1325 let _result = self.send_raw(payload);
1326 self.drop_without_shutdown();
1327 _result
1328 }
1329
1330 fn send_raw(&self, mut payload: &PuppetSetImagePropertiesResponse) -> Result<(), fidl::Error> {
1331 self.control_handle.inner.send::<PuppetSetImagePropertiesResponse>(
1332 payload,
1333 self.tx_id,
1334 0x2683795408d033ff,
1335 fidl::encoding::DynamicFlags::empty(),
1336 )
1337 }
1338}
1339
1340#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1341pub struct PuppetFactoryMarker;
1342
1343impl fidl::endpoints::ProtocolMarker for PuppetFactoryMarker {
1344 type Proxy = PuppetFactoryProxy;
1345 type RequestStream = PuppetFactoryRequestStream;
1346 #[cfg(target_os = "fuchsia")]
1347 type SynchronousProxy = PuppetFactorySynchronousProxy;
1348
1349 const DEBUG_NAME: &'static str = "fuchsia.ui.test.conformance.PuppetFactory";
1350}
1351impl fidl::endpoints::DiscoverableProtocolMarker for PuppetFactoryMarker {}
1352
1353pub trait PuppetFactoryProxyInterface: Send + Sync {
1354 type CreateResponseFut: std::future::Future<Output = Result<PuppetFactoryCreateResponse, fidl::Error>>
1355 + Send;
1356 fn r#create(&self, payload: PuppetCreationArgs) -> Self::CreateResponseFut;
1357}
1358#[derive(Debug)]
1359#[cfg(target_os = "fuchsia")]
1360pub struct PuppetFactorySynchronousProxy {
1361 client: fidl::client::sync::Client,
1362}
1363
1364#[cfg(target_os = "fuchsia")]
1365impl fidl::endpoints::SynchronousProxy for PuppetFactorySynchronousProxy {
1366 type Proxy = PuppetFactoryProxy;
1367 type Protocol = PuppetFactoryMarker;
1368
1369 fn from_channel(inner: fidl::Channel) -> Self {
1370 Self::new(inner)
1371 }
1372
1373 fn into_channel(self) -> fidl::Channel {
1374 self.client.into_channel()
1375 }
1376
1377 fn as_channel(&self) -> &fidl::Channel {
1378 self.client.as_channel()
1379 }
1380}
1381
1382#[cfg(target_os = "fuchsia")]
1383impl PuppetFactorySynchronousProxy {
1384 pub fn new(channel: fidl::Channel) -> Self {
1385 let protocol_name = <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1386 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1387 }
1388
1389 pub fn into_channel(self) -> fidl::Channel {
1390 self.client.into_channel()
1391 }
1392
1393 pub fn wait_for_event(
1396 &self,
1397 deadline: zx::MonotonicInstant,
1398 ) -> Result<PuppetFactoryEvent, fidl::Error> {
1399 PuppetFactoryEvent::decode(self.client.wait_for_event(deadline)?)
1400 }
1401
1402 pub fn r#create(
1405 &self,
1406 mut payload: PuppetCreationArgs,
1407 ___deadline: zx::MonotonicInstant,
1408 ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
1409 let _response = self.client.send_query::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
1410 &mut payload,
1411 0x4f90811dc284b595,
1412 fidl::encoding::DynamicFlags::empty(),
1413 ___deadline,
1414 )?;
1415 Ok(_response)
1416 }
1417}
1418
1419#[derive(Debug, Clone)]
1420pub struct PuppetFactoryProxy {
1421 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1422}
1423
1424impl fidl::endpoints::Proxy for PuppetFactoryProxy {
1425 type Protocol = PuppetFactoryMarker;
1426
1427 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1428 Self::new(inner)
1429 }
1430
1431 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1432 self.client.into_channel().map_err(|client| Self { client })
1433 }
1434
1435 fn as_channel(&self) -> &::fidl::AsyncChannel {
1436 self.client.as_channel()
1437 }
1438}
1439
1440impl PuppetFactoryProxy {
1441 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1443 let protocol_name = <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1444 Self { client: fidl::client::Client::new(channel, protocol_name) }
1445 }
1446
1447 pub fn take_event_stream(&self) -> PuppetFactoryEventStream {
1453 PuppetFactoryEventStream { event_receiver: self.client.take_event_receiver() }
1454 }
1455
1456 pub fn r#create(
1459 &self,
1460 mut payload: PuppetCreationArgs,
1461 ) -> fidl::client::QueryResponseFut<
1462 PuppetFactoryCreateResponse,
1463 fidl::encoding::DefaultFuchsiaResourceDialect,
1464 > {
1465 PuppetFactoryProxyInterface::r#create(self, payload)
1466 }
1467}
1468
1469impl PuppetFactoryProxyInterface for PuppetFactoryProxy {
1470 type CreateResponseFut = fidl::client::QueryResponseFut<
1471 PuppetFactoryCreateResponse,
1472 fidl::encoding::DefaultFuchsiaResourceDialect,
1473 >;
1474 fn r#create(&self, mut payload: PuppetCreationArgs) -> Self::CreateResponseFut {
1475 fn _decode(
1476 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1477 ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
1478 let _response = fidl::client::decode_transaction_body::<
1479 PuppetFactoryCreateResponse,
1480 fidl::encoding::DefaultFuchsiaResourceDialect,
1481 0x4f90811dc284b595,
1482 >(_buf?)?;
1483 Ok(_response)
1484 }
1485 self.client.send_query_and_decode::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
1486 &mut payload,
1487 0x4f90811dc284b595,
1488 fidl::encoding::DynamicFlags::empty(),
1489 _decode,
1490 )
1491 }
1492}
1493
1494pub struct PuppetFactoryEventStream {
1495 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1496}
1497
1498impl std::marker::Unpin for PuppetFactoryEventStream {}
1499
1500impl futures::stream::FusedStream for PuppetFactoryEventStream {
1501 fn is_terminated(&self) -> bool {
1502 self.event_receiver.is_terminated()
1503 }
1504}
1505
1506impl futures::Stream for PuppetFactoryEventStream {
1507 type Item = Result<PuppetFactoryEvent, fidl::Error>;
1508
1509 fn poll_next(
1510 mut self: std::pin::Pin<&mut Self>,
1511 cx: &mut std::task::Context<'_>,
1512 ) -> std::task::Poll<Option<Self::Item>> {
1513 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1514 &mut self.event_receiver,
1515 cx
1516 )?) {
1517 Some(buf) => std::task::Poll::Ready(Some(PuppetFactoryEvent::decode(buf))),
1518 None => std::task::Poll::Ready(None),
1519 }
1520 }
1521}
1522
1523#[derive(Debug)]
1524pub enum PuppetFactoryEvent {}
1525
1526impl PuppetFactoryEvent {
1527 fn decode(
1529 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1530 ) -> Result<PuppetFactoryEvent, fidl::Error> {
1531 let (bytes, _handles) = buf.split_mut();
1532 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1533 debug_assert_eq!(tx_header.tx_id, 0);
1534 match tx_header.ordinal {
1535 _ => Err(fidl::Error::UnknownOrdinal {
1536 ordinal: tx_header.ordinal,
1537 protocol_name: <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1538 }),
1539 }
1540 }
1541}
1542
1543pub struct PuppetFactoryRequestStream {
1545 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1546 is_terminated: bool,
1547}
1548
1549impl std::marker::Unpin for PuppetFactoryRequestStream {}
1550
1551impl futures::stream::FusedStream for PuppetFactoryRequestStream {
1552 fn is_terminated(&self) -> bool {
1553 self.is_terminated
1554 }
1555}
1556
1557impl fidl::endpoints::RequestStream for PuppetFactoryRequestStream {
1558 type Protocol = PuppetFactoryMarker;
1559 type ControlHandle = PuppetFactoryControlHandle;
1560
1561 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1562 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1563 }
1564
1565 fn control_handle(&self) -> Self::ControlHandle {
1566 PuppetFactoryControlHandle { inner: self.inner.clone() }
1567 }
1568
1569 fn into_inner(
1570 self,
1571 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1572 {
1573 (self.inner, self.is_terminated)
1574 }
1575
1576 fn from_inner(
1577 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1578 is_terminated: bool,
1579 ) -> Self {
1580 Self { inner, is_terminated }
1581 }
1582}
1583
1584impl futures::Stream for PuppetFactoryRequestStream {
1585 type Item = Result<PuppetFactoryRequest, fidl::Error>;
1586
1587 fn poll_next(
1588 mut self: std::pin::Pin<&mut Self>,
1589 cx: &mut std::task::Context<'_>,
1590 ) -> std::task::Poll<Option<Self::Item>> {
1591 let this = &mut *self;
1592 if this.inner.check_shutdown(cx) {
1593 this.is_terminated = true;
1594 return std::task::Poll::Ready(None);
1595 }
1596 if this.is_terminated {
1597 panic!("polled PuppetFactoryRequestStream after completion");
1598 }
1599 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1600 |bytes, handles| {
1601 match this.inner.channel().read_etc(cx, bytes, handles) {
1602 std::task::Poll::Ready(Ok(())) => {}
1603 std::task::Poll::Pending => return std::task::Poll::Pending,
1604 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1605 this.is_terminated = true;
1606 return std::task::Poll::Ready(None);
1607 }
1608 std::task::Poll::Ready(Err(e)) => {
1609 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1610 e.into(),
1611 ))))
1612 }
1613 }
1614
1615 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1617
1618 std::task::Poll::Ready(Some(match header.ordinal {
1619 0x4f90811dc284b595 => {
1620 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1621 let mut req = fidl::new_empty!(
1622 PuppetCreationArgs,
1623 fidl::encoding::DefaultFuchsiaResourceDialect
1624 );
1625 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetCreationArgs>(&header, _body_bytes, handles, &mut req)?;
1626 let control_handle =
1627 PuppetFactoryControlHandle { inner: this.inner.clone() };
1628 Ok(PuppetFactoryRequest::Create {
1629 payload: req,
1630 responder: PuppetFactoryCreateResponder {
1631 control_handle: std::mem::ManuallyDrop::new(control_handle),
1632 tx_id: header.tx_id,
1633 },
1634 })
1635 }
1636 _ => Err(fidl::Error::UnknownOrdinal {
1637 ordinal: header.ordinal,
1638 protocol_name:
1639 <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1640 }),
1641 }))
1642 },
1643 )
1644 }
1645}
1646
1647#[derive(Debug)]
1650pub enum PuppetFactoryRequest {
1651 Create { payload: PuppetCreationArgs, responder: PuppetFactoryCreateResponder },
1654}
1655
1656impl PuppetFactoryRequest {
1657 #[allow(irrefutable_let_patterns)]
1658 pub fn into_create(self) -> Option<(PuppetCreationArgs, PuppetFactoryCreateResponder)> {
1659 if let PuppetFactoryRequest::Create { payload, responder } = self {
1660 Some((payload, responder))
1661 } else {
1662 None
1663 }
1664 }
1665
1666 pub fn method_name(&self) -> &'static str {
1668 match *self {
1669 PuppetFactoryRequest::Create { .. } => "create",
1670 }
1671 }
1672}
1673
1674#[derive(Debug, Clone)]
1675pub struct PuppetFactoryControlHandle {
1676 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1677}
1678
1679impl fidl::endpoints::ControlHandle for PuppetFactoryControlHandle {
1680 fn shutdown(&self) {
1681 self.inner.shutdown()
1682 }
1683 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1684 self.inner.shutdown_with_epitaph(status)
1685 }
1686
1687 fn is_closed(&self) -> bool {
1688 self.inner.channel().is_closed()
1689 }
1690 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1691 self.inner.channel().on_closed()
1692 }
1693
1694 #[cfg(target_os = "fuchsia")]
1695 fn signal_peer(
1696 &self,
1697 clear_mask: zx::Signals,
1698 set_mask: zx::Signals,
1699 ) -> Result<(), zx_status::Status> {
1700 use fidl::Peered;
1701 self.inner.channel().signal_peer(clear_mask, set_mask)
1702 }
1703}
1704
1705impl PuppetFactoryControlHandle {}
1706
1707#[must_use = "FIDL methods require a response to be sent"]
1708#[derive(Debug)]
1709pub struct PuppetFactoryCreateResponder {
1710 control_handle: std::mem::ManuallyDrop<PuppetFactoryControlHandle>,
1711 tx_id: u32,
1712}
1713
1714impl std::ops::Drop for PuppetFactoryCreateResponder {
1718 fn drop(&mut self) {
1719 self.control_handle.shutdown();
1720 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1722 }
1723}
1724
1725impl fidl::endpoints::Responder for PuppetFactoryCreateResponder {
1726 type ControlHandle = PuppetFactoryControlHandle;
1727
1728 fn control_handle(&self) -> &PuppetFactoryControlHandle {
1729 &self.control_handle
1730 }
1731
1732 fn drop_without_shutdown(mut self) {
1733 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1735 std::mem::forget(self);
1737 }
1738}
1739
1740impl PuppetFactoryCreateResponder {
1741 pub fn send(self, mut payload: PuppetFactoryCreateResponse) -> Result<(), fidl::Error> {
1745 let _result = self.send_raw(payload);
1746 if _result.is_err() {
1747 self.control_handle.shutdown();
1748 }
1749 self.drop_without_shutdown();
1750 _result
1751 }
1752
1753 pub fn send_no_shutdown_on_err(
1755 self,
1756 mut payload: PuppetFactoryCreateResponse,
1757 ) -> Result<(), fidl::Error> {
1758 let _result = self.send_raw(payload);
1759 self.drop_without_shutdown();
1760 _result
1761 }
1762
1763 fn send_raw(&self, mut payload: PuppetFactoryCreateResponse) -> Result<(), fidl::Error> {
1764 self.control_handle.inner.send::<PuppetFactoryCreateResponse>(
1765 &mut payload,
1766 self.tx_id,
1767 0x4f90811dc284b595,
1768 fidl::encoding::DynamicFlags::empty(),
1769 )
1770 }
1771}
1772
1773mod internal {
1774 use super::*;
1775 unsafe impl fidl::encoding::TypeMarker for Color {
1776 type Owned = Self;
1777
1778 #[inline(always)]
1779 fn inline_align(_context: fidl::encoding::Context) -> usize {
1780 std::mem::align_of::<u32>()
1781 }
1782
1783 #[inline(always)]
1784 fn inline_size(_context: fidl::encoding::Context) -> usize {
1785 std::mem::size_of::<u32>()
1786 }
1787
1788 #[inline(always)]
1789 fn encode_is_copy() -> bool {
1790 false
1791 }
1792
1793 #[inline(always)]
1794 fn decode_is_copy() -> bool {
1795 false
1796 }
1797 }
1798
1799 impl fidl::encoding::ValueTypeMarker for Color {
1800 type Borrowed<'a> = Self;
1801 #[inline(always)]
1802 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1803 *value
1804 }
1805 }
1806
1807 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Color {
1808 #[inline]
1809 unsafe fn encode(
1810 self,
1811 encoder: &mut fidl::encoding::Encoder<'_, D>,
1812 offset: usize,
1813 _depth: fidl::encoding::Depth,
1814 ) -> fidl::Result<()> {
1815 encoder.debug_check_bounds::<Self>(offset);
1816 encoder.write_num(self.into_primitive(), offset);
1817 Ok(())
1818 }
1819 }
1820
1821 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Color {
1822 #[inline(always)]
1823 fn new_empty() -> Self {
1824 Self::unknown()
1825 }
1826
1827 #[inline]
1828 unsafe fn decode(
1829 &mut self,
1830 decoder: &mut fidl::encoding::Decoder<'_, D>,
1831 offset: usize,
1832 _depth: fidl::encoding::Depth,
1833 ) -> fidl::Result<()> {
1834 decoder.debug_check_bounds::<Self>(offset);
1835 let prim = decoder.read_num::<u32>(offset);
1836
1837 *self = Self::from_primitive_allow_unknown(prim);
1838 Ok(())
1839 }
1840 }
1841 unsafe impl fidl::encoding::TypeMarker for Result_ {
1842 type Owned = Self;
1843
1844 #[inline(always)]
1845 fn inline_align(_context: fidl::encoding::Context) -> usize {
1846 std::mem::align_of::<u32>()
1847 }
1848
1849 #[inline(always)]
1850 fn inline_size(_context: fidl::encoding::Context) -> usize {
1851 std::mem::size_of::<u32>()
1852 }
1853
1854 #[inline(always)]
1855 fn encode_is_copy() -> bool {
1856 false
1857 }
1858
1859 #[inline(always)]
1860 fn decode_is_copy() -> bool {
1861 false
1862 }
1863 }
1864
1865 impl fidl::encoding::ValueTypeMarker for Result_ {
1866 type Borrowed<'a> = Self;
1867 #[inline(always)]
1868 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1869 *value
1870 }
1871 }
1872
1873 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Result_ {
1874 #[inline]
1875 unsafe fn encode(
1876 self,
1877 encoder: &mut fidl::encoding::Encoder<'_, D>,
1878 offset: usize,
1879 _depth: fidl::encoding::Depth,
1880 ) -> fidl::Result<()> {
1881 encoder.debug_check_bounds::<Self>(offset);
1882 encoder.write_num(self.into_primitive(), offset);
1883 Ok(())
1884 }
1885 }
1886
1887 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Result_ {
1888 #[inline(always)]
1889 fn new_empty() -> Self {
1890 Self::unknown()
1891 }
1892
1893 #[inline]
1894 unsafe fn decode(
1895 &mut self,
1896 decoder: &mut fidl::encoding::Decoder<'_, D>,
1897 offset: usize,
1898 _depth: fidl::encoding::Depth,
1899 ) -> fidl::Result<()> {
1900 decoder.debug_check_bounds::<Self>(offset);
1901 let prim = decoder.read_num::<u32>(offset);
1902
1903 *self = Self::from_primitive_allow_unknown(prim);
1904 Ok(())
1905 }
1906 }
1907
1908 impl ContentBounds {
1909 #[inline(always)]
1910 fn max_ordinal_present(&self) -> u64 {
1911 if let Some(_) = self.origin {
1912 return 2;
1913 }
1914 if let Some(_) = self.size {
1915 return 1;
1916 }
1917 0
1918 }
1919 }
1920
1921 impl fidl::encoding::ValueTypeMarker for ContentBounds {
1922 type Borrowed<'a> = &'a Self;
1923 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1924 value
1925 }
1926 }
1927
1928 unsafe impl fidl::encoding::TypeMarker for ContentBounds {
1929 type Owned = Self;
1930
1931 #[inline(always)]
1932 fn inline_align(_context: fidl::encoding::Context) -> usize {
1933 8
1934 }
1935
1936 #[inline(always)]
1937 fn inline_size(_context: fidl::encoding::Context) -> usize {
1938 16
1939 }
1940 }
1941
1942 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ContentBounds, D>
1943 for &ContentBounds
1944 {
1945 unsafe fn encode(
1946 self,
1947 encoder: &mut fidl::encoding::Encoder<'_, D>,
1948 offset: usize,
1949 mut depth: fidl::encoding::Depth,
1950 ) -> fidl::Result<()> {
1951 encoder.debug_check_bounds::<ContentBounds>(offset);
1952 let max_ordinal: u64 = self.max_ordinal_present();
1954 encoder.write_num(max_ordinal, offset);
1955 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1956 if max_ordinal == 0 {
1958 return Ok(());
1959 }
1960 depth.increment()?;
1961 let envelope_size = 8;
1962 let bytes_len = max_ordinal as usize * envelope_size;
1963 #[allow(unused_variables)]
1964 let offset = encoder.out_of_line_offset(bytes_len);
1965 let mut _prev_end_offset: usize = 0;
1966 if 1 > max_ordinal {
1967 return Ok(());
1968 }
1969
1970 let cur_offset: usize = (1 - 1) * envelope_size;
1973
1974 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1976
1977 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::SizeU, D>(
1982 self.size
1983 .as_ref()
1984 .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
1985 encoder,
1986 offset + cur_offset,
1987 depth,
1988 )?;
1989
1990 _prev_end_offset = cur_offset + envelope_size;
1991 if 2 > max_ordinal {
1992 return Ok(());
1993 }
1994
1995 let cur_offset: usize = (2 - 1) * envelope_size;
1998
1999 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2001
2002 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::Vec_, D>(
2007 self.origin
2008 .as_ref()
2009 .map(<fidl_fuchsia_math::Vec_ as fidl::encoding::ValueTypeMarker>::borrow),
2010 encoder,
2011 offset + cur_offset,
2012 depth,
2013 )?;
2014
2015 _prev_end_offset = cur_offset + envelope_size;
2016
2017 Ok(())
2018 }
2019 }
2020
2021 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContentBounds {
2022 #[inline(always)]
2023 fn new_empty() -> Self {
2024 Self::default()
2025 }
2026
2027 unsafe fn decode(
2028 &mut self,
2029 decoder: &mut fidl::encoding::Decoder<'_, D>,
2030 offset: usize,
2031 mut depth: fidl::encoding::Depth,
2032 ) -> fidl::Result<()> {
2033 decoder.debug_check_bounds::<Self>(offset);
2034 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2035 None => return Err(fidl::Error::NotNullable),
2036 Some(len) => len,
2037 };
2038 if len == 0 {
2040 return Ok(());
2041 };
2042 depth.increment()?;
2043 let envelope_size = 8;
2044 let bytes_len = len * envelope_size;
2045 let offset = decoder.out_of_line_offset(bytes_len)?;
2046 let mut _next_ordinal_to_read = 0;
2048 let mut next_offset = offset;
2049 let end_offset = offset + bytes_len;
2050 _next_ordinal_to_read += 1;
2051 if next_offset >= end_offset {
2052 return Ok(());
2053 }
2054
2055 while _next_ordinal_to_read < 1 {
2057 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2058 _next_ordinal_to_read += 1;
2059 next_offset += envelope_size;
2060 }
2061
2062 let next_out_of_line = decoder.next_out_of_line();
2063 let handles_before = decoder.remaining_handles();
2064 if let Some((inlined, num_bytes, num_handles)) =
2065 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2066 {
2067 let member_inline_size =
2068 <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
2069 decoder.context,
2070 );
2071 if inlined != (member_inline_size <= 4) {
2072 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2073 }
2074 let inner_offset;
2075 let mut inner_depth = depth.clone();
2076 if inlined {
2077 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2078 inner_offset = next_offset;
2079 } else {
2080 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2081 inner_depth.increment()?;
2082 }
2083 let val_ref =
2084 self.size.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::SizeU, D));
2085 fidl::decode!(
2086 fidl_fuchsia_math::SizeU,
2087 D,
2088 val_ref,
2089 decoder,
2090 inner_offset,
2091 inner_depth
2092 )?;
2093 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2094 {
2095 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2096 }
2097 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2098 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2099 }
2100 }
2101
2102 next_offset += envelope_size;
2103 _next_ordinal_to_read += 1;
2104 if next_offset >= end_offset {
2105 return Ok(());
2106 }
2107
2108 while _next_ordinal_to_read < 2 {
2110 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2111 _next_ordinal_to_read += 1;
2112 next_offset += envelope_size;
2113 }
2114
2115 let next_out_of_line = decoder.next_out_of_line();
2116 let handles_before = decoder.remaining_handles();
2117 if let Some((inlined, num_bytes, num_handles)) =
2118 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2119 {
2120 let member_inline_size =
2121 <fidl_fuchsia_math::Vec_ as fidl::encoding::TypeMarker>::inline_size(
2122 decoder.context,
2123 );
2124 if inlined != (member_inline_size <= 4) {
2125 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2126 }
2127 let inner_offset;
2128 let mut inner_depth = depth.clone();
2129 if inlined {
2130 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2131 inner_offset = next_offset;
2132 } else {
2133 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2134 inner_depth.increment()?;
2135 }
2136 let val_ref =
2137 self.origin.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::Vec_, D));
2138 fidl::decode!(
2139 fidl_fuchsia_math::Vec_,
2140 D,
2141 val_ref,
2142 decoder,
2143 inner_offset,
2144 inner_depth
2145 )?;
2146 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2147 {
2148 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2149 }
2150 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2151 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2152 }
2153 }
2154
2155 next_offset += envelope_size;
2156
2157 while next_offset < end_offset {
2159 _next_ordinal_to_read += 1;
2160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2161 next_offset += envelope_size;
2162 }
2163
2164 Ok(())
2165 }
2166 }
2167
2168 impl EmbeddedViewProperties {
2169 #[inline(always)]
2170 fn max_ordinal_present(&self) -> u64 {
2171 if let Some(_) = self.bounds {
2172 return 1;
2173 }
2174 0
2175 }
2176 }
2177
2178 impl fidl::encoding::ValueTypeMarker for EmbeddedViewProperties {
2179 type Borrowed<'a> = &'a Self;
2180 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2181 value
2182 }
2183 }
2184
2185 unsafe impl fidl::encoding::TypeMarker for EmbeddedViewProperties {
2186 type Owned = Self;
2187
2188 #[inline(always)]
2189 fn inline_align(_context: fidl::encoding::Context) -> usize {
2190 8
2191 }
2192
2193 #[inline(always)]
2194 fn inline_size(_context: fidl::encoding::Context) -> usize {
2195 16
2196 }
2197 }
2198
2199 unsafe impl<D: fidl::encoding::ResourceDialect>
2200 fidl::encoding::Encode<EmbeddedViewProperties, D> for &EmbeddedViewProperties
2201 {
2202 unsafe fn encode(
2203 self,
2204 encoder: &mut fidl::encoding::Encoder<'_, D>,
2205 offset: usize,
2206 mut depth: fidl::encoding::Depth,
2207 ) -> fidl::Result<()> {
2208 encoder.debug_check_bounds::<EmbeddedViewProperties>(offset);
2209 let max_ordinal: u64 = self.max_ordinal_present();
2211 encoder.write_num(max_ordinal, offset);
2212 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2213 if max_ordinal == 0 {
2215 return Ok(());
2216 }
2217 depth.increment()?;
2218 let envelope_size = 8;
2219 let bytes_len = max_ordinal as usize * envelope_size;
2220 #[allow(unused_variables)]
2221 let offset = encoder.out_of_line_offset(bytes_len);
2222 let mut _prev_end_offset: usize = 0;
2223 if 1 > max_ordinal {
2224 return Ok(());
2225 }
2226
2227 let cur_offset: usize = (1 - 1) * envelope_size;
2230
2231 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2233
2234 fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2239 self.bounds
2240 .as_ref()
2241 .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2242 encoder,
2243 offset + cur_offset,
2244 depth,
2245 )?;
2246
2247 _prev_end_offset = cur_offset + envelope_size;
2248
2249 Ok(())
2250 }
2251 }
2252
2253 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2254 for EmbeddedViewProperties
2255 {
2256 #[inline(always)]
2257 fn new_empty() -> Self {
2258 Self::default()
2259 }
2260
2261 unsafe fn decode(
2262 &mut self,
2263 decoder: &mut fidl::encoding::Decoder<'_, D>,
2264 offset: usize,
2265 mut depth: fidl::encoding::Depth,
2266 ) -> fidl::Result<()> {
2267 decoder.debug_check_bounds::<Self>(offset);
2268 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2269 None => return Err(fidl::Error::NotNullable),
2270 Some(len) => len,
2271 };
2272 if len == 0 {
2274 return Ok(());
2275 };
2276 depth.increment()?;
2277 let envelope_size = 8;
2278 let bytes_len = len * envelope_size;
2279 let offset = decoder.out_of_line_offset(bytes_len)?;
2280 let mut _next_ordinal_to_read = 0;
2282 let mut next_offset = offset;
2283 let end_offset = offset + bytes_len;
2284 _next_ordinal_to_read += 1;
2285 if next_offset >= end_offset {
2286 return Ok(());
2287 }
2288
2289 while _next_ordinal_to_read < 1 {
2291 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2292 _next_ordinal_to_read += 1;
2293 next_offset += envelope_size;
2294 }
2295
2296 let next_out_of_line = decoder.next_out_of_line();
2297 let handles_before = decoder.remaining_handles();
2298 if let Some((inlined, num_bytes, num_handles)) =
2299 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2300 {
2301 let member_inline_size =
2302 <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2303 if inlined != (member_inline_size <= 4) {
2304 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2305 }
2306 let inner_offset;
2307 let mut inner_depth = depth.clone();
2308 if inlined {
2309 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2310 inner_offset = next_offset;
2311 } else {
2312 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2313 inner_depth.increment()?;
2314 }
2315 let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2316 fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2317 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2318 {
2319 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2320 }
2321 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2322 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2323 }
2324 }
2325
2326 next_offset += envelope_size;
2327
2328 while next_offset < end_offset {
2330 _next_ordinal_to_read += 1;
2331 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2332 next_offset += envelope_size;
2333 }
2334
2335 Ok(())
2336 }
2337 }
2338
2339 impl FilledRect {
2340 #[inline(always)]
2341 fn max_ordinal_present(&self) -> u64 {
2342 if let Some(_) = self.bounds {
2343 return 2;
2344 }
2345 if let Some(_) = self.color {
2346 return 1;
2347 }
2348 0
2349 }
2350 }
2351
2352 impl fidl::encoding::ValueTypeMarker for FilledRect {
2353 type Borrowed<'a> = &'a Self;
2354 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2355 value
2356 }
2357 }
2358
2359 unsafe impl fidl::encoding::TypeMarker for FilledRect {
2360 type Owned = Self;
2361
2362 #[inline(always)]
2363 fn inline_align(_context: fidl::encoding::Context) -> usize {
2364 8
2365 }
2366
2367 #[inline(always)]
2368 fn inline_size(_context: fidl::encoding::Context) -> usize {
2369 16
2370 }
2371 }
2372
2373 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilledRect, D>
2374 for &FilledRect
2375 {
2376 unsafe fn encode(
2377 self,
2378 encoder: &mut fidl::encoding::Encoder<'_, D>,
2379 offset: usize,
2380 mut depth: fidl::encoding::Depth,
2381 ) -> fidl::Result<()> {
2382 encoder.debug_check_bounds::<FilledRect>(offset);
2383 let max_ordinal: u64 = self.max_ordinal_present();
2385 encoder.write_num(max_ordinal, offset);
2386 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2387 if max_ordinal == 0 {
2389 return Ok(());
2390 }
2391 depth.increment()?;
2392 let envelope_size = 8;
2393 let bytes_len = max_ordinal as usize * envelope_size;
2394 #[allow(unused_variables)]
2395 let offset = encoder.out_of_line_offset(bytes_len);
2396 let mut _prev_end_offset: usize = 0;
2397 if 1 > max_ordinal {
2398 return Ok(());
2399 }
2400
2401 let cur_offset: usize = (1 - 1) * envelope_size;
2404
2405 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2407
2408 fidl::encoding::encode_in_envelope_optional::<Color, D>(
2413 self.color.as_ref().map(<Color as fidl::encoding::ValueTypeMarker>::borrow),
2414 encoder,
2415 offset + cur_offset,
2416 depth,
2417 )?;
2418
2419 _prev_end_offset = cur_offset + envelope_size;
2420 if 2 > max_ordinal {
2421 return Ok(());
2422 }
2423
2424 let cur_offset: usize = (2 - 1) * envelope_size;
2427
2428 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2430
2431 fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2436 self.bounds
2437 .as_ref()
2438 .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2439 encoder,
2440 offset + cur_offset,
2441 depth,
2442 )?;
2443
2444 _prev_end_offset = cur_offset + envelope_size;
2445
2446 Ok(())
2447 }
2448 }
2449
2450 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilledRect {
2451 #[inline(always)]
2452 fn new_empty() -> Self {
2453 Self::default()
2454 }
2455
2456 unsafe fn decode(
2457 &mut self,
2458 decoder: &mut fidl::encoding::Decoder<'_, D>,
2459 offset: usize,
2460 mut depth: fidl::encoding::Depth,
2461 ) -> fidl::Result<()> {
2462 decoder.debug_check_bounds::<Self>(offset);
2463 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2464 None => return Err(fidl::Error::NotNullable),
2465 Some(len) => len,
2466 };
2467 if len == 0 {
2469 return Ok(());
2470 };
2471 depth.increment()?;
2472 let envelope_size = 8;
2473 let bytes_len = len * envelope_size;
2474 let offset = decoder.out_of_line_offset(bytes_len)?;
2475 let mut _next_ordinal_to_read = 0;
2477 let mut next_offset = offset;
2478 let end_offset = offset + bytes_len;
2479 _next_ordinal_to_read += 1;
2480 if next_offset >= end_offset {
2481 return Ok(());
2482 }
2483
2484 while _next_ordinal_to_read < 1 {
2486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2487 _next_ordinal_to_read += 1;
2488 next_offset += envelope_size;
2489 }
2490
2491 let next_out_of_line = decoder.next_out_of_line();
2492 let handles_before = decoder.remaining_handles();
2493 if let Some((inlined, num_bytes, num_handles)) =
2494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2495 {
2496 let member_inline_size =
2497 <Color as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2498 if inlined != (member_inline_size <= 4) {
2499 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2500 }
2501 let inner_offset;
2502 let mut inner_depth = depth.clone();
2503 if inlined {
2504 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2505 inner_offset = next_offset;
2506 } else {
2507 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2508 inner_depth.increment()?;
2509 }
2510 let val_ref = self.color.get_or_insert_with(|| fidl::new_empty!(Color, D));
2511 fidl::decode!(Color, D, val_ref, decoder, inner_offset, inner_depth)?;
2512 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2513 {
2514 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2515 }
2516 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2517 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2518 }
2519 }
2520
2521 next_offset += envelope_size;
2522 _next_ordinal_to_read += 1;
2523 if next_offset >= end_offset {
2524 return Ok(());
2525 }
2526
2527 while _next_ordinal_to_read < 2 {
2529 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2530 _next_ordinal_to_read += 1;
2531 next_offset += envelope_size;
2532 }
2533
2534 let next_out_of_line = decoder.next_out_of_line();
2535 let handles_before = decoder.remaining_handles();
2536 if let Some((inlined, num_bytes, num_handles)) =
2537 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2538 {
2539 let member_inline_size =
2540 <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2541 if inlined != (member_inline_size <= 4) {
2542 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2543 }
2544 let inner_offset;
2545 let mut inner_depth = depth.clone();
2546 if inlined {
2547 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2548 inner_offset = next_offset;
2549 } else {
2550 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2551 inner_depth.increment()?;
2552 }
2553 let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2554 fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2555 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2556 {
2557 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2558 }
2559 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2560 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2561 }
2562 }
2563
2564 next_offset += envelope_size;
2565
2566 while next_offset < end_offset {
2568 _next_ordinal_to_read += 1;
2569 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2570 next_offset += envelope_size;
2571 }
2572
2573 Ok(())
2574 }
2575 }
2576
2577 impl ImageProperties {
2578 #[inline(always)]
2579 fn max_ordinal_present(&self) -> u64 {
2580 if let Some(_) = self.filled_rects {
2581 return 2;
2582 }
2583 if let Some(_) = self.bounds {
2584 return 1;
2585 }
2586 0
2587 }
2588 }
2589
2590 impl fidl::encoding::ValueTypeMarker for ImageProperties {
2591 type Borrowed<'a> = &'a Self;
2592 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2593 value
2594 }
2595 }
2596
2597 unsafe impl fidl::encoding::TypeMarker for ImageProperties {
2598 type Owned = Self;
2599
2600 #[inline(always)]
2601 fn inline_align(_context: fidl::encoding::Context) -> usize {
2602 8
2603 }
2604
2605 #[inline(always)]
2606 fn inline_size(_context: fidl::encoding::Context) -> usize {
2607 16
2608 }
2609 }
2610
2611 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageProperties, D>
2612 for &ImageProperties
2613 {
2614 unsafe fn encode(
2615 self,
2616 encoder: &mut fidl::encoding::Encoder<'_, D>,
2617 offset: usize,
2618 mut depth: fidl::encoding::Depth,
2619 ) -> fidl::Result<()> {
2620 encoder.debug_check_bounds::<ImageProperties>(offset);
2621 let max_ordinal: u64 = self.max_ordinal_present();
2623 encoder.write_num(max_ordinal, offset);
2624 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2625 if max_ordinal == 0 {
2627 return Ok(());
2628 }
2629 depth.increment()?;
2630 let envelope_size = 8;
2631 let bytes_len = max_ordinal as usize * envelope_size;
2632 #[allow(unused_variables)]
2633 let offset = encoder.out_of_line_offset(bytes_len);
2634 let mut _prev_end_offset: usize = 0;
2635 if 1 > max_ordinal {
2636 return Ok(());
2637 }
2638
2639 let cur_offset: usize = (1 - 1) * envelope_size;
2642
2643 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2645
2646 fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2651 self.bounds
2652 .as_ref()
2653 .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2654 encoder,
2655 offset + cur_offset,
2656 depth,
2657 )?;
2658
2659 _prev_end_offset = cur_offset + envelope_size;
2660 if 2 > max_ordinal {
2661 return Ok(());
2662 }
2663
2664 let cur_offset: usize = (2 - 1) * envelope_size;
2667
2668 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2670
2671 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<FilledRect, 1024>, D>(
2676 self.filled_rects.as_ref().map(<fidl::encoding::Vector<FilledRect, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
2677 encoder, offset + cur_offset, depth
2678 )?;
2679
2680 _prev_end_offset = cur_offset + envelope_size;
2681
2682 Ok(())
2683 }
2684 }
2685
2686 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageProperties {
2687 #[inline(always)]
2688 fn new_empty() -> Self {
2689 Self::default()
2690 }
2691
2692 unsafe fn decode(
2693 &mut self,
2694 decoder: &mut fidl::encoding::Decoder<'_, D>,
2695 offset: usize,
2696 mut depth: fidl::encoding::Depth,
2697 ) -> fidl::Result<()> {
2698 decoder.debug_check_bounds::<Self>(offset);
2699 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2700 None => return Err(fidl::Error::NotNullable),
2701 Some(len) => len,
2702 };
2703 if len == 0 {
2705 return Ok(());
2706 };
2707 depth.increment()?;
2708 let envelope_size = 8;
2709 let bytes_len = len * envelope_size;
2710 let offset = decoder.out_of_line_offset(bytes_len)?;
2711 let mut _next_ordinal_to_read = 0;
2713 let mut next_offset = offset;
2714 let end_offset = offset + bytes_len;
2715 _next_ordinal_to_read += 1;
2716 if next_offset >= end_offset {
2717 return Ok(());
2718 }
2719
2720 while _next_ordinal_to_read < 1 {
2722 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2723 _next_ordinal_to_read += 1;
2724 next_offset += envelope_size;
2725 }
2726
2727 let next_out_of_line = decoder.next_out_of_line();
2728 let handles_before = decoder.remaining_handles();
2729 if let Some((inlined, num_bytes, num_handles)) =
2730 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2731 {
2732 let member_inline_size =
2733 <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2734 if inlined != (member_inline_size <= 4) {
2735 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2736 }
2737 let inner_offset;
2738 let mut inner_depth = depth.clone();
2739 if inlined {
2740 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2741 inner_offset = next_offset;
2742 } else {
2743 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2744 inner_depth.increment()?;
2745 }
2746 let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2747 fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2748 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2749 {
2750 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2751 }
2752 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2753 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2754 }
2755 }
2756
2757 next_offset += envelope_size;
2758 _next_ordinal_to_read += 1;
2759 if next_offset >= end_offset {
2760 return Ok(());
2761 }
2762
2763 while _next_ordinal_to_read < 2 {
2765 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2766 _next_ordinal_to_read += 1;
2767 next_offset += envelope_size;
2768 }
2769
2770 let next_out_of_line = decoder.next_out_of_line();
2771 let handles_before = decoder.remaining_handles();
2772 if let Some((inlined, num_bytes, num_handles)) =
2773 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2774 {
2775 let member_inline_size = <fidl::encoding::Vector<FilledRect, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2776 if inlined != (member_inline_size <= 4) {
2777 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2778 }
2779 let inner_offset;
2780 let mut inner_depth = depth.clone();
2781 if inlined {
2782 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2783 inner_offset = next_offset;
2784 } else {
2785 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2786 inner_depth.increment()?;
2787 }
2788 let val_ref = self.filled_rects.get_or_insert_with(
2789 || fidl::new_empty!(fidl::encoding::Vector<FilledRect, 1024>, D),
2790 );
2791 fidl::decode!(fidl::encoding::Vector<FilledRect, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
2792 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2793 {
2794 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2795 }
2796 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2797 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2798 }
2799 }
2800
2801 next_offset += envelope_size;
2802
2803 while next_offset < end_offset {
2805 _next_ordinal_to_read += 1;
2806 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2807 next_offset += envelope_size;
2808 }
2809
2810 Ok(())
2811 }
2812 }
2813
2814 impl PuppetCreationArgs {
2815 #[inline(always)]
2816 fn max_ordinal_present(&self) -> u64 {
2817 if let Some(_) = self.focuser {
2818 return 9;
2819 }
2820 if let Some(_) = self.device_pixel_ratio {
2821 return 8;
2822 }
2823 if let Some(_) = self.keyboard_client {
2824 return 7;
2825 }
2826 if let Some(_) = self.flatland_client {
2827 return 6;
2828 }
2829 if let Some(_) = self.keyboard_listener {
2830 return 5;
2831 }
2832 if let Some(_) = self.mouse_listener {
2833 return 4;
2834 }
2835 if let Some(_) = self.touch_listener {
2836 return 3;
2837 }
2838 if let Some(_) = self.view_token {
2839 return 2;
2840 }
2841 if let Some(_) = self.server_end {
2842 return 1;
2843 }
2844 0
2845 }
2846 }
2847
2848 impl fidl::encoding::ResourceTypeMarker for PuppetCreationArgs {
2849 type Borrowed<'a> = &'a mut Self;
2850 fn take_or_borrow<'a>(
2851 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2852 ) -> Self::Borrowed<'a> {
2853 value
2854 }
2855 }
2856
2857 unsafe impl fidl::encoding::TypeMarker for PuppetCreationArgs {
2858 type Owned = Self;
2859
2860 #[inline(always)]
2861 fn inline_align(_context: fidl::encoding::Context) -> usize {
2862 8
2863 }
2864
2865 #[inline(always)]
2866 fn inline_size(_context: fidl::encoding::Context) -> usize {
2867 16
2868 }
2869 }
2870
2871 unsafe impl
2872 fidl::encoding::Encode<PuppetCreationArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2873 for &mut PuppetCreationArgs
2874 {
2875 unsafe fn encode(
2876 self,
2877 encoder: &mut fidl::encoding::Encoder<
2878 '_,
2879 fidl::encoding::DefaultFuchsiaResourceDialect,
2880 >,
2881 offset: usize,
2882 mut depth: fidl::encoding::Depth,
2883 ) -> fidl::Result<()> {
2884 encoder.debug_check_bounds::<PuppetCreationArgs>(offset);
2885 let max_ordinal: u64 = self.max_ordinal_present();
2887 encoder.write_num(max_ordinal, offset);
2888 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2889 if max_ordinal == 0 {
2891 return Ok(());
2892 }
2893 depth.increment()?;
2894 let envelope_size = 8;
2895 let bytes_len = max_ordinal as usize * envelope_size;
2896 #[allow(unused_variables)]
2897 let offset = encoder.out_of_line_offset(bytes_len);
2898 let mut _prev_end_offset: usize = 0;
2899 if 1 > max_ordinal {
2900 return Ok(());
2901 }
2902
2903 let cur_offset: usize = (1 - 1) * envelope_size;
2906
2907 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2909
2910 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
2915 self.server_end.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2916 encoder, offset + cur_offset, depth
2917 )?;
2918
2919 _prev_end_offset = cur_offset + envelope_size;
2920 if 2 > max_ordinal {
2921 return Ok(());
2922 }
2923
2924 let cur_offset: usize = (2 - 1) * envelope_size;
2927
2928 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2930
2931 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
2936 self.view_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2937 encoder, offset + cur_offset, depth
2938 )?;
2939
2940 _prev_end_offset = cur_offset + envelope_size;
2941 if 3 > max_ordinal {
2942 return Ok(());
2943 }
2944
2945 let cur_offset: usize = (3 - 1) * envelope_size;
2948
2949 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2951
2952 fidl::encoding::encode_in_envelope_optional::<
2957 fidl::encoding::Endpoint<
2958 fidl::endpoints::ClientEnd<
2959 fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
2960 >,
2961 >,
2962 fidl::encoding::DefaultFuchsiaResourceDialect,
2963 >(
2964 self.touch_listener.as_mut().map(
2965 <fidl::encoding::Endpoint<
2966 fidl::endpoints::ClientEnd<
2967 fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
2968 >,
2969 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2970 ),
2971 encoder,
2972 offset + cur_offset,
2973 depth,
2974 )?;
2975
2976 _prev_end_offset = cur_offset + envelope_size;
2977 if 4 > max_ordinal {
2978 return Ok(());
2979 }
2980
2981 let cur_offset: usize = (4 - 1) * envelope_size;
2984
2985 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2987
2988 fidl::encoding::encode_in_envelope_optional::<
2993 fidl::encoding::Endpoint<
2994 fidl::endpoints::ClientEnd<
2995 fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
2996 >,
2997 >,
2998 fidl::encoding::DefaultFuchsiaResourceDialect,
2999 >(
3000 self.mouse_listener.as_mut().map(
3001 <fidl::encoding::Endpoint<
3002 fidl::endpoints::ClientEnd<
3003 fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3004 >,
3005 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3006 ),
3007 encoder,
3008 offset + cur_offset,
3009 depth,
3010 )?;
3011
3012 _prev_end_offset = cur_offset + envelope_size;
3013 if 5 > max_ordinal {
3014 return Ok(());
3015 }
3016
3017 let cur_offset: usize = (5 - 1) * envelope_size;
3020
3021 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3023
3024 fidl::encoding::encode_in_envelope_optional::<
3029 fidl::encoding::Endpoint<
3030 fidl::endpoints::ClientEnd<
3031 fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3032 >,
3033 >,
3034 fidl::encoding::DefaultFuchsiaResourceDialect,
3035 >(
3036 self.keyboard_listener.as_mut().map(
3037 <fidl::encoding::Endpoint<
3038 fidl::endpoints::ClientEnd<
3039 fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3040 >,
3041 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3042 ),
3043 encoder,
3044 offset + cur_offset,
3045 depth,
3046 )?;
3047
3048 _prev_end_offset = cur_offset + envelope_size;
3049 if 6 > max_ordinal {
3050 return Ok(());
3051 }
3052
3053 let cur_offset: usize = (6 - 1) * envelope_size;
3056
3057 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3059
3060 fidl::encoding::encode_in_envelope_optional::<
3065 fidl::encoding::Endpoint<
3066 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3067 >,
3068 fidl::encoding::DefaultFuchsiaResourceDialect,
3069 >(
3070 self.flatland_client.as_mut().map(
3071 <fidl::encoding::Endpoint<
3072 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3073 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3074 ),
3075 encoder,
3076 offset + cur_offset,
3077 depth,
3078 )?;
3079
3080 _prev_end_offset = cur_offset + envelope_size;
3081 if 7 > max_ordinal {
3082 return Ok(());
3083 }
3084
3085 let cur_offset: usize = (7 - 1) * envelope_size;
3088
3089 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3091
3092 fidl::encoding::encode_in_envelope_optional::<
3097 fidl::encoding::Endpoint<
3098 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3099 >,
3100 fidl::encoding::DefaultFuchsiaResourceDialect,
3101 >(
3102 self.keyboard_client.as_mut().map(
3103 <fidl::encoding::Endpoint<
3104 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3105 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3106 ),
3107 encoder,
3108 offset + cur_offset,
3109 depth,
3110 )?;
3111
3112 _prev_end_offset = cur_offset + envelope_size;
3113 if 8 > max_ordinal {
3114 return Ok(());
3115 }
3116
3117 let cur_offset: usize = (8 - 1) * envelope_size;
3120
3121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3123
3124 fidl::encoding::encode_in_envelope_optional::<
3129 f32,
3130 fidl::encoding::DefaultFuchsiaResourceDialect,
3131 >(
3132 self.device_pixel_ratio
3133 .as_ref()
3134 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
3135 encoder,
3136 offset + cur_offset,
3137 depth,
3138 )?;
3139
3140 _prev_end_offset = cur_offset + envelope_size;
3141 if 9 > max_ordinal {
3142 return Ok(());
3143 }
3144
3145 let cur_offset: usize = (9 - 1) * envelope_size;
3148
3149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3151
3152 fidl::encoding::encode_in_envelope_optional::<
3157 fidl::encoding::Endpoint<
3158 fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3159 >,
3160 fidl::encoding::DefaultFuchsiaResourceDialect,
3161 >(
3162 self.focuser.as_mut().map(
3163 <fidl::encoding::Endpoint<
3164 fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3165 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3166 ),
3167 encoder,
3168 offset + cur_offset,
3169 depth,
3170 )?;
3171
3172 _prev_end_offset = cur_offset + envelope_size;
3173
3174 Ok(())
3175 }
3176 }
3177
3178 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
3179 for PuppetCreationArgs
3180 {
3181 #[inline(always)]
3182 fn new_empty() -> Self {
3183 Self::default()
3184 }
3185
3186 unsafe fn decode(
3187 &mut self,
3188 decoder: &mut fidl::encoding::Decoder<
3189 '_,
3190 fidl::encoding::DefaultFuchsiaResourceDialect,
3191 >,
3192 offset: usize,
3193 mut depth: fidl::encoding::Depth,
3194 ) -> fidl::Result<()> {
3195 decoder.debug_check_bounds::<Self>(offset);
3196 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3197 None => return Err(fidl::Error::NotNullable),
3198 Some(len) => len,
3199 };
3200 if len == 0 {
3202 return Ok(());
3203 };
3204 depth.increment()?;
3205 let envelope_size = 8;
3206 let bytes_len = len * envelope_size;
3207 let offset = decoder.out_of_line_offset(bytes_len)?;
3208 let mut _next_ordinal_to_read = 0;
3210 let mut next_offset = offset;
3211 let end_offset = offset + bytes_len;
3212 _next_ordinal_to_read += 1;
3213 if next_offset >= end_offset {
3214 return Ok(());
3215 }
3216
3217 while _next_ordinal_to_read < 1 {
3219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3220 _next_ordinal_to_read += 1;
3221 next_offset += envelope_size;
3222 }
3223
3224 let next_out_of_line = decoder.next_out_of_line();
3225 let handles_before = decoder.remaining_handles();
3226 if let Some((inlined, num_bytes, num_handles)) =
3227 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3228 {
3229 let member_inline_size = <fidl::encoding::Endpoint<
3230 fidl::endpoints::ServerEnd<PuppetMarker>,
3231 > as fidl::encoding::TypeMarker>::inline_size(
3232 decoder.context
3233 );
3234 if inlined != (member_inline_size <= 4) {
3235 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3236 }
3237 let inner_offset;
3238 let mut inner_depth = depth.clone();
3239 if inlined {
3240 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3241 inner_offset = next_offset;
3242 } else {
3243 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3244 inner_depth.increment()?;
3245 }
3246 let val_ref = self.server_end.get_or_insert_with(|| {
3247 fidl::new_empty!(
3248 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>,
3249 fidl::encoding::DefaultFuchsiaResourceDialect
3250 )
3251 });
3252 fidl::decode!(
3253 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>,
3254 fidl::encoding::DefaultFuchsiaResourceDialect,
3255 val_ref,
3256 decoder,
3257 inner_offset,
3258 inner_depth
3259 )?;
3260 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3261 {
3262 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3263 }
3264 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3265 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3266 }
3267 }
3268
3269 next_offset += envelope_size;
3270 _next_ordinal_to_read += 1;
3271 if next_offset >= end_offset {
3272 return Ok(());
3273 }
3274
3275 while _next_ordinal_to_read < 2 {
3277 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3278 _next_ordinal_to_read += 1;
3279 next_offset += envelope_size;
3280 }
3281
3282 let next_out_of_line = decoder.next_out_of_line();
3283 let handles_before = decoder.remaining_handles();
3284 if let Some((inlined, num_bytes, num_handles)) =
3285 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3286 {
3287 let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3288 if inlined != (member_inline_size <= 4) {
3289 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3290 }
3291 let inner_offset;
3292 let mut inner_depth = depth.clone();
3293 if inlined {
3294 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3295 inner_offset = next_offset;
3296 } else {
3297 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3298 inner_depth.increment()?;
3299 }
3300 let val_ref = self.view_token.get_or_insert_with(|| {
3301 fidl::new_empty!(
3302 fidl_fuchsia_ui_views::ViewCreationToken,
3303 fidl::encoding::DefaultFuchsiaResourceDialect
3304 )
3305 });
3306 fidl::decode!(
3307 fidl_fuchsia_ui_views::ViewCreationToken,
3308 fidl::encoding::DefaultFuchsiaResourceDialect,
3309 val_ref,
3310 decoder,
3311 inner_offset,
3312 inner_depth
3313 )?;
3314 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3315 {
3316 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3317 }
3318 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3319 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3320 }
3321 }
3322
3323 next_offset += envelope_size;
3324 _next_ordinal_to_read += 1;
3325 if next_offset >= end_offset {
3326 return Ok(());
3327 }
3328
3329 while _next_ordinal_to_read < 3 {
3331 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3332 _next_ordinal_to_read += 1;
3333 next_offset += envelope_size;
3334 }
3335
3336 let next_out_of_line = decoder.next_out_of_line();
3337 let handles_before = decoder.remaining_handles();
3338 if let Some((inlined, num_bytes, num_handles)) =
3339 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3340 {
3341 let member_inline_size = <fidl::encoding::Endpoint<
3342 fidl::endpoints::ClientEnd<
3343 fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3344 >,
3345 > as fidl::encoding::TypeMarker>::inline_size(
3346 decoder.context
3347 );
3348 if inlined != (member_inline_size <= 4) {
3349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3350 }
3351 let inner_offset;
3352 let mut inner_depth = depth.clone();
3353 if inlined {
3354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3355 inner_offset = next_offset;
3356 } else {
3357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3358 inner_depth.increment()?;
3359 }
3360 let val_ref = self.touch_listener.get_or_insert_with(|| {
3361 fidl::new_empty!(
3362 fidl::encoding::Endpoint<
3363 fidl::endpoints::ClientEnd<
3364 fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3365 >,
3366 >,
3367 fidl::encoding::DefaultFuchsiaResourceDialect
3368 )
3369 });
3370 fidl::decode!(
3371 fidl::encoding::Endpoint<
3372 fidl::endpoints::ClientEnd<
3373 fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3374 >,
3375 >,
3376 fidl::encoding::DefaultFuchsiaResourceDialect,
3377 val_ref,
3378 decoder,
3379 inner_offset,
3380 inner_depth
3381 )?;
3382 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3383 {
3384 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3385 }
3386 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3387 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3388 }
3389 }
3390
3391 next_offset += envelope_size;
3392 _next_ordinal_to_read += 1;
3393 if next_offset >= end_offset {
3394 return Ok(());
3395 }
3396
3397 while _next_ordinal_to_read < 4 {
3399 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3400 _next_ordinal_to_read += 1;
3401 next_offset += envelope_size;
3402 }
3403
3404 let next_out_of_line = decoder.next_out_of_line();
3405 let handles_before = decoder.remaining_handles();
3406 if let Some((inlined, num_bytes, num_handles)) =
3407 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3408 {
3409 let member_inline_size = <fidl::encoding::Endpoint<
3410 fidl::endpoints::ClientEnd<
3411 fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3412 >,
3413 > as fidl::encoding::TypeMarker>::inline_size(
3414 decoder.context
3415 );
3416 if inlined != (member_inline_size <= 4) {
3417 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3418 }
3419 let inner_offset;
3420 let mut inner_depth = depth.clone();
3421 if inlined {
3422 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3423 inner_offset = next_offset;
3424 } else {
3425 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3426 inner_depth.increment()?;
3427 }
3428 let val_ref = self.mouse_listener.get_or_insert_with(|| {
3429 fidl::new_empty!(
3430 fidl::encoding::Endpoint<
3431 fidl::endpoints::ClientEnd<
3432 fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3433 >,
3434 >,
3435 fidl::encoding::DefaultFuchsiaResourceDialect
3436 )
3437 });
3438 fidl::decode!(
3439 fidl::encoding::Endpoint<
3440 fidl::endpoints::ClientEnd<
3441 fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3442 >,
3443 >,
3444 fidl::encoding::DefaultFuchsiaResourceDialect,
3445 val_ref,
3446 decoder,
3447 inner_offset,
3448 inner_depth
3449 )?;
3450 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3451 {
3452 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3453 }
3454 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3455 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3456 }
3457 }
3458
3459 next_offset += envelope_size;
3460 _next_ordinal_to_read += 1;
3461 if next_offset >= end_offset {
3462 return Ok(());
3463 }
3464
3465 while _next_ordinal_to_read < 5 {
3467 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3468 _next_ordinal_to_read += 1;
3469 next_offset += envelope_size;
3470 }
3471
3472 let next_out_of_line = decoder.next_out_of_line();
3473 let handles_before = decoder.remaining_handles();
3474 if let Some((inlined, num_bytes, num_handles)) =
3475 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3476 {
3477 let member_inline_size = <fidl::encoding::Endpoint<
3478 fidl::endpoints::ClientEnd<
3479 fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3480 >,
3481 > as fidl::encoding::TypeMarker>::inline_size(
3482 decoder.context
3483 );
3484 if inlined != (member_inline_size <= 4) {
3485 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3486 }
3487 let inner_offset;
3488 let mut inner_depth = depth.clone();
3489 if inlined {
3490 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3491 inner_offset = next_offset;
3492 } else {
3493 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3494 inner_depth.increment()?;
3495 }
3496 let val_ref = self.keyboard_listener.get_or_insert_with(|| {
3497 fidl::new_empty!(
3498 fidl::encoding::Endpoint<
3499 fidl::endpoints::ClientEnd<
3500 fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3501 >,
3502 >,
3503 fidl::encoding::DefaultFuchsiaResourceDialect
3504 )
3505 });
3506 fidl::decode!(
3507 fidl::encoding::Endpoint<
3508 fidl::endpoints::ClientEnd<
3509 fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3510 >,
3511 >,
3512 fidl::encoding::DefaultFuchsiaResourceDialect,
3513 val_ref,
3514 decoder,
3515 inner_offset,
3516 inner_depth
3517 )?;
3518 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3519 {
3520 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3521 }
3522 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3523 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3524 }
3525 }
3526
3527 next_offset += envelope_size;
3528 _next_ordinal_to_read += 1;
3529 if next_offset >= end_offset {
3530 return Ok(());
3531 }
3532
3533 while _next_ordinal_to_read < 6 {
3535 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3536 _next_ordinal_to_read += 1;
3537 next_offset += envelope_size;
3538 }
3539
3540 let next_out_of_line = decoder.next_out_of_line();
3541 let handles_before = decoder.remaining_handles();
3542 if let Some((inlined, num_bytes, num_handles)) =
3543 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3544 {
3545 let member_inline_size = <fidl::encoding::Endpoint<
3546 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3547 > as fidl::encoding::TypeMarker>::inline_size(
3548 decoder.context
3549 );
3550 if inlined != (member_inline_size <= 4) {
3551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3552 }
3553 let inner_offset;
3554 let mut inner_depth = depth.clone();
3555 if inlined {
3556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3557 inner_offset = next_offset;
3558 } else {
3559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3560 inner_depth.increment()?;
3561 }
3562 let val_ref = self.flatland_client.get_or_insert_with(|| {
3563 fidl::new_empty!(
3564 fidl::encoding::Endpoint<
3565 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3566 >,
3567 fidl::encoding::DefaultFuchsiaResourceDialect
3568 )
3569 });
3570 fidl::decode!(
3571 fidl::encoding::Endpoint<
3572 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3573 >,
3574 fidl::encoding::DefaultFuchsiaResourceDialect,
3575 val_ref,
3576 decoder,
3577 inner_offset,
3578 inner_depth
3579 )?;
3580 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3581 {
3582 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3583 }
3584 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3585 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3586 }
3587 }
3588
3589 next_offset += envelope_size;
3590 _next_ordinal_to_read += 1;
3591 if next_offset >= end_offset {
3592 return Ok(());
3593 }
3594
3595 while _next_ordinal_to_read < 7 {
3597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3598 _next_ordinal_to_read += 1;
3599 next_offset += envelope_size;
3600 }
3601
3602 let next_out_of_line = decoder.next_out_of_line();
3603 let handles_before = decoder.remaining_handles();
3604 if let Some((inlined, num_bytes, num_handles)) =
3605 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3606 {
3607 let member_inline_size = <fidl::encoding::Endpoint<
3608 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3609 > as fidl::encoding::TypeMarker>::inline_size(
3610 decoder.context
3611 );
3612 if inlined != (member_inline_size <= 4) {
3613 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3614 }
3615 let inner_offset;
3616 let mut inner_depth = depth.clone();
3617 if inlined {
3618 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3619 inner_offset = next_offset;
3620 } else {
3621 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3622 inner_depth.increment()?;
3623 }
3624 let val_ref = self.keyboard_client.get_or_insert_with(|| {
3625 fidl::new_empty!(
3626 fidl::encoding::Endpoint<
3627 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3628 >,
3629 fidl::encoding::DefaultFuchsiaResourceDialect
3630 )
3631 });
3632 fidl::decode!(
3633 fidl::encoding::Endpoint<
3634 fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3635 >,
3636 fidl::encoding::DefaultFuchsiaResourceDialect,
3637 val_ref,
3638 decoder,
3639 inner_offset,
3640 inner_depth
3641 )?;
3642 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3643 {
3644 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3645 }
3646 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3647 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3648 }
3649 }
3650
3651 next_offset += envelope_size;
3652 _next_ordinal_to_read += 1;
3653 if next_offset >= end_offset {
3654 return Ok(());
3655 }
3656
3657 while _next_ordinal_to_read < 8 {
3659 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3660 _next_ordinal_to_read += 1;
3661 next_offset += envelope_size;
3662 }
3663
3664 let next_out_of_line = decoder.next_out_of_line();
3665 let handles_before = decoder.remaining_handles();
3666 if let Some((inlined, num_bytes, num_handles)) =
3667 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3668 {
3669 let member_inline_size =
3670 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3671 if inlined != (member_inline_size <= 4) {
3672 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3673 }
3674 let inner_offset;
3675 let mut inner_depth = depth.clone();
3676 if inlined {
3677 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3678 inner_offset = next_offset;
3679 } else {
3680 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3681 inner_depth.increment()?;
3682 }
3683 let val_ref = self.device_pixel_ratio.get_or_insert_with(|| {
3684 fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
3685 });
3686 fidl::decode!(
3687 f32,
3688 fidl::encoding::DefaultFuchsiaResourceDialect,
3689 val_ref,
3690 decoder,
3691 inner_offset,
3692 inner_depth
3693 )?;
3694 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3695 {
3696 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3697 }
3698 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3699 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3700 }
3701 }
3702
3703 next_offset += envelope_size;
3704 _next_ordinal_to_read += 1;
3705 if next_offset >= end_offset {
3706 return Ok(());
3707 }
3708
3709 while _next_ordinal_to_read < 9 {
3711 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3712 _next_ordinal_to_read += 1;
3713 next_offset += envelope_size;
3714 }
3715
3716 let next_out_of_line = decoder.next_out_of_line();
3717 let handles_before = decoder.remaining_handles();
3718 if let Some((inlined, num_bytes, num_handles)) =
3719 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3720 {
3721 let member_inline_size = <fidl::encoding::Endpoint<
3722 fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3723 > as fidl::encoding::TypeMarker>::inline_size(
3724 decoder.context
3725 );
3726 if inlined != (member_inline_size <= 4) {
3727 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3728 }
3729 let inner_offset;
3730 let mut inner_depth = depth.clone();
3731 if inlined {
3732 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3733 inner_offset = next_offset;
3734 } else {
3735 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3736 inner_depth.increment()?;
3737 }
3738 let val_ref = self.focuser.get_or_insert_with(|| {
3739 fidl::new_empty!(
3740 fidl::encoding::Endpoint<
3741 fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3742 >,
3743 fidl::encoding::DefaultFuchsiaResourceDialect
3744 )
3745 });
3746 fidl::decode!(
3747 fidl::encoding::Endpoint<
3748 fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3749 >,
3750 fidl::encoding::DefaultFuchsiaResourceDialect,
3751 val_ref,
3752 decoder,
3753 inner_offset,
3754 inner_depth
3755 )?;
3756 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3757 {
3758 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3759 }
3760 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3761 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3762 }
3763 }
3764
3765 next_offset += envelope_size;
3766
3767 while next_offset < end_offset {
3769 _next_ordinal_to_read += 1;
3770 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3771 next_offset += envelope_size;
3772 }
3773
3774 Ok(())
3775 }
3776 }
3777
3778 impl PuppetDrawImageRequest {
3779 #[inline(always)]
3780 fn max_ordinal_present(&self) -> u64 {
3781 if let Some(_) = self.properties {
3782 return 2;
3783 }
3784 if let Some(_) = self.id {
3785 return 1;
3786 }
3787 0
3788 }
3789 }
3790
3791 impl fidl::encoding::ValueTypeMarker for PuppetDrawImageRequest {
3792 type Borrowed<'a> = &'a Self;
3793 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3794 value
3795 }
3796 }
3797
3798 unsafe impl fidl::encoding::TypeMarker for PuppetDrawImageRequest {
3799 type Owned = Self;
3800
3801 #[inline(always)]
3802 fn inline_align(_context: fidl::encoding::Context) -> usize {
3803 8
3804 }
3805
3806 #[inline(always)]
3807 fn inline_size(_context: fidl::encoding::Context) -> usize {
3808 16
3809 }
3810 }
3811
3812 unsafe impl<D: fidl::encoding::ResourceDialect>
3813 fidl::encoding::Encode<PuppetDrawImageRequest, D> for &PuppetDrawImageRequest
3814 {
3815 unsafe fn encode(
3816 self,
3817 encoder: &mut fidl::encoding::Encoder<'_, D>,
3818 offset: usize,
3819 mut depth: fidl::encoding::Depth,
3820 ) -> fidl::Result<()> {
3821 encoder.debug_check_bounds::<PuppetDrawImageRequest>(offset);
3822 let max_ordinal: u64 = self.max_ordinal_present();
3824 encoder.write_num(max_ordinal, offset);
3825 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3826 if max_ordinal == 0 {
3828 return Ok(());
3829 }
3830 depth.increment()?;
3831 let envelope_size = 8;
3832 let bytes_len = max_ordinal as usize * envelope_size;
3833 #[allow(unused_variables)]
3834 let offset = encoder.out_of_line_offset(bytes_len);
3835 let mut _prev_end_offset: usize = 0;
3836 if 1 > max_ordinal {
3837 return Ok(());
3838 }
3839
3840 let cur_offset: usize = (1 - 1) * envelope_size;
3843
3844 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3846
3847 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3852 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3853 encoder,
3854 offset + cur_offset,
3855 depth,
3856 )?;
3857
3858 _prev_end_offset = cur_offset + envelope_size;
3859 if 2 > max_ordinal {
3860 return Ok(());
3861 }
3862
3863 let cur_offset: usize = (2 - 1) * envelope_size;
3866
3867 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3869
3870 fidl::encoding::encode_in_envelope_optional::<ImageProperties, D>(
3875 self.properties
3876 .as_ref()
3877 .map(<ImageProperties as fidl::encoding::ValueTypeMarker>::borrow),
3878 encoder,
3879 offset + cur_offset,
3880 depth,
3881 )?;
3882
3883 _prev_end_offset = cur_offset + envelope_size;
3884
3885 Ok(())
3886 }
3887 }
3888
3889 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3890 for PuppetDrawImageRequest
3891 {
3892 #[inline(always)]
3893 fn new_empty() -> Self {
3894 Self::default()
3895 }
3896
3897 unsafe fn decode(
3898 &mut self,
3899 decoder: &mut fidl::encoding::Decoder<'_, D>,
3900 offset: usize,
3901 mut depth: fidl::encoding::Depth,
3902 ) -> fidl::Result<()> {
3903 decoder.debug_check_bounds::<Self>(offset);
3904 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3905 None => return Err(fidl::Error::NotNullable),
3906 Some(len) => len,
3907 };
3908 if len == 0 {
3910 return Ok(());
3911 };
3912 depth.increment()?;
3913 let envelope_size = 8;
3914 let bytes_len = len * envelope_size;
3915 let offset = decoder.out_of_line_offset(bytes_len)?;
3916 let mut _next_ordinal_to_read = 0;
3918 let mut next_offset = offset;
3919 let end_offset = offset + bytes_len;
3920 _next_ordinal_to_read += 1;
3921 if next_offset >= end_offset {
3922 return Ok(());
3923 }
3924
3925 while _next_ordinal_to_read < 1 {
3927 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3928 _next_ordinal_to_read += 1;
3929 next_offset += envelope_size;
3930 }
3931
3932 let next_out_of_line = decoder.next_out_of_line();
3933 let handles_before = decoder.remaining_handles();
3934 if let Some((inlined, num_bytes, num_handles)) =
3935 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3936 {
3937 let member_inline_size =
3938 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3939 if inlined != (member_inline_size <= 4) {
3940 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3941 }
3942 let inner_offset;
3943 let mut inner_depth = depth.clone();
3944 if inlined {
3945 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3946 inner_offset = next_offset;
3947 } else {
3948 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3949 inner_depth.increment()?;
3950 }
3951 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3952 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3953 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3954 {
3955 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3956 }
3957 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3958 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3959 }
3960 }
3961
3962 next_offset += envelope_size;
3963 _next_ordinal_to_read += 1;
3964 if next_offset >= end_offset {
3965 return Ok(());
3966 }
3967
3968 while _next_ordinal_to_read < 2 {
3970 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3971 _next_ordinal_to_read += 1;
3972 next_offset += envelope_size;
3973 }
3974
3975 let next_out_of_line = decoder.next_out_of_line();
3976 let handles_before = decoder.remaining_handles();
3977 if let Some((inlined, num_bytes, num_handles)) =
3978 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3979 {
3980 let member_inline_size =
3981 <ImageProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3982 if inlined != (member_inline_size <= 4) {
3983 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3984 }
3985 let inner_offset;
3986 let mut inner_depth = depth.clone();
3987 if inlined {
3988 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3989 inner_offset = next_offset;
3990 } else {
3991 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3992 inner_depth.increment()?;
3993 }
3994 let val_ref =
3995 self.properties.get_or_insert_with(|| fidl::new_empty!(ImageProperties, D));
3996 fidl::decode!(ImageProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3997 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3998 {
3999 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4000 }
4001 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4002 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4003 }
4004 }
4005
4006 next_offset += envelope_size;
4007
4008 while next_offset < end_offset {
4010 _next_ordinal_to_read += 1;
4011 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4012 next_offset += envelope_size;
4013 }
4014
4015 Ok(())
4016 }
4017 }
4018
4019 impl PuppetDrawImageResponse {
4020 #[inline(always)]
4021 fn max_ordinal_present(&self) -> u64 {
4022 if let Some(_) = self.result {
4023 return 1;
4024 }
4025 0
4026 }
4027 }
4028
4029 impl fidl::encoding::ValueTypeMarker for PuppetDrawImageResponse {
4030 type Borrowed<'a> = &'a Self;
4031 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4032 value
4033 }
4034 }
4035
4036 unsafe impl fidl::encoding::TypeMarker for PuppetDrawImageResponse {
4037 type Owned = Self;
4038
4039 #[inline(always)]
4040 fn inline_align(_context: fidl::encoding::Context) -> usize {
4041 8
4042 }
4043
4044 #[inline(always)]
4045 fn inline_size(_context: fidl::encoding::Context) -> usize {
4046 16
4047 }
4048 }
4049
4050 unsafe impl<D: fidl::encoding::ResourceDialect>
4051 fidl::encoding::Encode<PuppetDrawImageResponse, D> for &PuppetDrawImageResponse
4052 {
4053 unsafe fn encode(
4054 self,
4055 encoder: &mut fidl::encoding::Encoder<'_, D>,
4056 offset: usize,
4057 mut depth: fidl::encoding::Depth,
4058 ) -> fidl::Result<()> {
4059 encoder.debug_check_bounds::<PuppetDrawImageResponse>(offset);
4060 let max_ordinal: u64 = self.max_ordinal_present();
4062 encoder.write_num(max_ordinal, offset);
4063 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4064 if max_ordinal == 0 {
4066 return Ok(());
4067 }
4068 depth.increment()?;
4069 let envelope_size = 8;
4070 let bytes_len = max_ordinal as usize * envelope_size;
4071 #[allow(unused_variables)]
4072 let offset = encoder.out_of_line_offset(bytes_len);
4073 let mut _prev_end_offset: usize = 0;
4074 if 1 > max_ordinal {
4075 return Ok(());
4076 }
4077
4078 let cur_offset: usize = (1 - 1) * envelope_size;
4081
4082 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4084
4085 fidl::encoding::encode_in_envelope_optional::<Result_, D>(
4090 self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4091 encoder,
4092 offset + cur_offset,
4093 depth,
4094 )?;
4095
4096 _prev_end_offset = cur_offset + envelope_size;
4097
4098 Ok(())
4099 }
4100 }
4101
4102 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4103 for PuppetDrawImageResponse
4104 {
4105 #[inline(always)]
4106 fn new_empty() -> Self {
4107 Self::default()
4108 }
4109
4110 unsafe fn decode(
4111 &mut self,
4112 decoder: &mut fidl::encoding::Decoder<'_, D>,
4113 offset: usize,
4114 mut depth: fidl::encoding::Depth,
4115 ) -> fidl::Result<()> {
4116 decoder.debug_check_bounds::<Self>(offset);
4117 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4118 None => return Err(fidl::Error::NotNullable),
4119 Some(len) => len,
4120 };
4121 if len == 0 {
4123 return Ok(());
4124 };
4125 depth.increment()?;
4126 let envelope_size = 8;
4127 let bytes_len = len * envelope_size;
4128 let offset = decoder.out_of_line_offset(bytes_len)?;
4129 let mut _next_ordinal_to_read = 0;
4131 let mut next_offset = offset;
4132 let end_offset = offset + bytes_len;
4133 _next_ordinal_to_read += 1;
4134 if next_offset >= end_offset {
4135 return Ok(());
4136 }
4137
4138 while _next_ordinal_to_read < 1 {
4140 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4141 _next_ordinal_to_read += 1;
4142 next_offset += envelope_size;
4143 }
4144
4145 let next_out_of_line = decoder.next_out_of_line();
4146 let handles_before = decoder.remaining_handles();
4147 if let Some((inlined, num_bytes, num_handles)) =
4148 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4149 {
4150 let member_inline_size =
4151 <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4152 if inlined != (member_inline_size <= 4) {
4153 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4154 }
4155 let inner_offset;
4156 let mut inner_depth = depth.clone();
4157 if inlined {
4158 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4159 inner_offset = next_offset;
4160 } else {
4161 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4162 inner_depth.increment()?;
4163 }
4164 let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
4165 fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
4166 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4167 {
4168 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4169 }
4170 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4171 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4172 }
4173 }
4174
4175 next_offset += envelope_size;
4176
4177 while next_offset < end_offset {
4179 _next_ordinal_to_read += 1;
4180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4181 next_offset += envelope_size;
4182 }
4183
4184 Ok(())
4185 }
4186 }
4187
4188 impl PuppetEmbedRemoteViewRequest {
4189 #[inline(always)]
4190 fn max_ordinal_present(&self) -> u64 {
4191 if let Some(_) = self.properties {
4192 return 2;
4193 }
4194 if let Some(_) = self.id {
4195 return 1;
4196 }
4197 0
4198 }
4199 }
4200
4201 impl fidl::encoding::ValueTypeMarker for PuppetEmbedRemoteViewRequest {
4202 type Borrowed<'a> = &'a Self;
4203 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4204 value
4205 }
4206 }
4207
4208 unsafe impl fidl::encoding::TypeMarker for PuppetEmbedRemoteViewRequest {
4209 type Owned = Self;
4210
4211 #[inline(always)]
4212 fn inline_align(_context: fidl::encoding::Context) -> usize {
4213 8
4214 }
4215
4216 #[inline(always)]
4217 fn inline_size(_context: fidl::encoding::Context) -> usize {
4218 16
4219 }
4220 }
4221
4222 unsafe impl<D: fidl::encoding::ResourceDialect>
4223 fidl::encoding::Encode<PuppetEmbedRemoteViewRequest, D> for &PuppetEmbedRemoteViewRequest
4224 {
4225 unsafe fn encode(
4226 self,
4227 encoder: &mut fidl::encoding::Encoder<'_, D>,
4228 offset: usize,
4229 mut depth: fidl::encoding::Depth,
4230 ) -> fidl::Result<()> {
4231 encoder.debug_check_bounds::<PuppetEmbedRemoteViewRequest>(offset);
4232 let max_ordinal: u64 = self.max_ordinal_present();
4234 encoder.write_num(max_ordinal, offset);
4235 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4236 if max_ordinal == 0 {
4238 return Ok(());
4239 }
4240 depth.increment()?;
4241 let envelope_size = 8;
4242 let bytes_len = max_ordinal as usize * envelope_size;
4243 #[allow(unused_variables)]
4244 let offset = encoder.out_of_line_offset(bytes_len);
4245 let mut _prev_end_offset: usize = 0;
4246 if 1 > max_ordinal {
4247 return Ok(());
4248 }
4249
4250 let cur_offset: usize = (1 - 1) * envelope_size;
4253
4254 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4256
4257 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4262 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4263 encoder,
4264 offset + cur_offset,
4265 depth,
4266 )?;
4267
4268 _prev_end_offset = cur_offset + envelope_size;
4269 if 2 > max_ordinal {
4270 return Ok(());
4271 }
4272
4273 let cur_offset: usize = (2 - 1) * envelope_size;
4276
4277 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4279
4280 fidl::encoding::encode_in_envelope_optional::<EmbeddedViewProperties, D>(
4285 self.properties
4286 .as_ref()
4287 .map(<EmbeddedViewProperties as fidl::encoding::ValueTypeMarker>::borrow),
4288 encoder,
4289 offset + cur_offset,
4290 depth,
4291 )?;
4292
4293 _prev_end_offset = cur_offset + envelope_size;
4294
4295 Ok(())
4296 }
4297 }
4298
4299 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4300 for PuppetEmbedRemoteViewRequest
4301 {
4302 #[inline(always)]
4303 fn new_empty() -> Self {
4304 Self::default()
4305 }
4306
4307 unsafe fn decode(
4308 &mut self,
4309 decoder: &mut fidl::encoding::Decoder<'_, D>,
4310 offset: usize,
4311 mut depth: fidl::encoding::Depth,
4312 ) -> fidl::Result<()> {
4313 decoder.debug_check_bounds::<Self>(offset);
4314 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4315 None => return Err(fidl::Error::NotNullable),
4316 Some(len) => len,
4317 };
4318 if len == 0 {
4320 return Ok(());
4321 };
4322 depth.increment()?;
4323 let envelope_size = 8;
4324 let bytes_len = len * envelope_size;
4325 let offset = decoder.out_of_line_offset(bytes_len)?;
4326 let mut _next_ordinal_to_read = 0;
4328 let mut next_offset = offset;
4329 let end_offset = offset + bytes_len;
4330 _next_ordinal_to_read += 1;
4331 if next_offset >= end_offset {
4332 return Ok(());
4333 }
4334
4335 while _next_ordinal_to_read < 1 {
4337 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4338 _next_ordinal_to_read += 1;
4339 next_offset += envelope_size;
4340 }
4341
4342 let next_out_of_line = decoder.next_out_of_line();
4343 let handles_before = decoder.remaining_handles();
4344 if let Some((inlined, num_bytes, num_handles)) =
4345 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4346 {
4347 let member_inline_size =
4348 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4349 if inlined != (member_inline_size <= 4) {
4350 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4351 }
4352 let inner_offset;
4353 let mut inner_depth = depth.clone();
4354 if inlined {
4355 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4356 inner_offset = next_offset;
4357 } else {
4358 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4359 inner_depth.increment()?;
4360 }
4361 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4362 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4363 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4364 {
4365 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4366 }
4367 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4368 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4369 }
4370 }
4371
4372 next_offset += envelope_size;
4373 _next_ordinal_to_read += 1;
4374 if next_offset >= end_offset {
4375 return Ok(());
4376 }
4377
4378 while _next_ordinal_to_read < 2 {
4380 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4381 _next_ordinal_to_read += 1;
4382 next_offset += envelope_size;
4383 }
4384
4385 let next_out_of_line = decoder.next_out_of_line();
4386 let handles_before = decoder.remaining_handles();
4387 if let Some((inlined, num_bytes, num_handles)) =
4388 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4389 {
4390 let member_inline_size =
4391 <EmbeddedViewProperties as fidl::encoding::TypeMarker>::inline_size(
4392 decoder.context,
4393 );
4394 if inlined != (member_inline_size <= 4) {
4395 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4396 }
4397 let inner_offset;
4398 let mut inner_depth = depth.clone();
4399 if inlined {
4400 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4401 inner_offset = next_offset;
4402 } else {
4403 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4404 inner_depth.increment()?;
4405 }
4406 let val_ref = self
4407 .properties
4408 .get_or_insert_with(|| fidl::new_empty!(EmbeddedViewProperties, D));
4409 fidl::decode!(
4410 EmbeddedViewProperties,
4411 D,
4412 val_ref,
4413 decoder,
4414 inner_offset,
4415 inner_depth
4416 )?;
4417 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4418 {
4419 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4420 }
4421 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4422 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4423 }
4424 }
4425
4426 next_offset += envelope_size;
4427
4428 while next_offset < end_offset {
4430 _next_ordinal_to_read += 1;
4431 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4432 next_offset += envelope_size;
4433 }
4434
4435 Ok(())
4436 }
4437 }
4438
4439 impl PuppetEmbedRemoteViewResponse {
4440 #[inline(always)]
4441 fn max_ordinal_present(&self) -> u64 {
4442 if let Some(_) = self.view_creation_token {
4443 return 2;
4444 }
4445 if let Some(_) = self.result {
4446 return 1;
4447 }
4448 0
4449 }
4450 }
4451
4452 impl fidl::encoding::ResourceTypeMarker for PuppetEmbedRemoteViewResponse {
4453 type Borrowed<'a> = &'a mut Self;
4454 fn take_or_borrow<'a>(
4455 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4456 ) -> Self::Borrowed<'a> {
4457 value
4458 }
4459 }
4460
4461 unsafe impl fidl::encoding::TypeMarker for PuppetEmbedRemoteViewResponse {
4462 type Owned = Self;
4463
4464 #[inline(always)]
4465 fn inline_align(_context: fidl::encoding::Context) -> usize {
4466 8
4467 }
4468
4469 #[inline(always)]
4470 fn inline_size(_context: fidl::encoding::Context) -> usize {
4471 16
4472 }
4473 }
4474
4475 unsafe impl
4476 fidl::encoding::Encode<
4477 PuppetEmbedRemoteViewResponse,
4478 fidl::encoding::DefaultFuchsiaResourceDialect,
4479 > for &mut PuppetEmbedRemoteViewResponse
4480 {
4481 unsafe fn encode(
4482 self,
4483 encoder: &mut fidl::encoding::Encoder<
4484 '_,
4485 fidl::encoding::DefaultFuchsiaResourceDialect,
4486 >,
4487 offset: usize,
4488 mut depth: fidl::encoding::Depth,
4489 ) -> fidl::Result<()> {
4490 encoder.debug_check_bounds::<PuppetEmbedRemoteViewResponse>(offset);
4491 let max_ordinal: u64 = self.max_ordinal_present();
4493 encoder.write_num(max_ordinal, offset);
4494 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4495 if max_ordinal == 0 {
4497 return Ok(());
4498 }
4499 depth.increment()?;
4500 let envelope_size = 8;
4501 let bytes_len = max_ordinal as usize * envelope_size;
4502 #[allow(unused_variables)]
4503 let offset = encoder.out_of_line_offset(bytes_len);
4504 let mut _prev_end_offset: usize = 0;
4505 if 1 > max_ordinal {
4506 return Ok(());
4507 }
4508
4509 let cur_offset: usize = (1 - 1) * envelope_size;
4512
4513 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4515
4516 fidl::encoding::encode_in_envelope_optional::<
4521 Result_,
4522 fidl::encoding::DefaultFuchsiaResourceDialect,
4523 >(
4524 self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4525 encoder,
4526 offset + cur_offset,
4527 depth,
4528 )?;
4529
4530 _prev_end_offset = cur_offset + envelope_size;
4531 if 2 > max_ordinal {
4532 return Ok(());
4533 }
4534
4535 let cur_offset: usize = (2 - 1) * envelope_size;
4538
4539 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4541
4542 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
4547 self.view_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4548 encoder, offset + cur_offset, depth
4549 )?;
4550
4551 _prev_end_offset = cur_offset + envelope_size;
4552
4553 Ok(())
4554 }
4555 }
4556
4557 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4558 for PuppetEmbedRemoteViewResponse
4559 {
4560 #[inline(always)]
4561 fn new_empty() -> Self {
4562 Self::default()
4563 }
4564
4565 unsafe fn decode(
4566 &mut self,
4567 decoder: &mut fidl::encoding::Decoder<
4568 '_,
4569 fidl::encoding::DefaultFuchsiaResourceDialect,
4570 >,
4571 offset: usize,
4572 mut depth: fidl::encoding::Depth,
4573 ) -> fidl::Result<()> {
4574 decoder.debug_check_bounds::<Self>(offset);
4575 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4576 None => return Err(fidl::Error::NotNullable),
4577 Some(len) => len,
4578 };
4579 if len == 0 {
4581 return Ok(());
4582 };
4583 depth.increment()?;
4584 let envelope_size = 8;
4585 let bytes_len = len * envelope_size;
4586 let offset = decoder.out_of_line_offset(bytes_len)?;
4587 let mut _next_ordinal_to_read = 0;
4589 let mut next_offset = offset;
4590 let end_offset = offset + bytes_len;
4591 _next_ordinal_to_read += 1;
4592 if next_offset >= end_offset {
4593 return Ok(());
4594 }
4595
4596 while _next_ordinal_to_read < 1 {
4598 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4599 _next_ordinal_to_read += 1;
4600 next_offset += envelope_size;
4601 }
4602
4603 let next_out_of_line = decoder.next_out_of_line();
4604 let handles_before = decoder.remaining_handles();
4605 if let Some((inlined, num_bytes, num_handles)) =
4606 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4607 {
4608 let member_inline_size =
4609 <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4610 if inlined != (member_inline_size <= 4) {
4611 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4612 }
4613 let inner_offset;
4614 let mut inner_depth = depth.clone();
4615 if inlined {
4616 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4617 inner_offset = next_offset;
4618 } else {
4619 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4620 inner_depth.increment()?;
4621 }
4622 let val_ref = self.result.get_or_insert_with(|| {
4623 fidl::new_empty!(Result_, fidl::encoding::DefaultFuchsiaResourceDialect)
4624 });
4625 fidl::decode!(
4626 Result_,
4627 fidl::encoding::DefaultFuchsiaResourceDialect,
4628 val_ref,
4629 decoder,
4630 inner_offset,
4631 inner_depth
4632 )?;
4633 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4634 {
4635 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4636 }
4637 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4638 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4639 }
4640 }
4641
4642 next_offset += envelope_size;
4643 _next_ordinal_to_read += 1;
4644 if next_offset >= end_offset {
4645 return Ok(());
4646 }
4647
4648 while _next_ordinal_to_read < 2 {
4650 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4651 _next_ordinal_to_read += 1;
4652 next_offset += envelope_size;
4653 }
4654
4655 let next_out_of_line = decoder.next_out_of_line();
4656 let handles_before = decoder.remaining_handles();
4657 if let Some((inlined, num_bytes, num_handles)) =
4658 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4659 {
4660 let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4661 if inlined != (member_inline_size <= 4) {
4662 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4663 }
4664 let inner_offset;
4665 let mut inner_depth = depth.clone();
4666 if inlined {
4667 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4668 inner_offset = next_offset;
4669 } else {
4670 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4671 inner_depth.increment()?;
4672 }
4673 let val_ref = self.view_creation_token.get_or_insert_with(|| {
4674 fidl::new_empty!(
4675 fidl_fuchsia_ui_views::ViewCreationToken,
4676 fidl::encoding::DefaultFuchsiaResourceDialect
4677 )
4678 });
4679 fidl::decode!(
4680 fidl_fuchsia_ui_views::ViewCreationToken,
4681 fidl::encoding::DefaultFuchsiaResourceDialect,
4682 val_ref,
4683 decoder,
4684 inner_offset,
4685 inner_depth
4686 )?;
4687 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4688 {
4689 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4690 }
4691 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4692 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4693 }
4694 }
4695
4696 next_offset += envelope_size;
4697
4698 while next_offset < end_offset {
4700 _next_ordinal_to_read += 1;
4701 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4702 next_offset += envelope_size;
4703 }
4704
4705 Ok(())
4706 }
4707 }
4708
4709 impl PuppetFactoryCreateResponse {
4710 #[inline(always)]
4711 fn max_ordinal_present(&self) -> u64 {
4712 if let Some(_) = self.view_ref {
4713 return 2;
4714 }
4715 if let Some(_) = self.result {
4716 return 1;
4717 }
4718 0
4719 }
4720 }
4721
4722 impl fidl::encoding::ResourceTypeMarker for PuppetFactoryCreateResponse {
4723 type Borrowed<'a> = &'a mut Self;
4724 fn take_or_borrow<'a>(
4725 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4726 ) -> Self::Borrowed<'a> {
4727 value
4728 }
4729 }
4730
4731 unsafe impl fidl::encoding::TypeMarker for PuppetFactoryCreateResponse {
4732 type Owned = Self;
4733
4734 #[inline(always)]
4735 fn inline_align(_context: fidl::encoding::Context) -> usize {
4736 8
4737 }
4738
4739 #[inline(always)]
4740 fn inline_size(_context: fidl::encoding::Context) -> usize {
4741 16
4742 }
4743 }
4744
4745 unsafe impl
4746 fidl::encoding::Encode<
4747 PuppetFactoryCreateResponse,
4748 fidl::encoding::DefaultFuchsiaResourceDialect,
4749 > for &mut PuppetFactoryCreateResponse
4750 {
4751 unsafe fn encode(
4752 self,
4753 encoder: &mut fidl::encoding::Encoder<
4754 '_,
4755 fidl::encoding::DefaultFuchsiaResourceDialect,
4756 >,
4757 offset: usize,
4758 mut depth: fidl::encoding::Depth,
4759 ) -> fidl::Result<()> {
4760 encoder.debug_check_bounds::<PuppetFactoryCreateResponse>(offset);
4761 let max_ordinal: u64 = self.max_ordinal_present();
4763 encoder.write_num(max_ordinal, offset);
4764 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4765 if max_ordinal == 0 {
4767 return Ok(());
4768 }
4769 depth.increment()?;
4770 let envelope_size = 8;
4771 let bytes_len = max_ordinal as usize * envelope_size;
4772 #[allow(unused_variables)]
4773 let offset = encoder.out_of_line_offset(bytes_len);
4774 let mut _prev_end_offset: usize = 0;
4775 if 1 > max_ordinal {
4776 return Ok(());
4777 }
4778
4779 let cur_offset: usize = (1 - 1) * envelope_size;
4782
4783 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4785
4786 fidl::encoding::encode_in_envelope_optional::<
4791 Result_,
4792 fidl::encoding::DefaultFuchsiaResourceDialect,
4793 >(
4794 self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4795 encoder,
4796 offset + cur_offset,
4797 depth,
4798 )?;
4799
4800 _prev_end_offset = cur_offset + envelope_size;
4801 if 2 > max_ordinal {
4802 return Ok(());
4803 }
4804
4805 let cur_offset: usize = (2 - 1) * envelope_size;
4808
4809 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4811
4812 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
4817 self.view_ref.as_mut().map(<fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4818 encoder, offset + cur_offset, depth
4819 )?;
4820
4821 _prev_end_offset = cur_offset + envelope_size;
4822
4823 Ok(())
4824 }
4825 }
4826
4827 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4828 for PuppetFactoryCreateResponse
4829 {
4830 #[inline(always)]
4831 fn new_empty() -> Self {
4832 Self::default()
4833 }
4834
4835 unsafe fn decode(
4836 &mut self,
4837 decoder: &mut fidl::encoding::Decoder<
4838 '_,
4839 fidl::encoding::DefaultFuchsiaResourceDialect,
4840 >,
4841 offset: usize,
4842 mut depth: fidl::encoding::Depth,
4843 ) -> fidl::Result<()> {
4844 decoder.debug_check_bounds::<Self>(offset);
4845 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4846 None => return Err(fidl::Error::NotNullable),
4847 Some(len) => len,
4848 };
4849 if len == 0 {
4851 return Ok(());
4852 };
4853 depth.increment()?;
4854 let envelope_size = 8;
4855 let bytes_len = len * envelope_size;
4856 let offset = decoder.out_of_line_offset(bytes_len)?;
4857 let mut _next_ordinal_to_read = 0;
4859 let mut next_offset = offset;
4860 let end_offset = offset + bytes_len;
4861 _next_ordinal_to_read += 1;
4862 if next_offset >= end_offset {
4863 return Ok(());
4864 }
4865
4866 while _next_ordinal_to_read < 1 {
4868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4869 _next_ordinal_to_read += 1;
4870 next_offset += envelope_size;
4871 }
4872
4873 let next_out_of_line = decoder.next_out_of_line();
4874 let handles_before = decoder.remaining_handles();
4875 if let Some((inlined, num_bytes, num_handles)) =
4876 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4877 {
4878 let member_inline_size =
4879 <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4880 if inlined != (member_inline_size <= 4) {
4881 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4882 }
4883 let inner_offset;
4884 let mut inner_depth = depth.clone();
4885 if inlined {
4886 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4887 inner_offset = next_offset;
4888 } else {
4889 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4890 inner_depth.increment()?;
4891 }
4892 let val_ref = self.result.get_or_insert_with(|| {
4893 fidl::new_empty!(Result_, fidl::encoding::DefaultFuchsiaResourceDialect)
4894 });
4895 fidl::decode!(
4896 Result_,
4897 fidl::encoding::DefaultFuchsiaResourceDialect,
4898 val_ref,
4899 decoder,
4900 inner_offset,
4901 inner_depth
4902 )?;
4903 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4904 {
4905 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4906 }
4907 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4908 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4909 }
4910 }
4911
4912 next_offset += envelope_size;
4913 _next_ordinal_to_read += 1;
4914 if next_offset >= end_offset {
4915 return Ok(());
4916 }
4917
4918 while _next_ordinal_to_read < 2 {
4920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4921 _next_ordinal_to_read += 1;
4922 next_offset += envelope_size;
4923 }
4924
4925 let next_out_of_line = decoder.next_out_of_line();
4926 let handles_before = decoder.remaining_handles();
4927 if let Some((inlined, num_bytes, num_handles)) =
4928 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4929 {
4930 let member_inline_size =
4931 <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::TypeMarker>::inline_size(
4932 decoder.context,
4933 );
4934 if inlined != (member_inline_size <= 4) {
4935 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4936 }
4937 let inner_offset;
4938 let mut inner_depth = depth.clone();
4939 if inlined {
4940 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4941 inner_offset = next_offset;
4942 } else {
4943 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4944 inner_depth.increment()?;
4945 }
4946 let val_ref = self.view_ref.get_or_insert_with(|| {
4947 fidl::new_empty!(
4948 fidl_fuchsia_ui_views::ViewRef,
4949 fidl::encoding::DefaultFuchsiaResourceDialect
4950 )
4951 });
4952 fidl::decode!(
4953 fidl_fuchsia_ui_views::ViewRef,
4954 fidl::encoding::DefaultFuchsiaResourceDialect,
4955 val_ref,
4956 decoder,
4957 inner_offset,
4958 inner_depth
4959 )?;
4960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4961 {
4962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4963 }
4964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4966 }
4967 }
4968
4969 next_offset += envelope_size;
4970
4971 while next_offset < end_offset {
4973 _next_ordinal_to_read += 1;
4974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4975 next_offset += envelope_size;
4976 }
4977
4978 Ok(())
4979 }
4980 }
4981
4982 impl PuppetSetEmbeddedViewPropertiesRequest {
4983 #[inline(always)]
4984 fn max_ordinal_present(&self) -> u64 {
4985 if let Some(_) = self.properties {
4986 return 2;
4987 }
4988 if let Some(_) = self.id {
4989 return 1;
4990 }
4991 0
4992 }
4993 }
4994
4995 impl fidl::encoding::ValueTypeMarker for PuppetSetEmbeddedViewPropertiesRequest {
4996 type Borrowed<'a> = &'a Self;
4997 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4998 value
4999 }
5000 }
5001
5002 unsafe impl fidl::encoding::TypeMarker for PuppetSetEmbeddedViewPropertiesRequest {
5003 type Owned = Self;
5004
5005 #[inline(always)]
5006 fn inline_align(_context: fidl::encoding::Context) -> usize {
5007 8
5008 }
5009
5010 #[inline(always)]
5011 fn inline_size(_context: fidl::encoding::Context) -> usize {
5012 16
5013 }
5014 }
5015
5016 unsafe impl<D: fidl::encoding::ResourceDialect>
5017 fidl::encoding::Encode<PuppetSetEmbeddedViewPropertiesRequest, D>
5018 for &PuppetSetEmbeddedViewPropertiesRequest
5019 {
5020 unsafe fn encode(
5021 self,
5022 encoder: &mut fidl::encoding::Encoder<'_, D>,
5023 offset: usize,
5024 mut depth: fidl::encoding::Depth,
5025 ) -> fidl::Result<()> {
5026 encoder.debug_check_bounds::<PuppetSetEmbeddedViewPropertiesRequest>(offset);
5027 let max_ordinal: u64 = self.max_ordinal_present();
5029 encoder.write_num(max_ordinal, offset);
5030 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5031 if max_ordinal == 0 {
5033 return Ok(());
5034 }
5035 depth.increment()?;
5036 let envelope_size = 8;
5037 let bytes_len = max_ordinal as usize * envelope_size;
5038 #[allow(unused_variables)]
5039 let offset = encoder.out_of_line_offset(bytes_len);
5040 let mut _prev_end_offset: usize = 0;
5041 if 1 > max_ordinal {
5042 return Ok(());
5043 }
5044
5045 let cur_offset: usize = (1 - 1) * envelope_size;
5048
5049 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5051
5052 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5057 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5058 encoder,
5059 offset + cur_offset,
5060 depth,
5061 )?;
5062
5063 _prev_end_offset = cur_offset + envelope_size;
5064 if 2 > max_ordinal {
5065 return Ok(());
5066 }
5067
5068 let cur_offset: usize = (2 - 1) * envelope_size;
5071
5072 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5074
5075 fidl::encoding::encode_in_envelope_optional::<EmbeddedViewProperties, D>(
5080 self.properties
5081 .as_ref()
5082 .map(<EmbeddedViewProperties as fidl::encoding::ValueTypeMarker>::borrow),
5083 encoder,
5084 offset + cur_offset,
5085 depth,
5086 )?;
5087
5088 _prev_end_offset = cur_offset + envelope_size;
5089
5090 Ok(())
5091 }
5092 }
5093
5094 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5095 for PuppetSetEmbeddedViewPropertiesRequest
5096 {
5097 #[inline(always)]
5098 fn new_empty() -> Self {
5099 Self::default()
5100 }
5101
5102 unsafe fn decode(
5103 &mut self,
5104 decoder: &mut fidl::encoding::Decoder<'_, D>,
5105 offset: usize,
5106 mut depth: fidl::encoding::Depth,
5107 ) -> fidl::Result<()> {
5108 decoder.debug_check_bounds::<Self>(offset);
5109 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5110 None => return Err(fidl::Error::NotNullable),
5111 Some(len) => len,
5112 };
5113 if len == 0 {
5115 return Ok(());
5116 };
5117 depth.increment()?;
5118 let envelope_size = 8;
5119 let bytes_len = len * envelope_size;
5120 let offset = decoder.out_of_line_offset(bytes_len)?;
5121 let mut _next_ordinal_to_read = 0;
5123 let mut next_offset = offset;
5124 let end_offset = offset + bytes_len;
5125 _next_ordinal_to_read += 1;
5126 if next_offset >= end_offset {
5127 return Ok(());
5128 }
5129
5130 while _next_ordinal_to_read < 1 {
5132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5133 _next_ordinal_to_read += 1;
5134 next_offset += envelope_size;
5135 }
5136
5137 let next_out_of_line = decoder.next_out_of_line();
5138 let handles_before = decoder.remaining_handles();
5139 if let Some((inlined, num_bytes, num_handles)) =
5140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5141 {
5142 let member_inline_size =
5143 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5144 if inlined != (member_inline_size <= 4) {
5145 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5146 }
5147 let inner_offset;
5148 let mut inner_depth = depth.clone();
5149 if inlined {
5150 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5151 inner_offset = next_offset;
5152 } else {
5153 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5154 inner_depth.increment()?;
5155 }
5156 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5157 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5158 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5159 {
5160 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5161 }
5162 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5163 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5164 }
5165 }
5166
5167 next_offset += envelope_size;
5168 _next_ordinal_to_read += 1;
5169 if next_offset >= end_offset {
5170 return Ok(());
5171 }
5172
5173 while _next_ordinal_to_read < 2 {
5175 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5176 _next_ordinal_to_read += 1;
5177 next_offset += envelope_size;
5178 }
5179
5180 let next_out_of_line = decoder.next_out_of_line();
5181 let handles_before = decoder.remaining_handles();
5182 if let Some((inlined, num_bytes, num_handles)) =
5183 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5184 {
5185 let member_inline_size =
5186 <EmbeddedViewProperties as fidl::encoding::TypeMarker>::inline_size(
5187 decoder.context,
5188 );
5189 if inlined != (member_inline_size <= 4) {
5190 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5191 }
5192 let inner_offset;
5193 let mut inner_depth = depth.clone();
5194 if inlined {
5195 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5196 inner_offset = next_offset;
5197 } else {
5198 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5199 inner_depth.increment()?;
5200 }
5201 let val_ref = self
5202 .properties
5203 .get_or_insert_with(|| fidl::new_empty!(EmbeddedViewProperties, D));
5204 fidl::decode!(
5205 EmbeddedViewProperties,
5206 D,
5207 val_ref,
5208 decoder,
5209 inner_offset,
5210 inner_depth
5211 )?;
5212 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5213 {
5214 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5215 }
5216 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5217 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5218 }
5219 }
5220
5221 next_offset += envelope_size;
5222
5223 while next_offset < end_offset {
5225 _next_ordinal_to_read += 1;
5226 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5227 next_offset += envelope_size;
5228 }
5229
5230 Ok(())
5231 }
5232 }
5233
5234 impl PuppetSetEmbeddedViewPropertiesResponse {
5235 #[inline(always)]
5236 fn max_ordinal_present(&self) -> u64 {
5237 if let Some(_) = self.result {
5238 return 1;
5239 }
5240 0
5241 }
5242 }
5243
5244 impl fidl::encoding::ValueTypeMarker for PuppetSetEmbeddedViewPropertiesResponse {
5245 type Borrowed<'a> = &'a Self;
5246 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5247 value
5248 }
5249 }
5250
5251 unsafe impl fidl::encoding::TypeMarker for PuppetSetEmbeddedViewPropertiesResponse {
5252 type Owned = Self;
5253
5254 #[inline(always)]
5255 fn inline_align(_context: fidl::encoding::Context) -> usize {
5256 8
5257 }
5258
5259 #[inline(always)]
5260 fn inline_size(_context: fidl::encoding::Context) -> usize {
5261 16
5262 }
5263 }
5264
5265 unsafe impl<D: fidl::encoding::ResourceDialect>
5266 fidl::encoding::Encode<PuppetSetEmbeddedViewPropertiesResponse, D>
5267 for &PuppetSetEmbeddedViewPropertiesResponse
5268 {
5269 unsafe fn encode(
5270 self,
5271 encoder: &mut fidl::encoding::Encoder<'_, D>,
5272 offset: usize,
5273 mut depth: fidl::encoding::Depth,
5274 ) -> fidl::Result<()> {
5275 encoder.debug_check_bounds::<PuppetSetEmbeddedViewPropertiesResponse>(offset);
5276 let max_ordinal: u64 = self.max_ordinal_present();
5278 encoder.write_num(max_ordinal, offset);
5279 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5280 if max_ordinal == 0 {
5282 return Ok(());
5283 }
5284 depth.increment()?;
5285 let envelope_size = 8;
5286 let bytes_len = max_ordinal as usize * envelope_size;
5287 #[allow(unused_variables)]
5288 let offset = encoder.out_of_line_offset(bytes_len);
5289 let mut _prev_end_offset: usize = 0;
5290 if 1 > max_ordinal {
5291 return Ok(());
5292 }
5293
5294 let cur_offset: usize = (1 - 1) * envelope_size;
5297
5298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5300
5301 fidl::encoding::encode_in_envelope_optional::<Result_, D>(
5306 self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
5307 encoder,
5308 offset + cur_offset,
5309 depth,
5310 )?;
5311
5312 _prev_end_offset = cur_offset + envelope_size;
5313
5314 Ok(())
5315 }
5316 }
5317
5318 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5319 for PuppetSetEmbeddedViewPropertiesResponse
5320 {
5321 #[inline(always)]
5322 fn new_empty() -> Self {
5323 Self::default()
5324 }
5325
5326 unsafe fn decode(
5327 &mut self,
5328 decoder: &mut fidl::encoding::Decoder<'_, D>,
5329 offset: usize,
5330 mut depth: fidl::encoding::Depth,
5331 ) -> fidl::Result<()> {
5332 decoder.debug_check_bounds::<Self>(offset);
5333 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5334 None => return Err(fidl::Error::NotNullable),
5335 Some(len) => len,
5336 };
5337 if len == 0 {
5339 return Ok(());
5340 };
5341 depth.increment()?;
5342 let envelope_size = 8;
5343 let bytes_len = len * envelope_size;
5344 let offset = decoder.out_of_line_offset(bytes_len)?;
5345 let mut _next_ordinal_to_read = 0;
5347 let mut next_offset = offset;
5348 let end_offset = offset + bytes_len;
5349 _next_ordinal_to_read += 1;
5350 if next_offset >= end_offset {
5351 return Ok(());
5352 }
5353
5354 while _next_ordinal_to_read < 1 {
5356 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5357 _next_ordinal_to_read += 1;
5358 next_offset += envelope_size;
5359 }
5360
5361 let next_out_of_line = decoder.next_out_of_line();
5362 let handles_before = decoder.remaining_handles();
5363 if let Some((inlined, num_bytes, num_handles)) =
5364 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5365 {
5366 let member_inline_size =
5367 <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5368 if inlined != (member_inline_size <= 4) {
5369 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5370 }
5371 let inner_offset;
5372 let mut inner_depth = depth.clone();
5373 if inlined {
5374 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5375 inner_offset = next_offset;
5376 } else {
5377 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5378 inner_depth.increment()?;
5379 }
5380 let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
5381 fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
5382 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5383 {
5384 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5385 }
5386 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5387 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5388 }
5389 }
5390
5391 next_offset += envelope_size;
5392
5393 while next_offset < end_offset {
5395 _next_ordinal_to_read += 1;
5396 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5397 next_offset += envelope_size;
5398 }
5399
5400 Ok(())
5401 }
5402 }
5403
5404 impl PuppetSetImagePropertiesRequest {
5405 #[inline(always)]
5406 fn max_ordinal_present(&self) -> u64 {
5407 if let Some(_) = self.properties {
5408 return 2;
5409 }
5410 if let Some(_) = self.id {
5411 return 1;
5412 }
5413 0
5414 }
5415 }
5416
5417 impl fidl::encoding::ValueTypeMarker for PuppetSetImagePropertiesRequest {
5418 type Borrowed<'a> = &'a Self;
5419 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5420 value
5421 }
5422 }
5423
5424 unsafe impl fidl::encoding::TypeMarker for PuppetSetImagePropertiesRequest {
5425 type Owned = Self;
5426
5427 #[inline(always)]
5428 fn inline_align(_context: fidl::encoding::Context) -> usize {
5429 8
5430 }
5431
5432 #[inline(always)]
5433 fn inline_size(_context: fidl::encoding::Context) -> usize {
5434 16
5435 }
5436 }
5437
5438 unsafe impl<D: fidl::encoding::ResourceDialect>
5439 fidl::encoding::Encode<PuppetSetImagePropertiesRequest, D>
5440 for &PuppetSetImagePropertiesRequest
5441 {
5442 unsafe fn encode(
5443 self,
5444 encoder: &mut fidl::encoding::Encoder<'_, D>,
5445 offset: usize,
5446 mut depth: fidl::encoding::Depth,
5447 ) -> fidl::Result<()> {
5448 encoder.debug_check_bounds::<PuppetSetImagePropertiesRequest>(offset);
5449 let max_ordinal: u64 = self.max_ordinal_present();
5451 encoder.write_num(max_ordinal, offset);
5452 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5453 if max_ordinal == 0 {
5455 return Ok(());
5456 }
5457 depth.increment()?;
5458 let envelope_size = 8;
5459 let bytes_len = max_ordinal as usize * envelope_size;
5460 #[allow(unused_variables)]
5461 let offset = encoder.out_of_line_offset(bytes_len);
5462 let mut _prev_end_offset: usize = 0;
5463 if 1 > max_ordinal {
5464 return Ok(());
5465 }
5466
5467 let cur_offset: usize = (1 - 1) * envelope_size;
5470
5471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5473
5474 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5479 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5480 encoder,
5481 offset + cur_offset,
5482 depth,
5483 )?;
5484
5485 _prev_end_offset = cur_offset + envelope_size;
5486 if 2 > max_ordinal {
5487 return Ok(());
5488 }
5489
5490 let cur_offset: usize = (2 - 1) * envelope_size;
5493
5494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5496
5497 fidl::encoding::encode_in_envelope_optional::<ImageProperties, D>(
5502 self.properties
5503 .as_ref()
5504 .map(<ImageProperties as fidl::encoding::ValueTypeMarker>::borrow),
5505 encoder,
5506 offset + cur_offset,
5507 depth,
5508 )?;
5509
5510 _prev_end_offset = cur_offset + envelope_size;
5511
5512 Ok(())
5513 }
5514 }
5515
5516 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5517 for PuppetSetImagePropertiesRequest
5518 {
5519 #[inline(always)]
5520 fn new_empty() -> Self {
5521 Self::default()
5522 }
5523
5524 unsafe fn decode(
5525 &mut self,
5526 decoder: &mut fidl::encoding::Decoder<'_, D>,
5527 offset: usize,
5528 mut depth: fidl::encoding::Depth,
5529 ) -> fidl::Result<()> {
5530 decoder.debug_check_bounds::<Self>(offset);
5531 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5532 None => return Err(fidl::Error::NotNullable),
5533 Some(len) => len,
5534 };
5535 if len == 0 {
5537 return Ok(());
5538 };
5539 depth.increment()?;
5540 let envelope_size = 8;
5541 let bytes_len = len * envelope_size;
5542 let offset = decoder.out_of_line_offset(bytes_len)?;
5543 let mut _next_ordinal_to_read = 0;
5545 let mut next_offset = offset;
5546 let end_offset = offset + bytes_len;
5547 _next_ordinal_to_read += 1;
5548 if next_offset >= end_offset {
5549 return Ok(());
5550 }
5551
5552 while _next_ordinal_to_read < 1 {
5554 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5555 _next_ordinal_to_read += 1;
5556 next_offset += envelope_size;
5557 }
5558
5559 let next_out_of_line = decoder.next_out_of_line();
5560 let handles_before = decoder.remaining_handles();
5561 if let Some((inlined, num_bytes, num_handles)) =
5562 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5563 {
5564 let member_inline_size =
5565 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5566 if inlined != (member_inline_size <= 4) {
5567 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5568 }
5569 let inner_offset;
5570 let mut inner_depth = depth.clone();
5571 if inlined {
5572 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5573 inner_offset = next_offset;
5574 } else {
5575 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5576 inner_depth.increment()?;
5577 }
5578 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5579 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5580 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5581 {
5582 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5583 }
5584 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5585 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5586 }
5587 }
5588
5589 next_offset += envelope_size;
5590 _next_ordinal_to_read += 1;
5591 if next_offset >= end_offset {
5592 return Ok(());
5593 }
5594
5595 while _next_ordinal_to_read < 2 {
5597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5598 _next_ordinal_to_read += 1;
5599 next_offset += envelope_size;
5600 }
5601
5602 let next_out_of_line = decoder.next_out_of_line();
5603 let handles_before = decoder.remaining_handles();
5604 if let Some((inlined, num_bytes, num_handles)) =
5605 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5606 {
5607 let member_inline_size =
5608 <ImageProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5609 if inlined != (member_inline_size <= 4) {
5610 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5611 }
5612 let inner_offset;
5613 let mut inner_depth = depth.clone();
5614 if inlined {
5615 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5616 inner_offset = next_offset;
5617 } else {
5618 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5619 inner_depth.increment()?;
5620 }
5621 let val_ref =
5622 self.properties.get_or_insert_with(|| fidl::new_empty!(ImageProperties, D));
5623 fidl::decode!(ImageProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
5624 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5625 {
5626 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5627 }
5628 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5629 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5630 }
5631 }
5632
5633 next_offset += envelope_size;
5634
5635 while next_offset < end_offset {
5637 _next_ordinal_to_read += 1;
5638 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5639 next_offset += envelope_size;
5640 }
5641
5642 Ok(())
5643 }
5644 }
5645
5646 impl PuppetSetImagePropertiesResponse {
5647 #[inline(always)]
5648 fn max_ordinal_present(&self) -> u64 {
5649 if let Some(_) = self.result {
5650 return 1;
5651 }
5652 0
5653 }
5654 }
5655
5656 impl fidl::encoding::ValueTypeMarker for PuppetSetImagePropertiesResponse {
5657 type Borrowed<'a> = &'a Self;
5658 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5659 value
5660 }
5661 }
5662
5663 unsafe impl fidl::encoding::TypeMarker for PuppetSetImagePropertiesResponse {
5664 type Owned = Self;
5665
5666 #[inline(always)]
5667 fn inline_align(_context: fidl::encoding::Context) -> usize {
5668 8
5669 }
5670
5671 #[inline(always)]
5672 fn inline_size(_context: fidl::encoding::Context) -> usize {
5673 16
5674 }
5675 }
5676
5677 unsafe impl<D: fidl::encoding::ResourceDialect>
5678 fidl::encoding::Encode<PuppetSetImagePropertiesResponse, D>
5679 for &PuppetSetImagePropertiesResponse
5680 {
5681 unsafe fn encode(
5682 self,
5683 encoder: &mut fidl::encoding::Encoder<'_, D>,
5684 offset: usize,
5685 mut depth: fidl::encoding::Depth,
5686 ) -> fidl::Result<()> {
5687 encoder.debug_check_bounds::<PuppetSetImagePropertiesResponse>(offset);
5688 let max_ordinal: u64 = self.max_ordinal_present();
5690 encoder.write_num(max_ordinal, offset);
5691 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5692 if max_ordinal == 0 {
5694 return Ok(());
5695 }
5696 depth.increment()?;
5697 let envelope_size = 8;
5698 let bytes_len = max_ordinal as usize * envelope_size;
5699 #[allow(unused_variables)]
5700 let offset = encoder.out_of_line_offset(bytes_len);
5701 let mut _prev_end_offset: usize = 0;
5702 if 1 > max_ordinal {
5703 return Ok(());
5704 }
5705
5706 let cur_offset: usize = (1 - 1) * envelope_size;
5709
5710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5712
5713 fidl::encoding::encode_in_envelope_optional::<Result_, D>(
5718 self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
5719 encoder,
5720 offset + cur_offset,
5721 depth,
5722 )?;
5723
5724 _prev_end_offset = cur_offset + envelope_size;
5725
5726 Ok(())
5727 }
5728 }
5729
5730 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5731 for PuppetSetImagePropertiesResponse
5732 {
5733 #[inline(always)]
5734 fn new_empty() -> Self {
5735 Self::default()
5736 }
5737
5738 unsafe fn decode(
5739 &mut self,
5740 decoder: &mut fidl::encoding::Decoder<'_, D>,
5741 offset: usize,
5742 mut depth: fidl::encoding::Depth,
5743 ) -> fidl::Result<()> {
5744 decoder.debug_check_bounds::<Self>(offset);
5745 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5746 None => return Err(fidl::Error::NotNullable),
5747 Some(len) => len,
5748 };
5749 if len == 0 {
5751 return Ok(());
5752 };
5753 depth.increment()?;
5754 let envelope_size = 8;
5755 let bytes_len = len * envelope_size;
5756 let offset = decoder.out_of_line_offset(bytes_len)?;
5757 let mut _next_ordinal_to_read = 0;
5759 let mut next_offset = offset;
5760 let end_offset = offset + bytes_len;
5761 _next_ordinal_to_read += 1;
5762 if next_offset >= end_offset {
5763 return Ok(());
5764 }
5765
5766 while _next_ordinal_to_read < 1 {
5768 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5769 _next_ordinal_to_read += 1;
5770 next_offset += envelope_size;
5771 }
5772
5773 let next_out_of_line = decoder.next_out_of_line();
5774 let handles_before = decoder.remaining_handles();
5775 if let Some((inlined, num_bytes, num_handles)) =
5776 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5777 {
5778 let member_inline_size =
5779 <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5780 if inlined != (member_inline_size <= 4) {
5781 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5782 }
5783 let inner_offset;
5784 let mut inner_depth = depth.clone();
5785 if inlined {
5786 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5787 inner_offset = next_offset;
5788 } else {
5789 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5790 inner_depth.increment()?;
5791 }
5792 let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
5793 fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
5794 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5795 {
5796 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5797 }
5798 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5799 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5800 }
5801 }
5802
5803 next_offset += envelope_size;
5804
5805 while next_offset < end_offset {
5807 _next_ordinal_to_read += 1;
5808 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5809 next_offset += envelope_size;
5810 }
5811
5812 Ok(())
5813 }
5814 }
5815}