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