1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type Mat3 = [f32; 9];
14
15pub type Point2 = [f32; 2];
18
19pub type RelativeMotion = [f32; 2];
23
24pub type RelativeMotionRange = [fidl_fuchsia_input_report__common::Axis; 2];
27
28pub const MOUSE_MAX_EVENT: u32 = 128;
29
30pub const TOUCH_MAX_EVENT: u32 = 128;
31
32#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
59#[repr(u32)]
60pub enum EventPhase {
61 Add = 1,
63 Change = 2,
65 Remove = 3,
67 Cancel = 4,
69}
70
71impl EventPhase {
72 #[inline]
73 pub fn from_primitive(prim: u32) -> Option<Self> {
74 match prim {
75 1 => Some(Self::Add),
76 2 => Some(Self::Change),
77 3 => Some(Self::Remove),
78 4 => Some(Self::Cancel),
79 _ => None,
80 }
81 }
82
83 #[inline]
84 pub const fn into_primitive(self) -> u32 {
85 self as u32
86 }
87}
88
89#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
91#[repr(u32)]
92pub enum MouseViewStatus {
93 Entered = 1,
95 Exited = 2,
97}
98
99impl MouseViewStatus {
100 #[inline]
101 pub fn from_primitive(prim: u32) -> Option<Self> {
102 match prim {
103 1 => Some(Self::Entered),
104 2 => Some(Self::Exited),
105 _ => None,
106 }
107 }
108
109 #[inline]
110 pub const fn into_primitive(self) -> u32 {
111 self as u32
112 }
113}
114
115#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
117#[repr(u32)]
118pub enum TouchInteractionStatus {
119 Denied = 1,
121 Granted = 2,
123}
124
125impl TouchInteractionStatus {
126 #[inline]
127 pub fn from_primitive(prim: u32) -> Option<Self> {
128 match prim {
129 1 => Some(Self::Denied),
130 2 => Some(Self::Granted),
131 _ => None,
132 }
133 }
134
135 #[inline]
136 pub const fn into_primitive(self) -> u32 {
137 self as u32
138 }
139}
140
141#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
148#[repr(u32)]
149pub enum TouchResponseType {
150 No = 1,
154 Maybe = 2,
158 MaybePrioritize = 3,
163 MaybeSuppress = 4,
168 MaybePrioritizeSuppress = 5,
175 Hold = 6,
180 HoldSuppress = 7,
186 Yes = 8,
191 YesPrioritize = 9,
196}
197
198impl TouchResponseType {
199 #[inline]
200 pub fn from_primitive(prim: u32) -> Option<Self> {
201 match prim {
202 1 => Some(Self::No),
203 2 => Some(Self::Maybe),
204 3 => Some(Self::MaybePrioritize),
205 4 => Some(Self::MaybeSuppress),
206 5 => Some(Self::MaybePrioritizeSuppress),
207 6 => Some(Self::Hold),
208 7 => Some(Self::HoldSuppress),
209 8 => Some(Self::Yes),
210 9 => Some(Self::YesPrioritize),
211 _ => None,
212 }
213 }
214
215 #[inline]
216 pub const fn into_primitive(self) -> u32 {
217 self as u32
218 }
219}
220
221#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
226pub struct MouseEventStreamInfo {
227 pub device_id: u32,
229 pub status: MouseViewStatus,
231}
232
233impl fidl::Persistable for MouseEventStreamInfo {}
234
235#[derive(Clone, Debug, PartialEq)]
236pub struct MouseSourceWatchResponse {
237 pub events: Vec<MouseEvent>,
238}
239
240impl fidl::Persistable for MouseSourceWatchResponse {}
241
242#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
245pub struct Rectangle {
246 pub min: [f32; 2],
250 pub max: [f32; 2],
254}
255
256impl fidl::Persistable for Rectangle {}
257
258#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
279#[repr(C)]
280pub struct TouchInteractionId {
281 pub device_id: u32,
284 pub pointer_id: u32,
288 pub interaction_id: u32,
291}
292
293impl fidl::Persistable for TouchInteractionId {}
294
295#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
298pub struct TouchInteractionResult {
299 pub interaction: TouchInteractionId,
301 pub status: TouchInteractionStatus,
303}
304
305impl fidl::Persistable for TouchInteractionResult {}
306
307#[derive(Clone, Debug, PartialEq)]
308pub struct TouchSourceUpdateResponseRequest {
309 pub interaction: TouchInteractionId,
310 pub response: TouchResponse,
311}
312
313impl fidl::Persistable for TouchSourceUpdateResponseRequest {}
314
315#[derive(Clone, Debug, PartialEq)]
316pub struct TouchSourceWatchRequest {
317 pub responses: Vec<TouchResponse>,
318}
319
320impl fidl::Persistable for TouchSourceWatchRequest {}
321
322#[derive(Clone, Debug, PartialEq)]
323pub struct TouchSourceWatchResponse {
324 pub events: Vec<TouchEvent>,
325}
326
327impl fidl::Persistable for TouchSourceWatchResponse {}
328
329#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
342pub struct ViewParameters {
343 pub view: Rectangle,
348 pub viewport: Rectangle,
357 pub viewport_to_view_transform: [f32; 9],
360}
361
362impl fidl::Persistable for ViewParameters {}
363
364#[derive(Clone, Debug, Default, PartialEq)]
366pub struct MouseDeviceInfo {
367 pub id: Option<u32>,
370 pub scroll_v_range: Option<fidl_fuchsia_input_report__common::Axis>,
372 pub scroll_h_range: Option<fidl_fuchsia_input_report__common::Axis>,
374 pub buttons: Option<Vec<u8>>,
376 pub relative_motion_range: Option<[fidl_fuchsia_input_report__common::Axis; 2]>,
378 #[doc(hidden)]
379 pub __source_breaking: fidl::marker::SourceBreaking,
380}
381
382impl fidl::Persistable for MouseDeviceInfo {}
383
384#[derive(Clone, Debug, Default, PartialEq)]
387pub struct MouseEvent {
388 pub timestamp: Option<i64>,
391 pub view_parameters: Option<ViewParameters>,
396 pub device_info: Option<MouseDeviceInfo>,
400 pub pointer_sample: Option<MousePointerSample>,
409 pub stream_info: Option<MouseEventStreamInfo>,
412 pub trace_flow_id: Option<u64>,
415 #[doc(hidden)]
416 pub __source_breaking: fidl::marker::SourceBreaking,
417}
418
419impl fidl::Persistable for MouseEvent {}
420
421#[derive(Clone, Debug, Default, PartialEq)]
429pub struct MousePointerSample {
430 pub device_id: Option<u32>,
433 pub position_in_viewport: Option<[f32; 2]>,
436 pub scroll_v: Option<i64>,
438 pub scroll_h: Option<i64>,
440 pub pressed_buttons: Option<Vec<u8>>,
442 pub relative_motion: Option<[f32; 2]>,
445 pub scroll_v_physical_pixel: Option<f64>,
448 pub scroll_h_physical_pixel: Option<f64>,
451 pub is_precision_scroll: Option<bool>,
455 #[doc(hidden)]
456 pub __source_breaking: fidl::marker::SourceBreaking,
457}
458
459impl fidl::Persistable for MousePointerSample {}
460
461#[derive(Clone, Debug, Default, PartialEq)]
463pub struct TouchDeviceInfo {
464 pub id: Option<u32>,
469 #[doc(hidden)]
470 pub __source_breaking: fidl::marker::SourceBreaking,
471}
472
473impl fidl::Persistable for TouchDeviceInfo {}
474
475#[derive(Clone, Debug, Default, PartialEq)]
478pub struct TouchEvent {
479 pub timestamp: Option<i64>,
482 pub view_parameters: Option<ViewParameters>,
487 pub device_info: Option<TouchDeviceInfo>,
491 pub pointer_sample: Option<TouchPointerSample>,
495 pub interaction_result: Option<TouchInteractionResult>,
498 pub trace_flow_id: Option<u64>,
501 #[doc(hidden)]
502 pub __source_breaking: fidl::marker::SourceBreaking,
503}
504
505impl fidl::Persistable for TouchEvent {}
506
507#[derive(Clone, Debug, Default, PartialEq)]
510pub struct TouchPointerSample {
511 pub interaction: Option<TouchInteractionId>,
513 pub phase: Option<EventPhase>,
515 pub position_in_viewport: Option<[f32; 2]>,
517 #[doc(hidden)]
518 pub __source_breaking: fidl::marker::SourceBreaking,
519}
520
521impl fidl::Persistable for TouchPointerSample {}
522
523#[derive(Clone, Debug, Default, PartialEq)]
528pub struct TouchResponse {
529 pub response_type: Option<TouchResponseType>,
532 pub trace_flow_id: Option<u64>,
535 #[doc(hidden)]
536 pub __source_breaking: fidl::marker::SourceBreaking,
537}
538
539impl fidl::Persistable for TouchResponse {}
540
541mod internal {
542 use super::*;
543 unsafe impl fidl::encoding::TypeMarker for EventPhase {
544 type Owned = Self;
545
546 #[inline(always)]
547 fn inline_align(_context: fidl::encoding::Context) -> usize {
548 std::mem::align_of::<u32>()
549 }
550
551 #[inline(always)]
552 fn inline_size(_context: fidl::encoding::Context) -> usize {
553 std::mem::size_of::<u32>()
554 }
555
556 #[inline(always)]
557 fn encode_is_copy() -> bool {
558 true
559 }
560
561 #[inline(always)]
562 fn decode_is_copy() -> bool {
563 false
564 }
565 }
566
567 impl fidl::encoding::ValueTypeMarker for EventPhase {
568 type Borrowed<'a> = Self;
569 #[inline(always)]
570 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
571 *value
572 }
573 }
574
575 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EventPhase {
576 #[inline]
577 unsafe fn encode(
578 self,
579 encoder: &mut fidl::encoding::Encoder<'_, D>,
580 offset: usize,
581 _depth: fidl::encoding::Depth,
582 ) -> fidl::Result<()> {
583 encoder.debug_check_bounds::<Self>(offset);
584 encoder.write_num(self.into_primitive(), offset);
585 Ok(())
586 }
587 }
588
589 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventPhase {
590 #[inline(always)]
591 fn new_empty() -> Self {
592 Self::Add
593 }
594
595 #[inline]
596 unsafe fn decode(
597 &mut self,
598 decoder: &mut fidl::encoding::Decoder<'_, D>,
599 offset: usize,
600 _depth: fidl::encoding::Depth,
601 ) -> fidl::Result<()> {
602 decoder.debug_check_bounds::<Self>(offset);
603 let prim = decoder.read_num::<u32>(offset);
604
605 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
606 Ok(())
607 }
608 }
609 unsafe impl fidl::encoding::TypeMarker for MouseViewStatus {
610 type Owned = Self;
611
612 #[inline(always)]
613 fn inline_align(_context: fidl::encoding::Context) -> usize {
614 std::mem::align_of::<u32>()
615 }
616
617 #[inline(always)]
618 fn inline_size(_context: fidl::encoding::Context) -> usize {
619 std::mem::size_of::<u32>()
620 }
621
622 #[inline(always)]
623 fn encode_is_copy() -> bool {
624 true
625 }
626
627 #[inline(always)]
628 fn decode_is_copy() -> bool {
629 false
630 }
631 }
632
633 impl fidl::encoding::ValueTypeMarker for MouseViewStatus {
634 type Borrowed<'a> = Self;
635 #[inline(always)]
636 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
637 *value
638 }
639 }
640
641 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
642 for MouseViewStatus
643 {
644 #[inline]
645 unsafe fn encode(
646 self,
647 encoder: &mut fidl::encoding::Encoder<'_, D>,
648 offset: usize,
649 _depth: fidl::encoding::Depth,
650 ) -> fidl::Result<()> {
651 encoder.debug_check_bounds::<Self>(offset);
652 encoder.write_num(self.into_primitive(), offset);
653 Ok(())
654 }
655 }
656
657 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseViewStatus {
658 #[inline(always)]
659 fn new_empty() -> Self {
660 Self::Entered
661 }
662
663 #[inline]
664 unsafe fn decode(
665 &mut self,
666 decoder: &mut fidl::encoding::Decoder<'_, D>,
667 offset: usize,
668 _depth: fidl::encoding::Depth,
669 ) -> fidl::Result<()> {
670 decoder.debug_check_bounds::<Self>(offset);
671 let prim = decoder.read_num::<u32>(offset);
672
673 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
674 Ok(())
675 }
676 }
677 unsafe impl fidl::encoding::TypeMarker for TouchInteractionStatus {
678 type Owned = Self;
679
680 #[inline(always)]
681 fn inline_align(_context: fidl::encoding::Context) -> usize {
682 std::mem::align_of::<u32>()
683 }
684
685 #[inline(always)]
686 fn inline_size(_context: fidl::encoding::Context) -> usize {
687 std::mem::size_of::<u32>()
688 }
689
690 #[inline(always)]
691 fn encode_is_copy() -> bool {
692 true
693 }
694
695 #[inline(always)]
696 fn decode_is_copy() -> bool {
697 false
698 }
699 }
700
701 impl fidl::encoding::ValueTypeMarker for TouchInteractionStatus {
702 type Borrowed<'a> = Self;
703 #[inline(always)]
704 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
705 *value
706 }
707 }
708
709 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
710 for TouchInteractionStatus
711 {
712 #[inline]
713 unsafe fn encode(
714 self,
715 encoder: &mut fidl::encoding::Encoder<'_, D>,
716 offset: usize,
717 _depth: fidl::encoding::Depth,
718 ) -> fidl::Result<()> {
719 encoder.debug_check_bounds::<Self>(offset);
720 encoder.write_num(self.into_primitive(), offset);
721 Ok(())
722 }
723 }
724
725 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
726 for TouchInteractionStatus
727 {
728 #[inline(always)]
729 fn new_empty() -> Self {
730 Self::Denied
731 }
732
733 #[inline]
734 unsafe fn decode(
735 &mut self,
736 decoder: &mut fidl::encoding::Decoder<'_, D>,
737 offset: usize,
738 _depth: fidl::encoding::Depth,
739 ) -> fidl::Result<()> {
740 decoder.debug_check_bounds::<Self>(offset);
741 let prim = decoder.read_num::<u32>(offset);
742
743 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
744 Ok(())
745 }
746 }
747 unsafe impl fidl::encoding::TypeMarker for TouchResponseType {
748 type Owned = Self;
749
750 #[inline(always)]
751 fn inline_align(_context: fidl::encoding::Context) -> usize {
752 std::mem::align_of::<u32>()
753 }
754
755 #[inline(always)]
756 fn inline_size(_context: fidl::encoding::Context) -> usize {
757 std::mem::size_of::<u32>()
758 }
759
760 #[inline(always)]
761 fn encode_is_copy() -> bool {
762 true
763 }
764
765 #[inline(always)]
766 fn decode_is_copy() -> bool {
767 false
768 }
769 }
770
771 impl fidl::encoding::ValueTypeMarker for TouchResponseType {
772 type Borrowed<'a> = Self;
773 #[inline(always)]
774 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
775 *value
776 }
777 }
778
779 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
780 for TouchResponseType
781 {
782 #[inline]
783 unsafe fn encode(
784 self,
785 encoder: &mut fidl::encoding::Encoder<'_, D>,
786 offset: usize,
787 _depth: fidl::encoding::Depth,
788 ) -> fidl::Result<()> {
789 encoder.debug_check_bounds::<Self>(offset);
790 encoder.write_num(self.into_primitive(), offset);
791 Ok(())
792 }
793 }
794
795 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchResponseType {
796 #[inline(always)]
797 fn new_empty() -> Self {
798 Self::No
799 }
800
801 #[inline]
802 unsafe fn decode(
803 &mut self,
804 decoder: &mut fidl::encoding::Decoder<'_, D>,
805 offset: usize,
806 _depth: fidl::encoding::Depth,
807 ) -> fidl::Result<()> {
808 decoder.debug_check_bounds::<Self>(offset);
809 let prim = decoder.read_num::<u32>(offset);
810
811 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
812 Ok(())
813 }
814 }
815
816 impl fidl::encoding::ValueTypeMarker for MouseEventStreamInfo {
817 type Borrowed<'a> = &'a Self;
818 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
819 value
820 }
821 }
822
823 unsafe impl fidl::encoding::TypeMarker for MouseEventStreamInfo {
824 type Owned = Self;
825
826 #[inline(always)]
827 fn inline_align(_context: fidl::encoding::Context) -> usize {
828 4
829 }
830
831 #[inline(always)]
832 fn inline_size(_context: fidl::encoding::Context) -> usize {
833 8
834 }
835 }
836
837 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseEventStreamInfo, D>
838 for &MouseEventStreamInfo
839 {
840 #[inline]
841 unsafe fn encode(
842 self,
843 encoder: &mut fidl::encoding::Encoder<'_, D>,
844 offset: usize,
845 _depth: fidl::encoding::Depth,
846 ) -> fidl::Result<()> {
847 encoder.debug_check_bounds::<MouseEventStreamInfo>(offset);
848 fidl::encoding::Encode::<MouseEventStreamInfo, D>::encode(
850 (
851 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_id),
852 <MouseViewStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
853 ),
854 encoder,
855 offset,
856 _depth,
857 )
858 }
859 }
860 unsafe impl<
861 D: fidl::encoding::ResourceDialect,
862 T0: fidl::encoding::Encode<u32, D>,
863 T1: fidl::encoding::Encode<MouseViewStatus, D>,
864 > fidl::encoding::Encode<MouseEventStreamInfo, D> for (T0, T1)
865 {
866 #[inline]
867 unsafe fn encode(
868 self,
869 encoder: &mut fidl::encoding::Encoder<'_, D>,
870 offset: usize,
871 depth: fidl::encoding::Depth,
872 ) -> fidl::Result<()> {
873 encoder.debug_check_bounds::<MouseEventStreamInfo>(offset);
874 self.0.encode(encoder, offset + 0, depth)?;
878 self.1.encode(encoder, offset + 4, depth)?;
879 Ok(())
880 }
881 }
882
883 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseEventStreamInfo {
884 #[inline(always)]
885 fn new_empty() -> Self {
886 Self {
887 device_id: fidl::new_empty!(u32, D),
888 status: fidl::new_empty!(MouseViewStatus, D),
889 }
890 }
891
892 #[inline]
893 unsafe fn decode(
894 &mut self,
895 decoder: &mut fidl::encoding::Decoder<'_, D>,
896 offset: usize,
897 _depth: fidl::encoding::Depth,
898 ) -> fidl::Result<()> {
899 decoder.debug_check_bounds::<Self>(offset);
900 fidl::decode!(u32, D, &mut self.device_id, decoder, offset + 0, _depth)?;
902 fidl::decode!(MouseViewStatus, D, &mut self.status, decoder, offset + 4, _depth)?;
903 Ok(())
904 }
905 }
906
907 impl fidl::encoding::ValueTypeMarker for MouseSourceWatchResponse {
908 type Borrowed<'a> = &'a Self;
909 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
910 value
911 }
912 }
913
914 unsafe impl fidl::encoding::TypeMarker for MouseSourceWatchResponse {
915 type Owned = Self;
916
917 #[inline(always)]
918 fn inline_align(_context: fidl::encoding::Context) -> usize {
919 8
920 }
921
922 #[inline(always)]
923 fn inline_size(_context: fidl::encoding::Context) -> usize {
924 16
925 }
926 }
927
928 unsafe impl<D: fidl::encoding::ResourceDialect>
929 fidl::encoding::Encode<MouseSourceWatchResponse, D> for &MouseSourceWatchResponse
930 {
931 #[inline]
932 unsafe fn encode(
933 self,
934 encoder: &mut fidl::encoding::Encoder<'_, D>,
935 offset: usize,
936 _depth: fidl::encoding::Depth,
937 ) -> fidl::Result<()> {
938 encoder.debug_check_bounds::<MouseSourceWatchResponse>(offset);
939 fidl::encoding::Encode::<MouseSourceWatchResponse, D>::encode(
941 (
942 <fidl::encoding::Vector<MouseEvent, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
943 ),
944 encoder, offset, _depth
945 )
946 }
947 }
948 unsafe impl<
949 D: fidl::encoding::ResourceDialect,
950 T0: fidl::encoding::Encode<fidl::encoding::Vector<MouseEvent, 128>, D>,
951 > fidl::encoding::Encode<MouseSourceWatchResponse, D> for (T0,)
952 {
953 #[inline]
954 unsafe fn encode(
955 self,
956 encoder: &mut fidl::encoding::Encoder<'_, D>,
957 offset: usize,
958 depth: fidl::encoding::Depth,
959 ) -> fidl::Result<()> {
960 encoder.debug_check_bounds::<MouseSourceWatchResponse>(offset);
961 self.0.encode(encoder, offset + 0, depth)?;
965 Ok(())
966 }
967 }
968
969 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
970 for MouseSourceWatchResponse
971 {
972 #[inline(always)]
973 fn new_empty() -> Self {
974 Self { events: fidl::new_empty!(fidl::encoding::Vector<MouseEvent, 128>, D) }
975 }
976
977 #[inline]
978 unsafe fn decode(
979 &mut self,
980 decoder: &mut fidl::encoding::Decoder<'_, D>,
981 offset: usize,
982 _depth: fidl::encoding::Depth,
983 ) -> fidl::Result<()> {
984 decoder.debug_check_bounds::<Self>(offset);
985 fidl::decode!(fidl::encoding::Vector<MouseEvent, 128>, D, &mut self.events, decoder, offset + 0, _depth)?;
987 Ok(())
988 }
989 }
990
991 impl fidl::encoding::ValueTypeMarker for Rectangle {
992 type Borrowed<'a> = &'a Self;
993 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
994 value
995 }
996 }
997
998 unsafe impl fidl::encoding::TypeMarker for Rectangle {
999 type Owned = Self;
1000
1001 #[inline(always)]
1002 fn inline_align(_context: fidl::encoding::Context) -> usize {
1003 4
1004 }
1005
1006 #[inline(always)]
1007 fn inline_size(_context: fidl::encoding::Context) -> usize {
1008 16
1009 }
1010 }
1011
1012 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Rectangle, D>
1013 for &Rectangle
1014 {
1015 #[inline]
1016 unsafe fn encode(
1017 self,
1018 encoder: &mut fidl::encoding::Encoder<'_, D>,
1019 offset: usize,
1020 _depth: fidl::encoding::Depth,
1021 ) -> fidl::Result<()> {
1022 encoder.debug_check_bounds::<Rectangle>(offset);
1023 fidl::encoding::Encode::<Rectangle, D>::encode(
1025 (
1026 <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow(
1027 &self.min,
1028 ),
1029 <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow(
1030 &self.max,
1031 ),
1032 ),
1033 encoder,
1034 offset,
1035 _depth,
1036 )
1037 }
1038 }
1039 unsafe impl<
1040 D: fidl::encoding::ResourceDialect,
1041 T0: fidl::encoding::Encode<fidl::encoding::Array<f32, 2>, D>,
1042 T1: fidl::encoding::Encode<fidl::encoding::Array<f32, 2>, D>,
1043 > fidl::encoding::Encode<Rectangle, D> for (T0, T1)
1044 {
1045 #[inline]
1046 unsafe fn encode(
1047 self,
1048 encoder: &mut fidl::encoding::Encoder<'_, D>,
1049 offset: usize,
1050 depth: fidl::encoding::Depth,
1051 ) -> fidl::Result<()> {
1052 encoder.debug_check_bounds::<Rectangle>(offset);
1053 self.0.encode(encoder, offset + 0, depth)?;
1057 self.1.encode(encoder, offset + 8, depth)?;
1058 Ok(())
1059 }
1060 }
1061
1062 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Rectangle {
1063 #[inline(always)]
1064 fn new_empty() -> Self {
1065 Self {
1066 min: fidl::new_empty!(fidl::encoding::Array<f32, 2>, D),
1067 max: fidl::new_empty!(fidl::encoding::Array<f32, 2>, D),
1068 }
1069 }
1070
1071 #[inline]
1072 unsafe fn decode(
1073 &mut self,
1074 decoder: &mut fidl::encoding::Decoder<'_, D>,
1075 offset: usize,
1076 _depth: fidl::encoding::Depth,
1077 ) -> fidl::Result<()> {
1078 decoder.debug_check_bounds::<Self>(offset);
1079 fidl::decode!(fidl::encoding::Array<f32, 2>, D, &mut self.min, decoder, offset + 0, _depth)?;
1081 fidl::decode!(fidl::encoding::Array<f32, 2>, D, &mut self.max, decoder, offset + 8, _depth)?;
1082 Ok(())
1083 }
1084 }
1085
1086 impl fidl::encoding::ValueTypeMarker for TouchInteractionId {
1087 type Borrowed<'a> = &'a Self;
1088 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1089 value
1090 }
1091 }
1092
1093 unsafe impl fidl::encoding::TypeMarker for TouchInteractionId {
1094 type Owned = Self;
1095
1096 #[inline(always)]
1097 fn inline_align(_context: fidl::encoding::Context) -> usize {
1098 4
1099 }
1100
1101 #[inline(always)]
1102 fn inline_size(_context: fidl::encoding::Context) -> usize {
1103 12
1104 }
1105 #[inline(always)]
1106 fn encode_is_copy() -> bool {
1107 true
1108 }
1109
1110 #[inline(always)]
1111 fn decode_is_copy() -> bool {
1112 true
1113 }
1114 }
1115
1116 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchInteractionId, D>
1117 for &TouchInteractionId
1118 {
1119 #[inline]
1120 unsafe fn encode(
1121 self,
1122 encoder: &mut fidl::encoding::Encoder<'_, D>,
1123 offset: usize,
1124 _depth: fidl::encoding::Depth,
1125 ) -> fidl::Result<()> {
1126 encoder.debug_check_bounds::<TouchInteractionId>(offset);
1127 unsafe {
1128 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1130 (buf_ptr as *mut TouchInteractionId)
1131 .write_unaligned((self as *const TouchInteractionId).read());
1132 }
1135 Ok(())
1136 }
1137 }
1138 unsafe impl<
1139 D: fidl::encoding::ResourceDialect,
1140 T0: fidl::encoding::Encode<u32, D>,
1141 T1: fidl::encoding::Encode<u32, D>,
1142 T2: fidl::encoding::Encode<u32, D>,
1143 > fidl::encoding::Encode<TouchInteractionId, D> for (T0, T1, T2)
1144 {
1145 #[inline]
1146 unsafe fn encode(
1147 self,
1148 encoder: &mut fidl::encoding::Encoder<'_, D>,
1149 offset: usize,
1150 depth: fidl::encoding::Depth,
1151 ) -> fidl::Result<()> {
1152 encoder.debug_check_bounds::<TouchInteractionId>(offset);
1153 self.0.encode(encoder, offset + 0, depth)?;
1157 self.1.encode(encoder, offset + 4, depth)?;
1158 self.2.encode(encoder, offset + 8, depth)?;
1159 Ok(())
1160 }
1161 }
1162
1163 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchInteractionId {
1164 #[inline(always)]
1165 fn new_empty() -> Self {
1166 Self {
1167 device_id: fidl::new_empty!(u32, D),
1168 pointer_id: fidl::new_empty!(u32, D),
1169 interaction_id: fidl::new_empty!(u32, D),
1170 }
1171 }
1172
1173 #[inline]
1174 unsafe fn decode(
1175 &mut self,
1176 decoder: &mut fidl::encoding::Decoder<'_, D>,
1177 offset: usize,
1178 _depth: fidl::encoding::Depth,
1179 ) -> fidl::Result<()> {
1180 decoder.debug_check_bounds::<Self>(offset);
1181 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1182 unsafe {
1185 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
1186 }
1187 Ok(())
1188 }
1189 }
1190
1191 impl fidl::encoding::ValueTypeMarker for TouchInteractionResult {
1192 type Borrowed<'a> = &'a Self;
1193 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1194 value
1195 }
1196 }
1197
1198 unsafe impl fidl::encoding::TypeMarker for TouchInteractionResult {
1199 type Owned = Self;
1200
1201 #[inline(always)]
1202 fn inline_align(_context: fidl::encoding::Context) -> usize {
1203 4
1204 }
1205
1206 #[inline(always)]
1207 fn inline_size(_context: fidl::encoding::Context) -> usize {
1208 16
1209 }
1210 }
1211
1212 unsafe impl<D: fidl::encoding::ResourceDialect>
1213 fidl::encoding::Encode<TouchInteractionResult, D> for &TouchInteractionResult
1214 {
1215 #[inline]
1216 unsafe fn encode(
1217 self,
1218 encoder: &mut fidl::encoding::Encoder<'_, D>,
1219 offset: usize,
1220 _depth: fidl::encoding::Depth,
1221 ) -> fidl::Result<()> {
1222 encoder.debug_check_bounds::<TouchInteractionResult>(offset);
1223 fidl::encoding::Encode::<TouchInteractionResult, D>::encode(
1225 (
1226 <TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow(
1227 &self.interaction,
1228 ),
1229 <TouchInteractionStatus as fidl::encoding::ValueTypeMarker>::borrow(
1230 &self.status,
1231 ),
1232 ),
1233 encoder,
1234 offset,
1235 _depth,
1236 )
1237 }
1238 }
1239 unsafe impl<
1240 D: fidl::encoding::ResourceDialect,
1241 T0: fidl::encoding::Encode<TouchInteractionId, D>,
1242 T1: fidl::encoding::Encode<TouchInteractionStatus, D>,
1243 > fidl::encoding::Encode<TouchInteractionResult, D> for (T0, T1)
1244 {
1245 #[inline]
1246 unsafe fn encode(
1247 self,
1248 encoder: &mut fidl::encoding::Encoder<'_, D>,
1249 offset: usize,
1250 depth: fidl::encoding::Depth,
1251 ) -> fidl::Result<()> {
1252 encoder.debug_check_bounds::<TouchInteractionResult>(offset);
1253 self.0.encode(encoder, offset + 0, depth)?;
1257 self.1.encode(encoder, offset + 12, depth)?;
1258 Ok(())
1259 }
1260 }
1261
1262 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1263 for TouchInteractionResult
1264 {
1265 #[inline(always)]
1266 fn new_empty() -> Self {
1267 Self {
1268 interaction: fidl::new_empty!(TouchInteractionId, D),
1269 status: fidl::new_empty!(TouchInteractionStatus, D),
1270 }
1271 }
1272
1273 #[inline]
1274 unsafe fn decode(
1275 &mut self,
1276 decoder: &mut fidl::encoding::Decoder<'_, D>,
1277 offset: usize,
1278 _depth: fidl::encoding::Depth,
1279 ) -> fidl::Result<()> {
1280 decoder.debug_check_bounds::<Self>(offset);
1281 fidl::decode!(
1283 TouchInteractionId,
1284 D,
1285 &mut self.interaction,
1286 decoder,
1287 offset + 0,
1288 _depth
1289 )?;
1290 fidl::decode!(
1291 TouchInteractionStatus,
1292 D,
1293 &mut self.status,
1294 decoder,
1295 offset + 12,
1296 _depth
1297 )?;
1298 Ok(())
1299 }
1300 }
1301
1302 impl fidl::encoding::ValueTypeMarker for TouchSourceUpdateResponseRequest {
1303 type Borrowed<'a> = &'a Self;
1304 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1305 value
1306 }
1307 }
1308
1309 unsafe impl fidl::encoding::TypeMarker for TouchSourceUpdateResponseRequest {
1310 type Owned = Self;
1311
1312 #[inline(always)]
1313 fn inline_align(_context: fidl::encoding::Context) -> usize {
1314 8
1315 }
1316
1317 #[inline(always)]
1318 fn inline_size(_context: fidl::encoding::Context) -> usize {
1319 32
1320 }
1321 }
1322
1323 unsafe impl<D: fidl::encoding::ResourceDialect>
1324 fidl::encoding::Encode<TouchSourceUpdateResponseRequest, D>
1325 for &TouchSourceUpdateResponseRequest
1326 {
1327 #[inline]
1328 unsafe fn encode(
1329 self,
1330 encoder: &mut fidl::encoding::Encoder<'_, D>,
1331 offset: usize,
1332 _depth: fidl::encoding::Depth,
1333 ) -> fidl::Result<()> {
1334 encoder.debug_check_bounds::<TouchSourceUpdateResponseRequest>(offset);
1335 fidl::encoding::Encode::<TouchSourceUpdateResponseRequest, D>::encode(
1337 (
1338 <TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow(
1339 &self.interaction,
1340 ),
1341 <TouchResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),
1342 ),
1343 encoder,
1344 offset,
1345 _depth,
1346 )
1347 }
1348 }
1349 unsafe impl<
1350 D: fidl::encoding::ResourceDialect,
1351 T0: fidl::encoding::Encode<TouchInteractionId, D>,
1352 T1: fidl::encoding::Encode<TouchResponse, D>,
1353 > fidl::encoding::Encode<TouchSourceUpdateResponseRequest, D> for (T0, T1)
1354 {
1355 #[inline]
1356 unsafe fn encode(
1357 self,
1358 encoder: &mut fidl::encoding::Encoder<'_, D>,
1359 offset: usize,
1360 depth: fidl::encoding::Depth,
1361 ) -> fidl::Result<()> {
1362 encoder.debug_check_bounds::<TouchSourceUpdateResponseRequest>(offset);
1363 unsafe {
1366 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1367 (ptr as *mut u64).write_unaligned(0);
1368 }
1369 self.0.encode(encoder, offset + 0, depth)?;
1371 self.1.encode(encoder, offset + 16, depth)?;
1372 Ok(())
1373 }
1374 }
1375
1376 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1377 for TouchSourceUpdateResponseRequest
1378 {
1379 #[inline(always)]
1380 fn new_empty() -> Self {
1381 Self {
1382 interaction: fidl::new_empty!(TouchInteractionId, D),
1383 response: fidl::new_empty!(TouchResponse, D),
1384 }
1385 }
1386
1387 #[inline]
1388 unsafe fn decode(
1389 &mut self,
1390 decoder: &mut fidl::encoding::Decoder<'_, D>,
1391 offset: usize,
1392 _depth: fidl::encoding::Depth,
1393 ) -> fidl::Result<()> {
1394 decoder.debug_check_bounds::<Self>(offset);
1395 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
1397 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1398 let mask = 0xffffffff00000000u64;
1399 let maskedval = padval & mask;
1400 if maskedval != 0 {
1401 return Err(fidl::Error::NonZeroPadding {
1402 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1403 });
1404 }
1405 fidl::decode!(
1406 TouchInteractionId,
1407 D,
1408 &mut self.interaction,
1409 decoder,
1410 offset + 0,
1411 _depth
1412 )?;
1413 fidl::decode!(TouchResponse, D, &mut self.response, decoder, offset + 16, _depth)?;
1414 Ok(())
1415 }
1416 }
1417
1418 impl fidl::encoding::ValueTypeMarker for TouchSourceWatchRequest {
1419 type Borrowed<'a> = &'a Self;
1420 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1421 value
1422 }
1423 }
1424
1425 unsafe impl fidl::encoding::TypeMarker for TouchSourceWatchRequest {
1426 type Owned = Self;
1427
1428 #[inline(always)]
1429 fn inline_align(_context: fidl::encoding::Context) -> usize {
1430 8
1431 }
1432
1433 #[inline(always)]
1434 fn inline_size(_context: fidl::encoding::Context) -> usize {
1435 16
1436 }
1437 }
1438
1439 unsafe impl<D: fidl::encoding::ResourceDialect>
1440 fidl::encoding::Encode<TouchSourceWatchRequest, D> for &TouchSourceWatchRequest
1441 {
1442 #[inline]
1443 unsafe fn encode(
1444 self,
1445 encoder: &mut fidl::encoding::Encoder<'_, D>,
1446 offset: usize,
1447 _depth: fidl::encoding::Depth,
1448 ) -> fidl::Result<()> {
1449 encoder.debug_check_bounds::<TouchSourceWatchRequest>(offset);
1450 fidl::encoding::Encode::<TouchSourceWatchRequest, D>::encode(
1452 (
1453 <fidl::encoding::Vector<TouchResponse, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.responses),
1454 ),
1455 encoder, offset, _depth
1456 )
1457 }
1458 }
1459 unsafe impl<
1460 D: fidl::encoding::ResourceDialect,
1461 T0: fidl::encoding::Encode<fidl::encoding::Vector<TouchResponse, 128>, D>,
1462 > fidl::encoding::Encode<TouchSourceWatchRequest, D> for (T0,)
1463 {
1464 #[inline]
1465 unsafe fn encode(
1466 self,
1467 encoder: &mut fidl::encoding::Encoder<'_, D>,
1468 offset: usize,
1469 depth: fidl::encoding::Depth,
1470 ) -> fidl::Result<()> {
1471 encoder.debug_check_bounds::<TouchSourceWatchRequest>(offset);
1472 self.0.encode(encoder, offset + 0, depth)?;
1476 Ok(())
1477 }
1478 }
1479
1480 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1481 for TouchSourceWatchRequest
1482 {
1483 #[inline(always)]
1484 fn new_empty() -> Self {
1485 Self { responses: fidl::new_empty!(fidl::encoding::Vector<TouchResponse, 128>, D) }
1486 }
1487
1488 #[inline]
1489 unsafe fn decode(
1490 &mut self,
1491 decoder: &mut fidl::encoding::Decoder<'_, D>,
1492 offset: usize,
1493 _depth: fidl::encoding::Depth,
1494 ) -> fidl::Result<()> {
1495 decoder.debug_check_bounds::<Self>(offset);
1496 fidl::decode!(fidl::encoding::Vector<TouchResponse, 128>, D, &mut self.responses, decoder, offset + 0, _depth)?;
1498 Ok(())
1499 }
1500 }
1501
1502 impl fidl::encoding::ValueTypeMarker for TouchSourceWatchResponse {
1503 type Borrowed<'a> = &'a Self;
1504 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1505 value
1506 }
1507 }
1508
1509 unsafe impl fidl::encoding::TypeMarker for TouchSourceWatchResponse {
1510 type Owned = Self;
1511
1512 #[inline(always)]
1513 fn inline_align(_context: fidl::encoding::Context) -> usize {
1514 8
1515 }
1516
1517 #[inline(always)]
1518 fn inline_size(_context: fidl::encoding::Context) -> usize {
1519 16
1520 }
1521 }
1522
1523 unsafe impl<D: fidl::encoding::ResourceDialect>
1524 fidl::encoding::Encode<TouchSourceWatchResponse, D> for &TouchSourceWatchResponse
1525 {
1526 #[inline]
1527 unsafe fn encode(
1528 self,
1529 encoder: &mut fidl::encoding::Encoder<'_, D>,
1530 offset: usize,
1531 _depth: fidl::encoding::Depth,
1532 ) -> fidl::Result<()> {
1533 encoder.debug_check_bounds::<TouchSourceWatchResponse>(offset);
1534 fidl::encoding::Encode::<TouchSourceWatchResponse, D>::encode(
1536 (
1537 <fidl::encoding::Vector<TouchEvent, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
1538 ),
1539 encoder, offset, _depth
1540 )
1541 }
1542 }
1543 unsafe impl<
1544 D: fidl::encoding::ResourceDialect,
1545 T0: fidl::encoding::Encode<fidl::encoding::Vector<TouchEvent, 128>, D>,
1546 > fidl::encoding::Encode<TouchSourceWatchResponse, D> for (T0,)
1547 {
1548 #[inline]
1549 unsafe fn encode(
1550 self,
1551 encoder: &mut fidl::encoding::Encoder<'_, D>,
1552 offset: usize,
1553 depth: fidl::encoding::Depth,
1554 ) -> fidl::Result<()> {
1555 encoder.debug_check_bounds::<TouchSourceWatchResponse>(offset);
1556 self.0.encode(encoder, offset + 0, depth)?;
1560 Ok(())
1561 }
1562 }
1563
1564 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1565 for TouchSourceWatchResponse
1566 {
1567 #[inline(always)]
1568 fn new_empty() -> Self {
1569 Self { events: fidl::new_empty!(fidl::encoding::Vector<TouchEvent, 128>, D) }
1570 }
1571
1572 #[inline]
1573 unsafe fn decode(
1574 &mut self,
1575 decoder: &mut fidl::encoding::Decoder<'_, D>,
1576 offset: usize,
1577 _depth: fidl::encoding::Depth,
1578 ) -> fidl::Result<()> {
1579 decoder.debug_check_bounds::<Self>(offset);
1580 fidl::decode!(fidl::encoding::Vector<TouchEvent, 128>, D, &mut self.events, decoder, offset + 0, _depth)?;
1582 Ok(())
1583 }
1584 }
1585
1586 impl fidl::encoding::ValueTypeMarker for ViewParameters {
1587 type Borrowed<'a> = &'a Self;
1588 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1589 value
1590 }
1591 }
1592
1593 unsafe impl fidl::encoding::TypeMarker for ViewParameters {
1594 type Owned = Self;
1595
1596 #[inline(always)]
1597 fn inline_align(_context: fidl::encoding::Context) -> usize {
1598 4
1599 }
1600
1601 #[inline(always)]
1602 fn inline_size(_context: fidl::encoding::Context) -> usize {
1603 68
1604 }
1605 }
1606
1607 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ViewParameters, D>
1608 for &ViewParameters
1609 {
1610 #[inline]
1611 unsafe fn encode(
1612 self,
1613 encoder: &mut fidl::encoding::Encoder<'_, D>,
1614 offset: usize,
1615 _depth: fidl::encoding::Depth,
1616 ) -> fidl::Result<()> {
1617 encoder.debug_check_bounds::<ViewParameters>(offset);
1618 fidl::encoding::Encode::<ViewParameters, D>::encode(
1620 (
1621 <Rectangle as fidl::encoding::ValueTypeMarker>::borrow(&self.view),
1622 <Rectangle as fidl::encoding::ValueTypeMarker>::borrow(&self.viewport),
1623 <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow(
1624 &self.viewport_to_view_transform,
1625 ),
1626 ),
1627 encoder,
1628 offset,
1629 _depth,
1630 )
1631 }
1632 }
1633 unsafe impl<
1634 D: fidl::encoding::ResourceDialect,
1635 T0: fidl::encoding::Encode<Rectangle, D>,
1636 T1: fidl::encoding::Encode<Rectangle, D>,
1637 T2: fidl::encoding::Encode<fidl::encoding::Array<f32, 9>, D>,
1638 > fidl::encoding::Encode<ViewParameters, D> for (T0, T1, T2)
1639 {
1640 #[inline]
1641 unsafe fn encode(
1642 self,
1643 encoder: &mut fidl::encoding::Encoder<'_, D>,
1644 offset: usize,
1645 depth: fidl::encoding::Depth,
1646 ) -> fidl::Result<()> {
1647 encoder.debug_check_bounds::<ViewParameters>(offset);
1648 self.0.encode(encoder, offset + 0, depth)?;
1652 self.1.encode(encoder, offset + 16, depth)?;
1653 self.2.encode(encoder, offset + 32, depth)?;
1654 Ok(())
1655 }
1656 }
1657
1658 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ViewParameters {
1659 #[inline(always)]
1660 fn new_empty() -> Self {
1661 Self {
1662 view: fidl::new_empty!(Rectangle, D),
1663 viewport: fidl::new_empty!(Rectangle, D),
1664 viewport_to_view_transform: fidl::new_empty!(fidl::encoding::Array<f32, 9>, D),
1665 }
1666 }
1667
1668 #[inline]
1669 unsafe fn decode(
1670 &mut self,
1671 decoder: &mut fidl::encoding::Decoder<'_, D>,
1672 offset: usize,
1673 _depth: fidl::encoding::Depth,
1674 ) -> fidl::Result<()> {
1675 decoder.debug_check_bounds::<Self>(offset);
1676 fidl::decode!(Rectangle, D, &mut self.view, decoder, offset + 0, _depth)?;
1678 fidl::decode!(Rectangle, D, &mut self.viewport, decoder, offset + 16, _depth)?;
1679 fidl::decode!(fidl::encoding::Array<f32, 9>, D, &mut self.viewport_to_view_transform, decoder, offset + 32, _depth)?;
1680 Ok(())
1681 }
1682 }
1683
1684 impl MouseDeviceInfo {
1685 #[inline(always)]
1686 fn max_ordinal_present(&self) -> u64 {
1687 if let Some(_) = self.relative_motion_range {
1688 return 5;
1689 }
1690 if let Some(_) = self.buttons {
1691 return 4;
1692 }
1693 if let Some(_) = self.scroll_h_range {
1694 return 3;
1695 }
1696 if let Some(_) = self.scroll_v_range {
1697 return 2;
1698 }
1699 if let Some(_) = self.id {
1700 return 1;
1701 }
1702 0
1703 }
1704 }
1705
1706 impl fidl::encoding::ValueTypeMarker for MouseDeviceInfo {
1707 type Borrowed<'a> = &'a Self;
1708 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1709 value
1710 }
1711 }
1712
1713 unsafe impl fidl::encoding::TypeMarker for MouseDeviceInfo {
1714 type Owned = Self;
1715
1716 #[inline(always)]
1717 fn inline_align(_context: fidl::encoding::Context) -> usize {
1718 8
1719 }
1720
1721 #[inline(always)]
1722 fn inline_size(_context: fidl::encoding::Context) -> usize {
1723 16
1724 }
1725 }
1726
1727 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseDeviceInfo, D>
1728 for &MouseDeviceInfo
1729 {
1730 unsafe fn encode(
1731 self,
1732 encoder: &mut fidl::encoding::Encoder<'_, D>,
1733 offset: usize,
1734 mut depth: fidl::encoding::Depth,
1735 ) -> fidl::Result<()> {
1736 encoder.debug_check_bounds::<MouseDeviceInfo>(offset);
1737 let max_ordinal: u64 = self.max_ordinal_present();
1739 encoder.write_num(max_ordinal, offset);
1740 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1741 if max_ordinal == 0 {
1743 return Ok(());
1744 }
1745 depth.increment()?;
1746 let envelope_size = 8;
1747 let bytes_len = max_ordinal as usize * envelope_size;
1748 #[allow(unused_variables)]
1749 let offset = encoder.out_of_line_offset(bytes_len);
1750 let mut _prev_end_offset: usize = 0;
1751 if 1 > max_ordinal {
1752 return Ok(());
1753 }
1754
1755 let cur_offset: usize = (1 - 1) * envelope_size;
1758
1759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1761
1762 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1767 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1768 encoder,
1769 offset + cur_offset,
1770 depth,
1771 )?;
1772
1773 _prev_end_offset = cur_offset + envelope_size;
1774 if 2 > max_ordinal {
1775 return Ok(());
1776 }
1777
1778 let cur_offset: usize = (2 - 1) * envelope_size;
1781
1782 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1784
1785 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_input_report__common::Axis, D>(
1790 self.scroll_v_range.as_ref().map(<fidl_fuchsia_input_report__common::Axis as fidl::encoding::ValueTypeMarker>::borrow),
1791 encoder, offset + cur_offset, depth
1792 )?;
1793
1794 _prev_end_offset = cur_offset + envelope_size;
1795 if 3 > max_ordinal {
1796 return Ok(());
1797 }
1798
1799 let cur_offset: usize = (3 - 1) * envelope_size;
1802
1803 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1805
1806 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_input_report__common::Axis, D>(
1811 self.scroll_h_range.as_ref().map(<fidl_fuchsia_input_report__common::Axis as fidl::encoding::ValueTypeMarker>::borrow),
1812 encoder, offset + cur_offset, depth
1813 )?;
1814
1815 _prev_end_offset = cur_offset + envelope_size;
1816 if 4 > max_ordinal {
1817 return Ok(());
1818 }
1819
1820 let cur_offset: usize = (4 - 1) * envelope_size;
1823
1824 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1826
1827 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
1832 self.buttons.as_ref().map(
1833 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
1834 ),
1835 encoder,
1836 offset + cur_offset,
1837 depth,
1838 )?;
1839
1840 _prev_end_offset = cur_offset + envelope_size;
1841 if 5 > max_ordinal {
1842 return Ok(());
1843 }
1844
1845 let cur_offset: usize = (5 - 1) * envelope_size;
1848
1849 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1851
1852 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D>(
1857 self.relative_motion_range.as_ref().map(<fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2> as fidl::encoding::ValueTypeMarker>::borrow),
1858 encoder, offset + cur_offset, depth
1859 )?;
1860
1861 _prev_end_offset = cur_offset + envelope_size;
1862
1863 Ok(())
1864 }
1865 }
1866
1867 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseDeviceInfo {
1868 #[inline(always)]
1869 fn new_empty() -> Self {
1870 Self::default()
1871 }
1872
1873 unsafe fn decode(
1874 &mut self,
1875 decoder: &mut fidl::encoding::Decoder<'_, D>,
1876 offset: usize,
1877 mut depth: fidl::encoding::Depth,
1878 ) -> fidl::Result<()> {
1879 decoder.debug_check_bounds::<Self>(offset);
1880 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1881 None => return Err(fidl::Error::NotNullable),
1882 Some(len) => len,
1883 };
1884 if len == 0 {
1886 return Ok(());
1887 };
1888 depth.increment()?;
1889 let envelope_size = 8;
1890 let bytes_len = len * envelope_size;
1891 let offset = decoder.out_of_line_offset(bytes_len)?;
1892 let mut _next_ordinal_to_read = 0;
1894 let mut next_offset = offset;
1895 let end_offset = offset + bytes_len;
1896 _next_ordinal_to_read += 1;
1897 if next_offset >= end_offset {
1898 return Ok(());
1899 }
1900
1901 while _next_ordinal_to_read < 1 {
1903 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1904 _next_ordinal_to_read += 1;
1905 next_offset += envelope_size;
1906 }
1907
1908 let next_out_of_line = decoder.next_out_of_line();
1909 let handles_before = decoder.remaining_handles();
1910 if let Some((inlined, num_bytes, num_handles)) =
1911 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1912 {
1913 let member_inline_size =
1914 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1915 if inlined != (member_inline_size <= 4) {
1916 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1917 }
1918 let inner_offset;
1919 let mut inner_depth = depth.clone();
1920 if inlined {
1921 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1922 inner_offset = next_offset;
1923 } else {
1924 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1925 inner_depth.increment()?;
1926 }
1927 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1928 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1929 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1930 {
1931 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1932 }
1933 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1934 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1935 }
1936 }
1937
1938 next_offset += envelope_size;
1939 _next_ordinal_to_read += 1;
1940 if next_offset >= end_offset {
1941 return Ok(());
1942 }
1943
1944 while _next_ordinal_to_read < 2 {
1946 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1947 _next_ordinal_to_read += 1;
1948 next_offset += envelope_size;
1949 }
1950
1951 let next_out_of_line = decoder.next_out_of_line();
1952 let handles_before = decoder.remaining_handles();
1953 if let Some((inlined, num_bytes, num_handles)) =
1954 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1955 {
1956 let member_inline_size = <fidl_fuchsia_input_report__common::Axis as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1957 if inlined != (member_inline_size <= 4) {
1958 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1959 }
1960 let inner_offset;
1961 let mut inner_depth = depth.clone();
1962 if inlined {
1963 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1964 inner_offset = next_offset;
1965 } else {
1966 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1967 inner_depth.increment()?;
1968 }
1969 let val_ref = self.scroll_v_range.get_or_insert_with(|| {
1970 fidl::new_empty!(fidl_fuchsia_input_report__common::Axis, D)
1971 });
1972 fidl::decode!(
1973 fidl_fuchsia_input_report__common::Axis,
1974 D,
1975 val_ref,
1976 decoder,
1977 inner_offset,
1978 inner_depth
1979 )?;
1980 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1981 {
1982 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1983 }
1984 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1985 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1986 }
1987 }
1988
1989 next_offset += envelope_size;
1990 _next_ordinal_to_read += 1;
1991 if next_offset >= end_offset {
1992 return Ok(());
1993 }
1994
1995 while _next_ordinal_to_read < 3 {
1997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1998 _next_ordinal_to_read += 1;
1999 next_offset += envelope_size;
2000 }
2001
2002 let next_out_of_line = decoder.next_out_of_line();
2003 let handles_before = decoder.remaining_handles();
2004 if let Some((inlined, num_bytes, num_handles)) =
2005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2006 {
2007 let member_inline_size = <fidl_fuchsia_input_report__common::Axis as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2008 if inlined != (member_inline_size <= 4) {
2009 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2010 }
2011 let inner_offset;
2012 let mut inner_depth = depth.clone();
2013 if inlined {
2014 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2015 inner_offset = next_offset;
2016 } else {
2017 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2018 inner_depth.increment()?;
2019 }
2020 let val_ref = self.scroll_h_range.get_or_insert_with(|| {
2021 fidl::new_empty!(fidl_fuchsia_input_report__common::Axis, D)
2022 });
2023 fidl::decode!(
2024 fidl_fuchsia_input_report__common::Axis,
2025 D,
2026 val_ref,
2027 decoder,
2028 inner_offset,
2029 inner_depth
2030 )?;
2031 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2032 {
2033 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2034 }
2035 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2036 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2037 }
2038 }
2039
2040 next_offset += envelope_size;
2041 _next_ordinal_to_read += 1;
2042 if next_offset >= end_offset {
2043 return Ok(());
2044 }
2045
2046 while _next_ordinal_to_read < 4 {
2048 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2049 _next_ordinal_to_read += 1;
2050 next_offset += envelope_size;
2051 }
2052
2053 let next_out_of_line = decoder.next_out_of_line();
2054 let handles_before = decoder.remaining_handles();
2055 if let Some((inlined, num_bytes, num_handles)) =
2056 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2057 {
2058 let member_inline_size =
2059 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
2060 decoder.context,
2061 );
2062 if inlined != (member_inline_size <= 4) {
2063 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2064 }
2065 let inner_offset;
2066 let mut inner_depth = depth.clone();
2067 if inlined {
2068 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2069 inner_offset = next_offset;
2070 } else {
2071 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2072 inner_depth.increment()?;
2073 }
2074 let val_ref = self
2075 .buttons
2076 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
2077 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
2078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2079 {
2080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2081 }
2082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2084 }
2085 }
2086
2087 next_offset += envelope_size;
2088 _next_ordinal_to_read += 1;
2089 if next_offset >= end_offset {
2090 return Ok(());
2091 }
2092
2093 while _next_ordinal_to_read < 5 {
2095 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2096 _next_ordinal_to_read += 1;
2097 next_offset += envelope_size;
2098 }
2099
2100 let next_out_of_line = decoder.next_out_of_line();
2101 let handles_before = decoder.remaining_handles();
2102 if let Some((inlined, num_bytes, num_handles)) =
2103 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2104 {
2105 let member_inline_size = <fidl::encoding::Array<
2106 fidl_fuchsia_input_report__common::Axis,
2107 2,
2108 > as fidl::encoding::TypeMarker>::inline_size(
2109 decoder.context
2110 );
2111 if inlined != (member_inline_size <= 4) {
2112 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2113 }
2114 let inner_offset;
2115 let mut inner_depth = depth.clone();
2116 if inlined {
2117 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2118 inner_offset = next_offset;
2119 } else {
2120 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2121 inner_depth.increment()?;
2122 }
2123 let val_ref =
2124 self.relative_motion_range.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D));
2125 fidl::decode!(fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
2126 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2127 {
2128 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2129 }
2130 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2131 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2132 }
2133 }
2134
2135 next_offset += envelope_size;
2136
2137 while next_offset < end_offset {
2139 _next_ordinal_to_read += 1;
2140 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2141 next_offset += envelope_size;
2142 }
2143
2144 Ok(())
2145 }
2146 }
2147
2148 impl MouseEvent {
2149 #[inline(always)]
2150 fn max_ordinal_present(&self) -> u64 {
2151 if let Some(_) = self.trace_flow_id {
2152 return 6;
2153 }
2154 if let Some(_) = self.stream_info {
2155 return 5;
2156 }
2157 if let Some(_) = self.pointer_sample {
2158 return 4;
2159 }
2160 if let Some(_) = self.device_info {
2161 return 3;
2162 }
2163 if let Some(_) = self.view_parameters {
2164 return 2;
2165 }
2166 if let Some(_) = self.timestamp {
2167 return 1;
2168 }
2169 0
2170 }
2171 }
2172
2173 impl fidl::encoding::ValueTypeMarker for MouseEvent {
2174 type Borrowed<'a> = &'a Self;
2175 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2176 value
2177 }
2178 }
2179
2180 unsafe impl fidl::encoding::TypeMarker for MouseEvent {
2181 type Owned = Self;
2182
2183 #[inline(always)]
2184 fn inline_align(_context: fidl::encoding::Context) -> usize {
2185 8
2186 }
2187
2188 #[inline(always)]
2189 fn inline_size(_context: fidl::encoding::Context) -> usize {
2190 16
2191 }
2192 }
2193
2194 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseEvent, D>
2195 for &MouseEvent
2196 {
2197 unsafe fn encode(
2198 self,
2199 encoder: &mut fidl::encoding::Encoder<'_, D>,
2200 offset: usize,
2201 mut depth: fidl::encoding::Depth,
2202 ) -> fidl::Result<()> {
2203 encoder.debug_check_bounds::<MouseEvent>(offset);
2204 let max_ordinal: u64 = self.max_ordinal_present();
2206 encoder.write_num(max_ordinal, offset);
2207 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2208 if max_ordinal == 0 {
2210 return Ok(());
2211 }
2212 depth.increment()?;
2213 let envelope_size = 8;
2214 let bytes_len = max_ordinal as usize * envelope_size;
2215 #[allow(unused_variables)]
2216 let offset = encoder.out_of_line_offset(bytes_len);
2217 let mut _prev_end_offset: usize = 0;
2218 if 1 > max_ordinal {
2219 return Ok(());
2220 }
2221
2222 let cur_offset: usize = (1 - 1) * envelope_size;
2225
2226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2228
2229 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2234 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2235 encoder,
2236 offset + cur_offset,
2237 depth,
2238 )?;
2239
2240 _prev_end_offset = cur_offset + envelope_size;
2241 if 2 > max_ordinal {
2242 return Ok(());
2243 }
2244
2245 let cur_offset: usize = (2 - 1) * envelope_size;
2248
2249 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2251
2252 fidl::encoding::encode_in_envelope_optional::<ViewParameters, D>(
2257 self.view_parameters
2258 .as_ref()
2259 .map(<ViewParameters as fidl::encoding::ValueTypeMarker>::borrow),
2260 encoder,
2261 offset + cur_offset,
2262 depth,
2263 )?;
2264
2265 _prev_end_offset = cur_offset + envelope_size;
2266 if 3 > max_ordinal {
2267 return Ok(());
2268 }
2269
2270 let cur_offset: usize = (3 - 1) * envelope_size;
2273
2274 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2276
2277 fidl::encoding::encode_in_envelope_optional::<MouseDeviceInfo, D>(
2282 self.device_info
2283 .as_ref()
2284 .map(<MouseDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow),
2285 encoder,
2286 offset + cur_offset,
2287 depth,
2288 )?;
2289
2290 _prev_end_offset = cur_offset + envelope_size;
2291 if 4 > max_ordinal {
2292 return Ok(());
2293 }
2294
2295 let cur_offset: usize = (4 - 1) * envelope_size;
2298
2299 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2301
2302 fidl::encoding::encode_in_envelope_optional::<MousePointerSample, D>(
2307 self.pointer_sample
2308 .as_ref()
2309 .map(<MousePointerSample as fidl::encoding::ValueTypeMarker>::borrow),
2310 encoder,
2311 offset + cur_offset,
2312 depth,
2313 )?;
2314
2315 _prev_end_offset = cur_offset + envelope_size;
2316 if 5 > max_ordinal {
2317 return Ok(());
2318 }
2319
2320 let cur_offset: usize = (5 - 1) * envelope_size;
2323
2324 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2326
2327 fidl::encoding::encode_in_envelope_optional::<MouseEventStreamInfo, D>(
2332 self.stream_info
2333 .as_ref()
2334 .map(<MouseEventStreamInfo as fidl::encoding::ValueTypeMarker>::borrow),
2335 encoder,
2336 offset + cur_offset,
2337 depth,
2338 )?;
2339
2340 _prev_end_offset = cur_offset + envelope_size;
2341 if 6 > max_ordinal {
2342 return Ok(());
2343 }
2344
2345 let cur_offset: usize = (6 - 1) * envelope_size;
2348
2349 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2351
2352 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2357 self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2358 encoder,
2359 offset + cur_offset,
2360 depth,
2361 )?;
2362
2363 _prev_end_offset = cur_offset + envelope_size;
2364
2365 Ok(())
2366 }
2367 }
2368
2369 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseEvent {
2370 #[inline(always)]
2371 fn new_empty() -> Self {
2372 Self::default()
2373 }
2374
2375 unsafe fn decode(
2376 &mut self,
2377 decoder: &mut fidl::encoding::Decoder<'_, D>,
2378 offset: usize,
2379 mut depth: fidl::encoding::Depth,
2380 ) -> fidl::Result<()> {
2381 decoder.debug_check_bounds::<Self>(offset);
2382 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2383 None => return Err(fidl::Error::NotNullable),
2384 Some(len) => len,
2385 };
2386 if len == 0 {
2388 return Ok(());
2389 };
2390 depth.increment()?;
2391 let envelope_size = 8;
2392 let bytes_len = len * envelope_size;
2393 let offset = decoder.out_of_line_offset(bytes_len)?;
2394 let mut _next_ordinal_to_read = 0;
2396 let mut next_offset = offset;
2397 let end_offset = offset + bytes_len;
2398 _next_ordinal_to_read += 1;
2399 if next_offset >= end_offset {
2400 return Ok(());
2401 }
2402
2403 while _next_ordinal_to_read < 1 {
2405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2406 _next_ordinal_to_read += 1;
2407 next_offset += envelope_size;
2408 }
2409
2410 let next_out_of_line = decoder.next_out_of_line();
2411 let handles_before = decoder.remaining_handles();
2412 if let Some((inlined, num_bytes, num_handles)) =
2413 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2414 {
2415 let member_inline_size =
2416 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2417 if inlined != (member_inline_size <= 4) {
2418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2419 }
2420 let inner_offset;
2421 let mut inner_depth = depth.clone();
2422 if inlined {
2423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2424 inner_offset = next_offset;
2425 } else {
2426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2427 inner_depth.increment()?;
2428 }
2429 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
2430 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2432 {
2433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2434 }
2435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2437 }
2438 }
2439
2440 next_offset += envelope_size;
2441 _next_ordinal_to_read += 1;
2442 if next_offset >= end_offset {
2443 return Ok(());
2444 }
2445
2446 while _next_ordinal_to_read < 2 {
2448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2449 _next_ordinal_to_read += 1;
2450 next_offset += envelope_size;
2451 }
2452
2453 let next_out_of_line = decoder.next_out_of_line();
2454 let handles_before = decoder.remaining_handles();
2455 if let Some((inlined, num_bytes, num_handles)) =
2456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2457 {
2458 let member_inline_size =
2459 <ViewParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2460 if inlined != (member_inline_size <= 4) {
2461 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2462 }
2463 let inner_offset;
2464 let mut inner_depth = depth.clone();
2465 if inlined {
2466 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2467 inner_offset = next_offset;
2468 } else {
2469 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2470 inner_depth.increment()?;
2471 }
2472 let val_ref =
2473 self.view_parameters.get_or_insert_with(|| fidl::new_empty!(ViewParameters, D));
2474 fidl::decode!(ViewParameters, D, val_ref, decoder, inner_offset, inner_depth)?;
2475 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2476 {
2477 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2478 }
2479 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2480 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2481 }
2482 }
2483
2484 next_offset += envelope_size;
2485 _next_ordinal_to_read += 1;
2486 if next_offset >= end_offset {
2487 return Ok(());
2488 }
2489
2490 while _next_ordinal_to_read < 3 {
2492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2493 _next_ordinal_to_read += 1;
2494 next_offset += envelope_size;
2495 }
2496
2497 let next_out_of_line = decoder.next_out_of_line();
2498 let handles_before = decoder.remaining_handles();
2499 if let Some((inlined, num_bytes, num_handles)) =
2500 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2501 {
2502 let member_inline_size =
2503 <MouseDeviceInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2504 if inlined != (member_inline_size <= 4) {
2505 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2506 }
2507 let inner_offset;
2508 let mut inner_depth = depth.clone();
2509 if inlined {
2510 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2511 inner_offset = next_offset;
2512 } else {
2513 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2514 inner_depth.increment()?;
2515 }
2516 let val_ref =
2517 self.device_info.get_or_insert_with(|| fidl::new_empty!(MouseDeviceInfo, D));
2518 fidl::decode!(MouseDeviceInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2519 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2520 {
2521 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2522 }
2523 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2524 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2525 }
2526 }
2527
2528 next_offset += envelope_size;
2529 _next_ordinal_to_read += 1;
2530 if next_offset >= end_offset {
2531 return Ok(());
2532 }
2533
2534 while _next_ordinal_to_read < 4 {
2536 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2537 _next_ordinal_to_read += 1;
2538 next_offset += envelope_size;
2539 }
2540
2541 let next_out_of_line = decoder.next_out_of_line();
2542 let handles_before = decoder.remaining_handles();
2543 if let Some((inlined, num_bytes, num_handles)) =
2544 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2545 {
2546 let member_inline_size =
2547 <MousePointerSample as fidl::encoding::TypeMarker>::inline_size(
2548 decoder.context,
2549 );
2550 if inlined != (member_inline_size <= 4) {
2551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2552 }
2553 let inner_offset;
2554 let mut inner_depth = depth.clone();
2555 if inlined {
2556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2557 inner_offset = next_offset;
2558 } else {
2559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2560 inner_depth.increment()?;
2561 }
2562 let val_ref = self
2563 .pointer_sample
2564 .get_or_insert_with(|| fidl::new_empty!(MousePointerSample, D));
2565 fidl::decode!(MousePointerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
2566 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2567 {
2568 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2569 }
2570 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2571 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2572 }
2573 }
2574
2575 next_offset += envelope_size;
2576 _next_ordinal_to_read += 1;
2577 if next_offset >= end_offset {
2578 return Ok(());
2579 }
2580
2581 while _next_ordinal_to_read < 5 {
2583 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2584 _next_ordinal_to_read += 1;
2585 next_offset += envelope_size;
2586 }
2587
2588 let next_out_of_line = decoder.next_out_of_line();
2589 let handles_before = decoder.remaining_handles();
2590 if let Some((inlined, num_bytes, num_handles)) =
2591 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2592 {
2593 let member_inline_size =
2594 <MouseEventStreamInfo as fidl::encoding::TypeMarker>::inline_size(
2595 decoder.context,
2596 );
2597 if inlined != (member_inline_size <= 4) {
2598 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2599 }
2600 let inner_offset;
2601 let mut inner_depth = depth.clone();
2602 if inlined {
2603 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2604 inner_offset = next_offset;
2605 } else {
2606 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2607 inner_depth.increment()?;
2608 }
2609 let val_ref = self
2610 .stream_info
2611 .get_or_insert_with(|| fidl::new_empty!(MouseEventStreamInfo, D));
2612 fidl::decode!(
2613 MouseEventStreamInfo,
2614 D,
2615 val_ref,
2616 decoder,
2617 inner_offset,
2618 inner_depth
2619 )?;
2620 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2621 {
2622 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2623 }
2624 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2625 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2626 }
2627 }
2628
2629 next_offset += envelope_size;
2630 _next_ordinal_to_read += 1;
2631 if next_offset >= end_offset {
2632 return Ok(());
2633 }
2634
2635 while _next_ordinal_to_read < 6 {
2637 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2638 _next_ordinal_to_read += 1;
2639 next_offset += envelope_size;
2640 }
2641
2642 let next_out_of_line = decoder.next_out_of_line();
2643 let handles_before = decoder.remaining_handles();
2644 if let Some((inlined, num_bytes, num_handles)) =
2645 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2646 {
2647 let member_inline_size =
2648 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2649 if inlined != (member_inline_size <= 4) {
2650 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2651 }
2652 let inner_offset;
2653 let mut inner_depth = depth.clone();
2654 if inlined {
2655 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2656 inner_offset = next_offset;
2657 } else {
2658 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2659 inner_depth.increment()?;
2660 }
2661 let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2662 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2663 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2664 {
2665 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2666 }
2667 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2668 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2669 }
2670 }
2671
2672 next_offset += envelope_size;
2673
2674 while next_offset < end_offset {
2676 _next_ordinal_to_read += 1;
2677 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2678 next_offset += envelope_size;
2679 }
2680
2681 Ok(())
2682 }
2683 }
2684
2685 impl MousePointerSample {
2686 #[inline(always)]
2687 fn max_ordinal_present(&self) -> u64 {
2688 if let Some(_) = self.is_precision_scroll {
2689 return 9;
2690 }
2691 if let Some(_) = self.scroll_h_physical_pixel {
2692 return 8;
2693 }
2694 if let Some(_) = self.scroll_v_physical_pixel {
2695 return 7;
2696 }
2697 if let Some(_) = self.relative_motion {
2698 return 6;
2699 }
2700 if let Some(_) = self.pressed_buttons {
2701 return 5;
2702 }
2703 if let Some(_) = self.scroll_h {
2704 return 4;
2705 }
2706 if let Some(_) = self.scroll_v {
2707 return 3;
2708 }
2709 if let Some(_) = self.position_in_viewport {
2710 return 2;
2711 }
2712 if let Some(_) = self.device_id {
2713 return 1;
2714 }
2715 0
2716 }
2717 }
2718
2719 impl fidl::encoding::ValueTypeMarker for MousePointerSample {
2720 type Borrowed<'a> = &'a Self;
2721 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2722 value
2723 }
2724 }
2725
2726 unsafe impl fidl::encoding::TypeMarker for MousePointerSample {
2727 type Owned = Self;
2728
2729 #[inline(always)]
2730 fn inline_align(_context: fidl::encoding::Context) -> usize {
2731 8
2732 }
2733
2734 #[inline(always)]
2735 fn inline_size(_context: fidl::encoding::Context) -> usize {
2736 16
2737 }
2738 }
2739
2740 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MousePointerSample, D>
2741 for &MousePointerSample
2742 {
2743 unsafe fn encode(
2744 self,
2745 encoder: &mut fidl::encoding::Encoder<'_, D>,
2746 offset: usize,
2747 mut depth: fidl::encoding::Depth,
2748 ) -> fidl::Result<()> {
2749 encoder.debug_check_bounds::<MousePointerSample>(offset);
2750 let max_ordinal: u64 = self.max_ordinal_present();
2752 encoder.write_num(max_ordinal, offset);
2753 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2754 if max_ordinal == 0 {
2756 return Ok(());
2757 }
2758 depth.increment()?;
2759 let envelope_size = 8;
2760 let bytes_len = max_ordinal as usize * envelope_size;
2761 #[allow(unused_variables)]
2762 let offset = encoder.out_of_line_offset(bytes_len);
2763 let mut _prev_end_offset: usize = 0;
2764 if 1 > max_ordinal {
2765 return Ok(());
2766 }
2767
2768 let cur_offset: usize = (1 - 1) * envelope_size;
2771
2772 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2774
2775 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2780 self.device_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2781 encoder,
2782 offset + cur_offset,
2783 depth,
2784 )?;
2785
2786 _prev_end_offset = cur_offset + envelope_size;
2787 if 2 > max_ordinal {
2788 return Ok(());
2789 }
2790
2791 let cur_offset: usize = (2 - 1) * envelope_size;
2794
2795 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2797
2798 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
2803 self.position_in_viewport.as_ref().map(
2804 <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
2805 ),
2806 encoder,
2807 offset + cur_offset,
2808 depth,
2809 )?;
2810
2811 _prev_end_offset = cur_offset + envelope_size;
2812 if 3 > max_ordinal {
2813 return Ok(());
2814 }
2815
2816 let cur_offset: usize = (3 - 1) * envelope_size;
2819
2820 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2822
2823 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2828 self.scroll_v.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2829 encoder,
2830 offset + cur_offset,
2831 depth,
2832 )?;
2833
2834 _prev_end_offset = cur_offset + envelope_size;
2835 if 4 > max_ordinal {
2836 return Ok(());
2837 }
2838
2839 let cur_offset: usize = (4 - 1) * envelope_size;
2842
2843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2845
2846 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2851 self.scroll_h.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2852 encoder,
2853 offset + cur_offset,
2854 depth,
2855 )?;
2856
2857 _prev_end_offset = cur_offset + envelope_size;
2858 if 5 > max_ordinal {
2859 return Ok(());
2860 }
2861
2862 let cur_offset: usize = (5 - 1) * envelope_size;
2865
2866 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2868
2869 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
2874 self.pressed_buttons.as_ref().map(
2875 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
2876 ),
2877 encoder,
2878 offset + cur_offset,
2879 depth,
2880 )?;
2881
2882 _prev_end_offset = cur_offset + envelope_size;
2883 if 6 > max_ordinal {
2884 return Ok(());
2885 }
2886
2887 let cur_offset: usize = (6 - 1) * envelope_size;
2890
2891 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2893
2894 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
2899 self.relative_motion.as_ref().map(
2900 <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
2901 ),
2902 encoder,
2903 offset + cur_offset,
2904 depth,
2905 )?;
2906
2907 _prev_end_offset = cur_offset + envelope_size;
2908 if 7 > max_ordinal {
2909 return Ok(());
2910 }
2911
2912 let cur_offset: usize = (7 - 1) * envelope_size;
2915
2916 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2918
2919 fidl::encoding::encode_in_envelope_optional::<f64, D>(
2924 self.scroll_v_physical_pixel
2925 .as_ref()
2926 .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
2927 encoder,
2928 offset + cur_offset,
2929 depth,
2930 )?;
2931
2932 _prev_end_offset = cur_offset + envelope_size;
2933 if 8 > max_ordinal {
2934 return Ok(());
2935 }
2936
2937 let cur_offset: usize = (8 - 1) * envelope_size;
2940
2941 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2943
2944 fidl::encoding::encode_in_envelope_optional::<f64, D>(
2949 self.scroll_h_physical_pixel
2950 .as_ref()
2951 .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
2952 encoder,
2953 offset + cur_offset,
2954 depth,
2955 )?;
2956
2957 _prev_end_offset = cur_offset + envelope_size;
2958 if 9 > max_ordinal {
2959 return Ok(());
2960 }
2961
2962 let cur_offset: usize = (9 - 1) * envelope_size;
2965
2966 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2968
2969 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2974 self.is_precision_scroll
2975 .as_ref()
2976 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2977 encoder,
2978 offset + cur_offset,
2979 depth,
2980 )?;
2981
2982 _prev_end_offset = cur_offset + envelope_size;
2983
2984 Ok(())
2985 }
2986 }
2987
2988 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MousePointerSample {
2989 #[inline(always)]
2990 fn new_empty() -> Self {
2991 Self::default()
2992 }
2993
2994 unsafe fn decode(
2995 &mut self,
2996 decoder: &mut fidl::encoding::Decoder<'_, D>,
2997 offset: usize,
2998 mut depth: fidl::encoding::Depth,
2999 ) -> fidl::Result<()> {
3000 decoder.debug_check_bounds::<Self>(offset);
3001 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3002 None => return Err(fidl::Error::NotNullable),
3003 Some(len) => len,
3004 };
3005 if len == 0 {
3007 return Ok(());
3008 };
3009 depth.increment()?;
3010 let envelope_size = 8;
3011 let bytes_len = len * envelope_size;
3012 let offset = decoder.out_of_line_offset(bytes_len)?;
3013 let mut _next_ordinal_to_read = 0;
3015 let mut next_offset = offset;
3016 let end_offset = offset + bytes_len;
3017 _next_ordinal_to_read += 1;
3018 if next_offset >= end_offset {
3019 return Ok(());
3020 }
3021
3022 while _next_ordinal_to_read < 1 {
3024 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3025 _next_ordinal_to_read += 1;
3026 next_offset += envelope_size;
3027 }
3028
3029 let next_out_of_line = decoder.next_out_of_line();
3030 let handles_before = decoder.remaining_handles();
3031 if let Some((inlined, num_bytes, num_handles)) =
3032 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3033 {
3034 let member_inline_size =
3035 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3036 if inlined != (member_inline_size <= 4) {
3037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3038 }
3039 let inner_offset;
3040 let mut inner_depth = depth.clone();
3041 if inlined {
3042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3043 inner_offset = next_offset;
3044 } else {
3045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3046 inner_depth.increment()?;
3047 }
3048 let val_ref = self.device_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
3049 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3050 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3051 {
3052 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3053 }
3054 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3055 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3056 }
3057 }
3058
3059 next_offset += envelope_size;
3060 _next_ordinal_to_read += 1;
3061 if next_offset >= end_offset {
3062 return Ok(());
3063 }
3064
3065 while _next_ordinal_to_read < 2 {
3067 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3068 _next_ordinal_to_read += 1;
3069 next_offset += envelope_size;
3070 }
3071
3072 let next_out_of_line = decoder.next_out_of_line();
3073 let handles_before = decoder.remaining_handles();
3074 if let Some((inlined, num_bytes, num_handles)) =
3075 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3076 {
3077 let member_inline_size =
3078 <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
3079 decoder.context,
3080 );
3081 if inlined != (member_inline_size <= 4) {
3082 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3083 }
3084 let inner_offset;
3085 let mut inner_depth = depth.clone();
3086 if inlined {
3087 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3088 inner_offset = next_offset;
3089 } else {
3090 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3091 inner_depth.increment()?;
3092 }
3093 let val_ref = self
3094 .position_in_viewport
3095 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
3096 fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
3097 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3098 {
3099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3100 }
3101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3103 }
3104 }
3105
3106 next_offset += envelope_size;
3107 _next_ordinal_to_read += 1;
3108 if next_offset >= end_offset {
3109 return Ok(());
3110 }
3111
3112 while _next_ordinal_to_read < 3 {
3114 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3115 _next_ordinal_to_read += 1;
3116 next_offset += envelope_size;
3117 }
3118
3119 let next_out_of_line = decoder.next_out_of_line();
3120 let handles_before = decoder.remaining_handles();
3121 if let Some((inlined, num_bytes, num_handles)) =
3122 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3123 {
3124 let member_inline_size =
3125 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3126 if inlined != (member_inline_size <= 4) {
3127 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3128 }
3129 let inner_offset;
3130 let mut inner_depth = depth.clone();
3131 if inlined {
3132 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3133 inner_offset = next_offset;
3134 } else {
3135 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3136 inner_depth.increment()?;
3137 }
3138 let val_ref = self.scroll_v.get_or_insert_with(|| fidl::new_empty!(i64, D));
3139 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3140 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3141 {
3142 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3143 }
3144 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3145 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3146 }
3147 }
3148
3149 next_offset += envelope_size;
3150 _next_ordinal_to_read += 1;
3151 if next_offset >= end_offset {
3152 return Ok(());
3153 }
3154
3155 while _next_ordinal_to_read < 4 {
3157 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3158 _next_ordinal_to_read += 1;
3159 next_offset += envelope_size;
3160 }
3161
3162 let next_out_of_line = decoder.next_out_of_line();
3163 let handles_before = decoder.remaining_handles();
3164 if let Some((inlined, num_bytes, num_handles)) =
3165 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3166 {
3167 let member_inline_size =
3168 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3169 if inlined != (member_inline_size <= 4) {
3170 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3171 }
3172 let inner_offset;
3173 let mut inner_depth = depth.clone();
3174 if inlined {
3175 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3176 inner_offset = next_offset;
3177 } else {
3178 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3179 inner_depth.increment()?;
3180 }
3181 let val_ref = self.scroll_h.get_or_insert_with(|| fidl::new_empty!(i64, D));
3182 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3184 {
3185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3186 }
3187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3189 }
3190 }
3191
3192 next_offset += envelope_size;
3193 _next_ordinal_to_read += 1;
3194 if next_offset >= end_offset {
3195 return Ok(());
3196 }
3197
3198 while _next_ordinal_to_read < 5 {
3200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3201 _next_ordinal_to_read += 1;
3202 next_offset += envelope_size;
3203 }
3204
3205 let next_out_of_line = decoder.next_out_of_line();
3206 let handles_before = decoder.remaining_handles();
3207 if let Some((inlined, num_bytes, num_handles)) =
3208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3209 {
3210 let member_inline_size =
3211 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3212 decoder.context,
3213 );
3214 if inlined != (member_inline_size <= 4) {
3215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3216 }
3217 let inner_offset;
3218 let mut inner_depth = depth.clone();
3219 if inlined {
3220 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3221 inner_offset = next_offset;
3222 } else {
3223 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3224 inner_depth.increment()?;
3225 }
3226 let val_ref = self
3227 .pressed_buttons
3228 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
3229 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3230 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3231 {
3232 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3233 }
3234 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3235 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3236 }
3237 }
3238
3239 next_offset += envelope_size;
3240 _next_ordinal_to_read += 1;
3241 if next_offset >= end_offset {
3242 return Ok(());
3243 }
3244
3245 while _next_ordinal_to_read < 6 {
3247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3248 _next_ordinal_to_read += 1;
3249 next_offset += envelope_size;
3250 }
3251
3252 let next_out_of_line = decoder.next_out_of_line();
3253 let handles_before = decoder.remaining_handles();
3254 if let Some((inlined, num_bytes, num_handles)) =
3255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3256 {
3257 let member_inline_size =
3258 <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
3259 decoder.context,
3260 );
3261 if inlined != (member_inline_size <= 4) {
3262 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3263 }
3264 let inner_offset;
3265 let mut inner_depth = depth.clone();
3266 if inlined {
3267 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3268 inner_offset = next_offset;
3269 } else {
3270 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3271 inner_depth.increment()?;
3272 }
3273 let val_ref = self
3274 .relative_motion
3275 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
3276 fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
3277 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3278 {
3279 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3280 }
3281 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3282 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3283 }
3284 }
3285
3286 next_offset += envelope_size;
3287 _next_ordinal_to_read += 1;
3288 if next_offset >= end_offset {
3289 return Ok(());
3290 }
3291
3292 while _next_ordinal_to_read < 7 {
3294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3295 _next_ordinal_to_read += 1;
3296 next_offset += envelope_size;
3297 }
3298
3299 let next_out_of_line = decoder.next_out_of_line();
3300 let handles_before = decoder.remaining_handles();
3301 if let Some((inlined, num_bytes, num_handles)) =
3302 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3303 {
3304 let member_inline_size =
3305 <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3306 if inlined != (member_inline_size <= 4) {
3307 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3308 }
3309 let inner_offset;
3310 let mut inner_depth = depth.clone();
3311 if inlined {
3312 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3313 inner_offset = next_offset;
3314 } else {
3315 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3316 inner_depth.increment()?;
3317 }
3318 let val_ref =
3319 self.scroll_v_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
3320 fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
3321 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3322 {
3323 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3324 }
3325 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3326 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3327 }
3328 }
3329
3330 next_offset += envelope_size;
3331 _next_ordinal_to_read += 1;
3332 if next_offset >= end_offset {
3333 return Ok(());
3334 }
3335
3336 while _next_ordinal_to_read < 8 {
3338 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3339 _next_ordinal_to_read += 1;
3340 next_offset += envelope_size;
3341 }
3342
3343 let next_out_of_line = decoder.next_out_of_line();
3344 let handles_before = decoder.remaining_handles();
3345 if let Some((inlined, num_bytes, num_handles)) =
3346 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3347 {
3348 let member_inline_size =
3349 <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3350 if inlined != (member_inline_size <= 4) {
3351 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3352 }
3353 let inner_offset;
3354 let mut inner_depth = depth.clone();
3355 if inlined {
3356 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3357 inner_offset = next_offset;
3358 } else {
3359 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3360 inner_depth.increment()?;
3361 }
3362 let val_ref =
3363 self.scroll_h_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
3364 fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
3365 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3366 {
3367 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3368 }
3369 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3370 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3371 }
3372 }
3373
3374 next_offset += envelope_size;
3375 _next_ordinal_to_read += 1;
3376 if next_offset >= end_offset {
3377 return Ok(());
3378 }
3379
3380 while _next_ordinal_to_read < 9 {
3382 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3383 _next_ordinal_to_read += 1;
3384 next_offset += envelope_size;
3385 }
3386
3387 let next_out_of_line = decoder.next_out_of_line();
3388 let handles_before = decoder.remaining_handles();
3389 if let Some((inlined, num_bytes, num_handles)) =
3390 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3391 {
3392 let member_inline_size =
3393 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3394 if inlined != (member_inline_size <= 4) {
3395 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3396 }
3397 let inner_offset;
3398 let mut inner_depth = depth.clone();
3399 if inlined {
3400 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3401 inner_offset = next_offset;
3402 } else {
3403 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3404 inner_depth.increment()?;
3405 }
3406 let val_ref =
3407 self.is_precision_scroll.get_or_insert_with(|| fidl::new_empty!(bool, D));
3408 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3409 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3410 {
3411 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3412 }
3413 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3414 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3415 }
3416 }
3417
3418 next_offset += envelope_size;
3419
3420 while next_offset < end_offset {
3422 _next_ordinal_to_read += 1;
3423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3424 next_offset += envelope_size;
3425 }
3426
3427 Ok(())
3428 }
3429 }
3430
3431 impl TouchDeviceInfo {
3432 #[inline(always)]
3433 fn max_ordinal_present(&self) -> u64 {
3434 if let Some(_) = self.id {
3435 return 1;
3436 }
3437 0
3438 }
3439 }
3440
3441 impl fidl::encoding::ValueTypeMarker for TouchDeviceInfo {
3442 type Borrowed<'a> = &'a Self;
3443 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3444 value
3445 }
3446 }
3447
3448 unsafe impl fidl::encoding::TypeMarker for TouchDeviceInfo {
3449 type Owned = Self;
3450
3451 #[inline(always)]
3452 fn inline_align(_context: fidl::encoding::Context) -> usize {
3453 8
3454 }
3455
3456 #[inline(always)]
3457 fn inline_size(_context: fidl::encoding::Context) -> usize {
3458 16
3459 }
3460 }
3461
3462 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchDeviceInfo, D>
3463 for &TouchDeviceInfo
3464 {
3465 unsafe fn encode(
3466 self,
3467 encoder: &mut fidl::encoding::Encoder<'_, D>,
3468 offset: usize,
3469 mut depth: fidl::encoding::Depth,
3470 ) -> fidl::Result<()> {
3471 encoder.debug_check_bounds::<TouchDeviceInfo>(offset);
3472 let max_ordinal: u64 = self.max_ordinal_present();
3474 encoder.write_num(max_ordinal, offset);
3475 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3476 if max_ordinal == 0 {
3478 return Ok(());
3479 }
3480 depth.increment()?;
3481 let envelope_size = 8;
3482 let bytes_len = max_ordinal as usize * envelope_size;
3483 #[allow(unused_variables)]
3484 let offset = encoder.out_of_line_offset(bytes_len);
3485 let mut _prev_end_offset: usize = 0;
3486 if 1 > max_ordinal {
3487 return Ok(());
3488 }
3489
3490 let cur_offset: usize = (1 - 1) * envelope_size;
3493
3494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3496
3497 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3502 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3503 encoder,
3504 offset + cur_offset,
3505 depth,
3506 )?;
3507
3508 _prev_end_offset = cur_offset + envelope_size;
3509
3510 Ok(())
3511 }
3512 }
3513
3514 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchDeviceInfo {
3515 #[inline(always)]
3516 fn new_empty() -> Self {
3517 Self::default()
3518 }
3519
3520 unsafe fn decode(
3521 &mut self,
3522 decoder: &mut fidl::encoding::Decoder<'_, D>,
3523 offset: usize,
3524 mut depth: fidl::encoding::Depth,
3525 ) -> fidl::Result<()> {
3526 decoder.debug_check_bounds::<Self>(offset);
3527 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3528 None => return Err(fidl::Error::NotNullable),
3529 Some(len) => len,
3530 };
3531 if len == 0 {
3533 return Ok(());
3534 };
3535 depth.increment()?;
3536 let envelope_size = 8;
3537 let bytes_len = len * envelope_size;
3538 let offset = decoder.out_of_line_offset(bytes_len)?;
3539 let mut _next_ordinal_to_read = 0;
3541 let mut next_offset = offset;
3542 let end_offset = offset + bytes_len;
3543 _next_ordinal_to_read += 1;
3544 if next_offset >= end_offset {
3545 return Ok(());
3546 }
3547
3548 while _next_ordinal_to_read < 1 {
3550 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3551 _next_ordinal_to_read += 1;
3552 next_offset += envelope_size;
3553 }
3554
3555 let next_out_of_line = decoder.next_out_of_line();
3556 let handles_before = decoder.remaining_handles();
3557 if let Some((inlined, num_bytes, num_handles)) =
3558 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3559 {
3560 let member_inline_size =
3561 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3562 if inlined != (member_inline_size <= 4) {
3563 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3564 }
3565 let inner_offset;
3566 let mut inner_depth = depth.clone();
3567 if inlined {
3568 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3569 inner_offset = next_offset;
3570 } else {
3571 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3572 inner_depth.increment()?;
3573 }
3574 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
3575 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3576 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3577 {
3578 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3579 }
3580 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3581 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3582 }
3583 }
3584
3585 next_offset += envelope_size;
3586
3587 while next_offset < end_offset {
3589 _next_ordinal_to_read += 1;
3590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3591 next_offset += envelope_size;
3592 }
3593
3594 Ok(())
3595 }
3596 }
3597
3598 impl TouchEvent {
3599 #[inline(always)]
3600 fn max_ordinal_present(&self) -> u64 {
3601 if let Some(_) = self.trace_flow_id {
3602 return 6;
3603 }
3604 if let Some(_) = self.interaction_result {
3605 return 5;
3606 }
3607 if let Some(_) = self.pointer_sample {
3608 return 4;
3609 }
3610 if let Some(_) = self.device_info {
3611 return 3;
3612 }
3613 if let Some(_) = self.view_parameters {
3614 return 2;
3615 }
3616 if let Some(_) = self.timestamp {
3617 return 1;
3618 }
3619 0
3620 }
3621 }
3622
3623 impl fidl::encoding::ValueTypeMarker for TouchEvent {
3624 type Borrowed<'a> = &'a Self;
3625 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3626 value
3627 }
3628 }
3629
3630 unsafe impl fidl::encoding::TypeMarker for TouchEvent {
3631 type Owned = Self;
3632
3633 #[inline(always)]
3634 fn inline_align(_context: fidl::encoding::Context) -> usize {
3635 8
3636 }
3637
3638 #[inline(always)]
3639 fn inline_size(_context: fidl::encoding::Context) -> usize {
3640 16
3641 }
3642 }
3643
3644 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchEvent, D>
3645 for &TouchEvent
3646 {
3647 unsafe fn encode(
3648 self,
3649 encoder: &mut fidl::encoding::Encoder<'_, D>,
3650 offset: usize,
3651 mut depth: fidl::encoding::Depth,
3652 ) -> fidl::Result<()> {
3653 encoder.debug_check_bounds::<TouchEvent>(offset);
3654 let max_ordinal: u64 = self.max_ordinal_present();
3656 encoder.write_num(max_ordinal, offset);
3657 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3658 if max_ordinal == 0 {
3660 return Ok(());
3661 }
3662 depth.increment()?;
3663 let envelope_size = 8;
3664 let bytes_len = max_ordinal as usize * envelope_size;
3665 #[allow(unused_variables)]
3666 let offset = encoder.out_of_line_offset(bytes_len);
3667 let mut _prev_end_offset: usize = 0;
3668 if 1 > max_ordinal {
3669 return Ok(());
3670 }
3671
3672 let cur_offset: usize = (1 - 1) * envelope_size;
3675
3676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3678
3679 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3684 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3685 encoder,
3686 offset + cur_offset,
3687 depth,
3688 )?;
3689
3690 _prev_end_offset = cur_offset + envelope_size;
3691 if 2 > max_ordinal {
3692 return Ok(());
3693 }
3694
3695 let cur_offset: usize = (2 - 1) * envelope_size;
3698
3699 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3701
3702 fidl::encoding::encode_in_envelope_optional::<ViewParameters, D>(
3707 self.view_parameters
3708 .as_ref()
3709 .map(<ViewParameters as fidl::encoding::ValueTypeMarker>::borrow),
3710 encoder,
3711 offset + cur_offset,
3712 depth,
3713 )?;
3714
3715 _prev_end_offset = cur_offset + envelope_size;
3716 if 3 > max_ordinal {
3717 return Ok(());
3718 }
3719
3720 let cur_offset: usize = (3 - 1) * envelope_size;
3723
3724 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3726
3727 fidl::encoding::encode_in_envelope_optional::<TouchDeviceInfo, D>(
3732 self.device_info
3733 .as_ref()
3734 .map(<TouchDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow),
3735 encoder,
3736 offset + cur_offset,
3737 depth,
3738 )?;
3739
3740 _prev_end_offset = cur_offset + envelope_size;
3741 if 4 > max_ordinal {
3742 return Ok(());
3743 }
3744
3745 let cur_offset: usize = (4 - 1) * envelope_size;
3748
3749 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3751
3752 fidl::encoding::encode_in_envelope_optional::<TouchPointerSample, D>(
3757 self.pointer_sample
3758 .as_ref()
3759 .map(<TouchPointerSample as fidl::encoding::ValueTypeMarker>::borrow),
3760 encoder,
3761 offset + cur_offset,
3762 depth,
3763 )?;
3764
3765 _prev_end_offset = cur_offset + envelope_size;
3766 if 5 > max_ordinal {
3767 return Ok(());
3768 }
3769
3770 let cur_offset: usize = (5 - 1) * envelope_size;
3773
3774 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3776
3777 fidl::encoding::encode_in_envelope_optional::<TouchInteractionResult, D>(
3782 self.interaction_result
3783 .as_ref()
3784 .map(<TouchInteractionResult as fidl::encoding::ValueTypeMarker>::borrow),
3785 encoder,
3786 offset + cur_offset,
3787 depth,
3788 )?;
3789
3790 _prev_end_offset = cur_offset + envelope_size;
3791 if 6 > max_ordinal {
3792 return Ok(());
3793 }
3794
3795 let cur_offset: usize = (6 - 1) * envelope_size;
3798
3799 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3801
3802 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3807 self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3808 encoder,
3809 offset + cur_offset,
3810 depth,
3811 )?;
3812
3813 _prev_end_offset = cur_offset + envelope_size;
3814
3815 Ok(())
3816 }
3817 }
3818
3819 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchEvent {
3820 #[inline(always)]
3821 fn new_empty() -> Self {
3822 Self::default()
3823 }
3824
3825 unsafe fn decode(
3826 &mut self,
3827 decoder: &mut fidl::encoding::Decoder<'_, D>,
3828 offset: usize,
3829 mut depth: fidl::encoding::Depth,
3830 ) -> fidl::Result<()> {
3831 decoder.debug_check_bounds::<Self>(offset);
3832 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3833 None => return Err(fidl::Error::NotNullable),
3834 Some(len) => len,
3835 };
3836 if len == 0 {
3838 return Ok(());
3839 };
3840 depth.increment()?;
3841 let envelope_size = 8;
3842 let bytes_len = len * envelope_size;
3843 let offset = decoder.out_of_line_offset(bytes_len)?;
3844 let mut _next_ordinal_to_read = 0;
3846 let mut next_offset = offset;
3847 let end_offset = offset + bytes_len;
3848 _next_ordinal_to_read += 1;
3849 if next_offset >= end_offset {
3850 return Ok(());
3851 }
3852
3853 while _next_ordinal_to_read < 1 {
3855 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3856 _next_ordinal_to_read += 1;
3857 next_offset += envelope_size;
3858 }
3859
3860 let next_out_of_line = decoder.next_out_of_line();
3861 let handles_before = decoder.remaining_handles();
3862 if let Some((inlined, num_bytes, num_handles)) =
3863 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3864 {
3865 let member_inline_size =
3866 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3867 if inlined != (member_inline_size <= 4) {
3868 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3869 }
3870 let inner_offset;
3871 let mut inner_depth = depth.clone();
3872 if inlined {
3873 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3874 inner_offset = next_offset;
3875 } else {
3876 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3877 inner_depth.increment()?;
3878 }
3879 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
3880 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3881 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3882 {
3883 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3884 }
3885 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3886 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3887 }
3888 }
3889
3890 next_offset += envelope_size;
3891 _next_ordinal_to_read += 1;
3892 if next_offset >= end_offset {
3893 return Ok(());
3894 }
3895
3896 while _next_ordinal_to_read < 2 {
3898 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3899 _next_ordinal_to_read += 1;
3900 next_offset += envelope_size;
3901 }
3902
3903 let next_out_of_line = decoder.next_out_of_line();
3904 let handles_before = decoder.remaining_handles();
3905 if let Some((inlined, num_bytes, num_handles)) =
3906 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3907 {
3908 let member_inline_size =
3909 <ViewParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3910 if inlined != (member_inline_size <= 4) {
3911 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3912 }
3913 let inner_offset;
3914 let mut inner_depth = depth.clone();
3915 if inlined {
3916 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3917 inner_offset = next_offset;
3918 } else {
3919 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3920 inner_depth.increment()?;
3921 }
3922 let val_ref =
3923 self.view_parameters.get_or_insert_with(|| fidl::new_empty!(ViewParameters, D));
3924 fidl::decode!(ViewParameters, D, val_ref, decoder, inner_offset, inner_depth)?;
3925 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3926 {
3927 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3928 }
3929 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3930 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3931 }
3932 }
3933
3934 next_offset += envelope_size;
3935 _next_ordinal_to_read += 1;
3936 if next_offset >= end_offset {
3937 return Ok(());
3938 }
3939
3940 while _next_ordinal_to_read < 3 {
3942 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3943 _next_ordinal_to_read += 1;
3944 next_offset += envelope_size;
3945 }
3946
3947 let next_out_of_line = decoder.next_out_of_line();
3948 let handles_before = decoder.remaining_handles();
3949 if let Some((inlined, num_bytes, num_handles)) =
3950 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3951 {
3952 let member_inline_size =
3953 <TouchDeviceInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3954 if inlined != (member_inline_size <= 4) {
3955 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3956 }
3957 let inner_offset;
3958 let mut inner_depth = depth.clone();
3959 if inlined {
3960 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3961 inner_offset = next_offset;
3962 } else {
3963 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3964 inner_depth.increment()?;
3965 }
3966 let val_ref =
3967 self.device_info.get_or_insert_with(|| fidl::new_empty!(TouchDeviceInfo, D));
3968 fidl::decode!(TouchDeviceInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3969 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3970 {
3971 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3972 }
3973 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3974 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3975 }
3976 }
3977
3978 next_offset += envelope_size;
3979 _next_ordinal_to_read += 1;
3980 if next_offset >= end_offset {
3981 return Ok(());
3982 }
3983
3984 while _next_ordinal_to_read < 4 {
3986 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3987 _next_ordinal_to_read += 1;
3988 next_offset += envelope_size;
3989 }
3990
3991 let next_out_of_line = decoder.next_out_of_line();
3992 let handles_before = decoder.remaining_handles();
3993 if let Some((inlined, num_bytes, num_handles)) =
3994 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3995 {
3996 let member_inline_size =
3997 <TouchPointerSample as fidl::encoding::TypeMarker>::inline_size(
3998 decoder.context,
3999 );
4000 if inlined != (member_inline_size <= 4) {
4001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4002 }
4003 let inner_offset;
4004 let mut inner_depth = depth.clone();
4005 if inlined {
4006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4007 inner_offset = next_offset;
4008 } else {
4009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4010 inner_depth.increment()?;
4011 }
4012 let val_ref = self
4013 .pointer_sample
4014 .get_or_insert_with(|| fidl::new_empty!(TouchPointerSample, D));
4015 fidl::decode!(TouchPointerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
4016 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4017 {
4018 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4019 }
4020 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4021 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4022 }
4023 }
4024
4025 next_offset += envelope_size;
4026 _next_ordinal_to_read += 1;
4027 if next_offset >= end_offset {
4028 return Ok(());
4029 }
4030
4031 while _next_ordinal_to_read < 5 {
4033 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4034 _next_ordinal_to_read += 1;
4035 next_offset += envelope_size;
4036 }
4037
4038 let next_out_of_line = decoder.next_out_of_line();
4039 let handles_before = decoder.remaining_handles();
4040 if let Some((inlined, num_bytes, num_handles)) =
4041 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4042 {
4043 let member_inline_size =
4044 <TouchInteractionResult as fidl::encoding::TypeMarker>::inline_size(
4045 decoder.context,
4046 );
4047 if inlined != (member_inline_size <= 4) {
4048 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4049 }
4050 let inner_offset;
4051 let mut inner_depth = depth.clone();
4052 if inlined {
4053 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4054 inner_offset = next_offset;
4055 } else {
4056 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4057 inner_depth.increment()?;
4058 }
4059 let val_ref = self
4060 .interaction_result
4061 .get_or_insert_with(|| fidl::new_empty!(TouchInteractionResult, D));
4062 fidl::decode!(
4063 TouchInteractionResult,
4064 D,
4065 val_ref,
4066 decoder,
4067 inner_offset,
4068 inner_depth
4069 )?;
4070 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4071 {
4072 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4073 }
4074 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4075 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4076 }
4077 }
4078
4079 next_offset += envelope_size;
4080 _next_ordinal_to_read += 1;
4081 if next_offset >= end_offset {
4082 return Ok(());
4083 }
4084
4085 while _next_ordinal_to_read < 6 {
4087 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4088 _next_ordinal_to_read += 1;
4089 next_offset += envelope_size;
4090 }
4091
4092 let next_out_of_line = decoder.next_out_of_line();
4093 let handles_before = decoder.remaining_handles();
4094 if let Some((inlined, num_bytes, num_handles)) =
4095 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4096 {
4097 let member_inline_size =
4098 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4099 if inlined != (member_inline_size <= 4) {
4100 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4101 }
4102 let inner_offset;
4103 let mut inner_depth = depth.clone();
4104 if inlined {
4105 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4106 inner_offset = next_offset;
4107 } else {
4108 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4109 inner_depth.increment()?;
4110 }
4111 let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4112 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4113 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4114 {
4115 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4116 }
4117 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4118 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4119 }
4120 }
4121
4122 next_offset += envelope_size;
4123
4124 while next_offset < end_offset {
4126 _next_ordinal_to_read += 1;
4127 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4128 next_offset += envelope_size;
4129 }
4130
4131 Ok(())
4132 }
4133 }
4134
4135 impl TouchPointerSample {
4136 #[inline(always)]
4137 fn max_ordinal_present(&self) -> u64 {
4138 if let Some(_) = self.position_in_viewport {
4139 return 3;
4140 }
4141 if let Some(_) = self.phase {
4142 return 2;
4143 }
4144 if let Some(_) = self.interaction {
4145 return 1;
4146 }
4147 0
4148 }
4149 }
4150
4151 impl fidl::encoding::ValueTypeMarker for TouchPointerSample {
4152 type Borrowed<'a> = &'a Self;
4153 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4154 value
4155 }
4156 }
4157
4158 unsafe impl fidl::encoding::TypeMarker for TouchPointerSample {
4159 type Owned = Self;
4160
4161 #[inline(always)]
4162 fn inline_align(_context: fidl::encoding::Context) -> usize {
4163 8
4164 }
4165
4166 #[inline(always)]
4167 fn inline_size(_context: fidl::encoding::Context) -> usize {
4168 16
4169 }
4170 }
4171
4172 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchPointerSample, D>
4173 for &TouchPointerSample
4174 {
4175 unsafe fn encode(
4176 self,
4177 encoder: &mut fidl::encoding::Encoder<'_, D>,
4178 offset: usize,
4179 mut depth: fidl::encoding::Depth,
4180 ) -> fidl::Result<()> {
4181 encoder.debug_check_bounds::<TouchPointerSample>(offset);
4182 let max_ordinal: u64 = self.max_ordinal_present();
4184 encoder.write_num(max_ordinal, offset);
4185 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4186 if max_ordinal == 0 {
4188 return Ok(());
4189 }
4190 depth.increment()?;
4191 let envelope_size = 8;
4192 let bytes_len = max_ordinal as usize * envelope_size;
4193 #[allow(unused_variables)]
4194 let offset = encoder.out_of_line_offset(bytes_len);
4195 let mut _prev_end_offset: usize = 0;
4196 if 1 > max_ordinal {
4197 return Ok(());
4198 }
4199
4200 let cur_offset: usize = (1 - 1) * envelope_size;
4203
4204 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4206
4207 fidl::encoding::encode_in_envelope_optional::<TouchInteractionId, D>(
4212 self.interaction
4213 .as_ref()
4214 .map(<TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow),
4215 encoder,
4216 offset + cur_offset,
4217 depth,
4218 )?;
4219
4220 _prev_end_offset = cur_offset + envelope_size;
4221 if 2 > max_ordinal {
4222 return Ok(());
4223 }
4224
4225 let cur_offset: usize = (2 - 1) * envelope_size;
4228
4229 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4231
4232 fidl::encoding::encode_in_envelope_optional::<EventPhase, D>(
4237 self.phase.as_ref().map(<EventPhase as fidl::encoding::ValueTypeMarker>::borrow),
4238 encoder,
4239 offset + cur_offset,
4240 depth,
4241 )?;
4242
4243 _prev_end_offset = cur_offset + envelope_size;
4244 if 3 > max_ordinal {
4245 return Ok(());
4246 }
4247
4248 let cur_offset: usize = (3 - 1) * envelope_size;
4251
4252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4254
4255 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
4260 self.position_in_viewport.as_ref().map(
4261 <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
4262 ),
4263 encoder,
4264 offset + cur_offset,
4265 depth,
4266 )?;
4267
4268 _prev_end_offset = cur_offset + envelope_size;
4269
4270 Ok(())
4271 }
4272 }
4273
4274 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchPointerSample {
4275 #[inline(always)]
4276 fn new_empty() -> Self {
4277 Self::default()
4278 }
4279
4280 unsafe fn decode(
4281 &mut self,
4282 decoder: &mut fidl::encoding::Decoder<'_, D>,
4283 offset: usize,
4284 mut depth: fidl::encoding::Depth,
4285 ) -> fidl::Result<()> {
4286 decoder.debug_check_bounds::<Self>(offset);
4287 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4288 None => return Err(fidl::Error::NotNullable),
4289 Some(len) => len,
4290 };
4291 if len == 0 {
4293 return Ok(());
4294 };
4295 depth.increment()?;
4296 let envelope_size = 8;
4297 let bytes_len = len * envelope_size;
4298 let offset = decoder.out_of_line_offset(bytes_len)?;
4299 let mut _next_ordinal_to_read = 0;
4301 let mut next_offset = offset;
4302 let end_offset = offset + bytes_len;
4303 _next_ordinal_to_read += 1;
4304 if next_offset >= end_offset {
4305 return Ok(());
4306 }
4307
4308 while _next_ordinal_to_read < 1 {
4310 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4311 _next_ordinal_to_read += 1;
4312 next_offset += envelope_size;
4313 }
4314
4315 let next_out_of_line = decoder.next_out_of_line();
4316 let handles_before = decoder.remaining_handles();
4317 if let Some((inlined, num_bytes, num_handles)) =
4318 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4319 {
4320 let member_inline_size =
4321 <TouchInteractionId as fidl::encoding::TypeMarker>::inline_size(
4322 decoder.context,
4323 );
4324 if inlined != (member_inline_size <= 4) {
4325 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4326 }
4327 let inner_offset;
4328 let mut inner_depth = depth.clone();
4329 if inlined {
4330 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4331 inner_offset = next_offset;
4332 } else {
4333 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4334 inner_depth.increment()?;
4335 }
4336 let val_ref =
4337 self.interaction.get_or_insert_with(|| fidl::new_empty!(TouchInteractionId, D));
4338 fidl::decode!(TouchInteractionId, D, val_ref, decoder, inner_offset, inner_depth)?;
4339 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4340 {
4341 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4342 }
4343 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4344 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4345 }
4346 }
4347
4348 next_offset += envelope_size;
4349 _next_ordinal_to_read += 1;
4350 if next_offset >= end_offset {
4351 return Ok(());
4352 }
4353
4354 while _next_ordinal_to_read < 2 {
4356 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4357 _next_ordinal_to_read += 1;
4358 next_offset += envelope_size;
4359 }
4360
4361 let next_out_of_line = decoder.next_out_of_line();
4362 let handles_before = decoder.remaining_handles();
4363 if let Some((inlined, num_bytes, num_handles)) =
4364 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4365 {
4366 let member_inline_size =
4367 <EventPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4368 if inlined != (member_inline_size <= 4) {
4369 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4370 }
4371 let inner_offset;
4372 let mut inner_depth = depth.clone();
4373 if inlined {
4374 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4375 inner_offset = next_offset;
4376 } else {
4377 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4378 inner_depth.increment()?;
4379 }
4380 let val_ref = self.phase.get_or_insert_with(|| fidl::new_empty!(EventPhase, D));
4381 fidl::decode!(EventPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
4382 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4383 {
4384 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4385 }
4386 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4387 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4388 }
4389 }
4390
4391 next_offset += envelope_size;
4392 _next_ordinal_to_read += 1;
4393 if next_offset >= end_offset {
4394 return Ok(());
4395 }
4396
4397 while _next_ordinal_to_read < 3 {
4399 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4400 _next_ordinal_to_read += 1;
4401 next_offset += envelope_size;
4402 }
4403
4404 let next_out_of_line = decoder.next_out_of_line();
4405 let handles_before = decoder.remaining_handles();
4406 if let Some((inlined, num_bytes, num_handles)) =
4407 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4408 {
4409 let member_inline_size =
4410 <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
4411 decoder.context,
4412 );
4413 if inlined != (member_inline_size <= 4) {
4414 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4415 }
4416 let inner_offset;
4417 let mut inner_depth = depth.clone();
4418 if inlined {
4419 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4420 inner_offset = next_offset;
4421 } else {
4422 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4423 inner_depth.increment()?;
4424 }
4425 let val_ref = self
4426 .position_in_viewport
4427 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
4428 fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
4429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4430 {
4431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4432 }
4433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4435 }
4436 }
4437
4438 next_offset += envelope_size;
4439
4440 while next_offset < end_offset {
4442 _next_ordinal_to_read += 1;
4443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4444 next_offset += envelope_size;
4445 }
4446
4447 Ok(())
4448 }
4449 }
4450
4451 impl TouchResponse {
4452 #[inline(always)]
4453 fn max_ordinal_present(&self) -> u64 {
4454 if let Some(_) = self.trace_flow_id {
4455 return 2;
4456 }
4457 if let Some(_) = self.response_type {
4458 return 1;
4459 }
4460 0
4461 }
4462 }
4463
4464 impl fidl::encoding::ValueTypeMarker for TouchResponse {
4465 type Borrowed<'a> = &'a Self;
4466 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4467 value
4468 }
4469 }
4470
4471 unsafe impl fidl::encoding::TypeMarker for TouchResponse {
4472 type Owned = Self;
4473
4474 #[inline(always)]
4475 fn inline_align(_context: fidl::encoding::Context) -> usize {
4476 8
4477 }
4478
4479 #[inline(always)]
4480 fn inline_size(_context: fidl::encoding::Context) -> usize {
4481 16
4482 }
4483 }
4484
4485 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchResponse, D>
4486 for &TouchResponse
4487 {
4488 unsafe fn encode(
4489 self,
4490 encoder: &mut fidl::encoding::Encoder<'_, D>,
4491 offset: usize,
4492 mut depth: fidl::encoding::Depth,
4493 ) -> fidl::Result<()> {
4494 encoder.debug_check_bounds::<TouchResponse>(offset);
4495 let max_ordinal: u64 = self.max_ordinal_present();
4497 encoder.write_num(max_ordinal, offset);
4498 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4499 if max_ordinal == 0 {
4501 return Ok(());
4502 }
4503 depth.increment()?;
4504 let envelope_size = 8;
4505 let bytes_len = max_ordinal as usize * envelope_size;
4506 #[allow(unused_variables)]
4507 let offset = encoder.out_of_line_offset(bytes_len);
4508 let mut _prev_end_offset: usize = 0;
4509 if 1 > max_ordinal {
4510 return Ok(());
4511 }
4512
4513 let cur_offset: usize = (1 - 1) * envelope_size;
4516
4517 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4519
4520 fidl::encoding::encode_in_envelope_optional::<TouchResponseType, D>(
4525 self.response_type
4526 .as_ref()
4527 .map(<TouchResponseType as fidl::encoding::ValueTypeMarker>::borrow),
4528 encoder,
4529 offset + cur_offset,
4530 depth,
4531 )?;
4532
4533 _prev_end_offset = cur_offset + envelope_size;
4534 if 2 > max_ordinal {
4535 return Ok(());
4536 }
4537
4538 let cur_offset: usize = (2 - 1) * envelope_size;
4541
4542 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4544
4545 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4550 self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4551 encoder,
4552 offset + cur_offset,
4553 depth,
4554 )?;
4555
4556 _prev_end_offset = cur_offset + envelope_size;
4557
4558 Ok(())
4559 }
4560 }
4561
4562 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchResponse {
4563 #[inline(always)]
4564 fn new_empty() -> Self {
4565 Self::default()
4566 }
4567
4568 unsafe fn decode(
4569 &mut self,
4570 decoder: &mut fidl::encoding::Decoder<'_, D>,
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 <TouchResponseType 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
4623 .response_type
4624 .get_or_insert_with(|| fidl::new_empty!(TouchResponseType, D));
4625 fidl::decode!(TouchResponseType, D, val_ref, decoder, inner_offset, inner_depth)?;
4626 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4627 {
4628 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4629 }
4630 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4631 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4632 }
4633 }
4634
4635 next_offset += envelope_size;
4636 _next_ordinal_to_read += 1;
4637 if next_offset >= end_offset {
4638 return Ok(());
4639 }
4640
4641 while _next_ordinal_to_read < 2 {
4643 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4644 _next_ordinal_to_read += 1;
4645 next_offset += envelope_size;
4646 }
4647
4648 let next_out_of_line = decoder.next_out_of_line();
4649 let handles_before = decoder.remaining_handles();
4650 if let Some((inlined, num_bytes, num_handles)) =
4651 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4652 {
4653 let member_inline_size =
4654 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4655 if inlined != (member_inline_size <= 4) {
4656 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4657 }
4658 let inner_offset;
4659 let mut inner_depth = depth.clone();
4660 if inlined {
4661 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4662 inner_offset = next_offset;
4663 } else {
4664 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4665 inner_depth.increment()?;
4666 }
4667 let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4668 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4669 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4670 {
4671 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4672 }
4673 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4674 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4675 }
4676 }
4677
4678 next_offset += envelope_size;
4679
4680 while next_offset < end_offset {
4682 _next_ordinal_to_read += 1;
4683 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4684 next_offset += envelope_size;
4685 }
4686
4687 Ok(())
4688 }
4689 }
4690}