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 ReportId = u8;
12
13pub const MAX_DESC_LEN: u16 = 8192;
14
15pub const MAX_REPORT_DATA: u16 = 8192;
16
17pub const MAX_REPORT_LEN: u16 = 8192;
18
19#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u8)]
22pub enum HidBootProtocol {
23 None = 0,
24 Kbd = 1,
25 Pointer = 2,
26 Other = 3,
27}
28
29impl HidBootProtocol {
30 #[inline]
31 pub fn from_primitive(prim: u8) -> Option<Self> {
32 match prim {
33 0 => Some(Self::None),
34 1 => Some(Self::Kbd),
35 2 => Some(Self::Pointer),
36 3 => Some(Self::Other),
37 _ => None,
38 }
39 }
40
41 #[inline]
42 pub const fn into_primitive(self) -> u8 {
43 self as u8
44 }
45}
46
47#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
49#[repr(u8)]
50pub enum HidDescriptorType {
51 Hid = 33,
52 Report = 34,
53 Physical = 35,
54}
55
56impl HidDescriptorType {
57 #[inline]
58 pub fn from_primitive(prim: u8) -> Option<Self> {
59 match prim {
60 33 => Some(Self::Hid),
61 34 => Some(Self::Report),
62 35 => Some(Self::Physical),
63 _ => None,
64 }
65 }
66
67 #[inline]
68 pub const fn into_primitive(self) -> u8 {
69 self as u8
70 }
71}
72
73#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
75#[repr(u8)]
76pub enum HidProtocol {
77 Boot = 0,
78 Report = 1,
79}
80
81impl HidProtocol {
82 #[inline]
83 pub fn from_primitive(prim: u8) -> Option<Self> {
84 match prim {
85 0 => Some(Self::Boot),
86 1 => Some(Self::Report),
87 _ => None,
88 }
89 }
90
91 #[inline]
92 pub const fn into_primitive(self) -> u8 {
93 self as u8
94 }
95}
96
97#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
98#[repr(u8)]
99pub enum ReportType {
100 Input = 1,
101 Output = 2,
102 Feature = 3,
103}
104
105impl ReportType {
106 #[inline]
107 pub fn from_primitive(prim: u8) -> Option<Self> {
108 match prim {
109 1 => Some(Self::Input),
110 2 => Some(Self::Output),
111 3 => Some(Self::Feature),
112 _ => None,
113 }
114 }
115
116 #[inline]
117 pub const fn into_primitive(self) -> u8 {
118 self as u8
119 }
120}
121
122#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
123pub struct HidbusGetDescriptorRequest {
124 pub desc_type: HidDescriptorType,
125}
126
127impl fidl::Persistable for HidbusGetDescriptorRequest {}
128
129#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
130#[repr(C)]
131pub struct HidbusGetIdleRequest {
132 pub rpt_id: u8,
133}
134
135impl fidl::Persistable for HidbusGetIdleRequest {}
136
137#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
138pub struct HidbusGetReportRequest {
139 pub rpt_type: ReportType,
140 pub rpt_id: u8,
141 pub len: u64,
142}
143
144impl fidl::Persistable for HidbusGetReportRequest {}
145
146#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
147pub struct HidbusSetDescriptorRequest {
148 pub desc_type: HidDescriptorType,
149 pub data: Vec<u8>,
150}
151
152impl fidl::Persistable for HidbusSetDescriptorRequest {}
153
154#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155#[repr(C)]
156pub struct HidbusSetIdleRequest {
157 pub rpt_id: u8,
158 pub duration: i64,
159}
160
161impl fidl::Persistable for HidbusSetIdleRequest {}
162
163#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
164pub struct HidbusSetProtocolRequest {
165 pub protocol: HidProtocol,
166}
167
168impl fidl::Persistable for HidbusSetProtocolRequest {}
169
170#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
171pub struct HidbusSetReportRequest {
172 pub rpt_type: ReportType,
173 pub rpt_id: u8,
174 pub data: Vec<u8>,
175}
176
177impl fidl::Persistable for HidbusSetReportRequest {}
178
179#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
180pub struct HidbusGetDescriptorResponse {
181 pub data: Vec<u8>,
182}
183
184impl fidl::Persistable for HidbusGetDescriptorResponse {}
185
186#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
187#[repr(C)]
188pub struct HidbusGetIdleResponse {
189 pub duration: i64,
190}
191
192impl fidl::Persistable for HidbusGetIdleResponse {}
193
194#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
195pub struct HidbusGetProtocolResponse {
196 pub protocol: HidProtocol,
197}
198
199impl fidl::Persistable for HidbusGetProtocolResponse {}
200
201#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
202pub struct HidbusGetReportResponse {
203 pub data: Vec<u8>,
204}
205
206impl fidl::Persistable for HidbusGetReportResponse {}
207
208#[derive(Clone, Debug, PartialEq)]
209pub struct HidbusQueryResponse {
210 pub info: HidInfo,
211}
212
213impl fidl::Persistable for HidbusQueryResponse {}
214
215#[derive(Clone, Debug, Default, PartialEq)]
216pub struct HidInfo {
217 pub dev_num: Option<u8>,
218 pub boot_protocol: Option<HidBootProtocol>,
219 pub vendor_id: Option<u32>,
220 pub product_id: Option<u32>,
221 pub version: Option<u32>,
222 pub polling_rate: Option<i64>,
224 #[doc(hidden)]
225 pub __source_breaking: fidl::marker::SourceBreaking,
226}
227
228impl fidl::Persistable for HidInfo {}
229
230pub mod hidbus_ordinals {
231 pub const QUERY: u64 = 0x23eb61f83d06efa9;
232 pub const START: u64 = 0x1ba15adf96bade4a;
233 pub const STOP: u64 = 0x61b973ecd69cfff8;
234 pub const ON_REPORT_RECEIVED: u64 = 0x6093963f2efe1e56;
235 pub const GET_DESCRIPTOR: u64 = 0x29343a1289ceb2e5;
236 pub const SET_DESCRIPTOR: u64 = 0x7567278eba076777;
237 pub const GET_REPORT: u64 = 0x69b5538a28dc472c;
238 pub const SET_REPORT: u64 = 0x1172863081673c55;
239 pub const GET_IDLE: u64 = 0xa95c2c504d9aa0b;
240 pub const SET_IDLE: u64 = 0x7c387cbaa4c09b3c;
241 pub const GET_PROTOCOL: u64 = 0x3ec61a9b2d5c50eb;
242 pub const SET_PROTOCOL: u64 = 0x1655cdfd0f316b0b;
243}
244
245mod internal {
246 use super::*;
247 unsafe impl fidl::encoding::TypeMarker for HidBootProtocol {
248 type Owned = Self;
249
250 #[inline(always)]
251 fn inline_align(_context: fidl::encoding::Context) -> usize {
252 std::mem::align_of::<u8>()
253 }
254
255 #[inline(always)]
256 fn inline_size(_context: fidl::encoding::Context) -> usize {
257 std::mem::size_of::<u8>()
258 }
259
260 #[inline(always)]
261 fn encode_is_copy() -> bool {
262 true
263 }
264
265 #[inline(always)]
266 fn decode_is_copy() -> bool {
267 false
268 }
269 }
270
271 impl fidl::encoding::ValueTypeMarker for HidBootProtocol {
272 type Borrowed<'a> = Self;
273 #[inline(always)]
274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
275 *value
276 }
277 }
278
279 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
280 for HidBootProtocol
281 {
282 #[inline]
283 unsafe fn encode(
284 self,
285 encoder: &mut fidl::encoding::Encoder<'_, D>,
286 offset: usize,
287 _depth: fidl::encoding::Depth,
288 ) -> fidl::Result<()> {
289 encoder.debug_check_bounds::<Self>(offset);
290 encoder.write_num(self.into_primitive(), offset);
291 Ok(())
292 }
293 }
294
295 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidBootProtocol {
296 #[inline(always)]
297 fn new_empty() -> Self {
298 Self::None
299 }
300
301 #[inline]
302 unsafe fn decode(
303 &mut self,
304 decoder: &mut fidl::encoding::Decoder<'_, D>,
305 offset: usize,
306 _depth: fidl::encoding::Depth,
307 ) -> fidl::Result<()> {
308 decoder.debug_check_bounds::<Self>(offset);
309 let prim = decoder.read_num::<u8>(offset);
310
311 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
312 Ok(())
313 }
314 }
315 unsafe impl fidl::encoding::TypeMarker for HidDescriptorType {
316 type Owned = Self;
317
318 #[inline(always)]
319 fn inline_align(_context: fidl::encoding::Context) -> usize {
320 std::mem::align_of::<u8>()
321 }
322
323 #[inline(always)]
324 fn inline_size(_context: fidl::encoding::Context) -> usize {
325 std::mem::size_of::<u8>()
326 }
327
328 #[inline(always)]
329 fn encode_is_copy() -> bool {
330 true
331 }
332
333 #[inline(always)]
334 fn decode_is_copy() -> bool {
335 false
336 }
337 }
338
339 impl fidl::encoding::ValueTypeMarker for HidDescriptorType {
340 type Borrowed<'a> = Self;
341 #[inline(always)]
342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
343 *value
344 }
345 }
346
347 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
348 for HidDescriptorType
349 {
350 #[inline]
351 unsafe fn encode(
352 self,
353 encoder: &mut fidl::encoding::Encoder<'_, D>,
354 offset: usize,
355 _depth: fidl::encoding::Depth,
356 ) -> fidl::Result<()> {
357 encoder.debug_check_bounds::<Self>(offset);
358 encoder.write_num(self.into_primitive(), offset);
359 Ok(())
360 }
361 }
362
363 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidDescriptorType {
364 #[inline(always)]
365 fn new_empty() -> Self {
366 Self::Hid
367 }
368
369 #[inline]
370 unsafe fn decode(
371 &mut self,
372 decoder: &mut fidl::encoding::Decoder<'_, D>,
373 offset: usize,
374 _depth: fidl::encoding::Depth,
375 ) -> fidl::Result<()> {
376 decoder.debug_check_bounds::<Self>(offset);
377 let prim = decoder.read_num::<u8>(offset);
378
379 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
380 Ok(())
381 }
382 }
383 unsafe impl fidl::encoding::TypeMarker for HidProtocol {
384 type Owned = Self;
385
386 #[inline(always)]
387 fn inline_align(_context: fidl::encoding::Context) -> usize {
388 std::mem::align_of::<u8>()
389 }
390
391 #[inline(always)]
392 fn inline_size(_context: fidl::encoding::Context) -> usize {
393 std::mem::size_of::<u8>()
394 }
395
396 #[inline(always)]
397 fn encode_is_copy() -> bool {
398 true
399 }
400
401 #[inline(always)]
402 fn decode_is_copy() -> bool {
403 false
404 }
405 }
406
407 impl fidl::encoding::ValueTypeMarker for HidProtocol {
408 type Borrowed<'a> = Self;
409 #[inline(always)]
410 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
411 *value
412 }
413 }
414
415 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HidProtocol {
416 #[inline]
417 unsafe fn encode(
418 self,
419 encoder: &mut fidl::encoding::Encoder<'_, D>,
420 offset: usize,
421 _depth: fidl::encoding::Depth,
422 ) -> fidl::Result<()> {
423 encoder.debug_check_bounds::<Self>(offset);
424 encoder.write_num(self.into_primitive(), offset);
425 Ok(())
426 }
427 }
428
429 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidProtocol {
430 #[inline(always)]
431 fn new_empty() -> Self {
432 Self::Boot
433 }
434
435 #[inline]
436 unsafe fn decode(
437 &mut self,
438 decoder: &mut fidl::encoding::Decoder<'_, D>,
439 offset: usize,
440 _depth: fidl::encoding::Depth,
441 ) -> fidl::Result<()> {
442 decoder.debug_check_bounds::<Self>(offset);
443 let prim = decoder.read_num::<u8>(offset);
444
445 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
446 Ok(())
447 }
448 }
449 unsafe impl fidl::encoding::TypeMarker for ReportType {
450 type Owned = Self;
451
452 #[inline(always)]
453 fn inline_align(_context: fidl::encoding::Context) -> usize {
454 std::mem::align_of::<u8>()
455 }
456
457 #[inline(always)]
458 fn inline_size(_context: fidl::encoding::Context) -> usize {
459 std::mem::size_of::<u8>()
460 }
461
462 #[inline(always)]
463 fn encode_is_copy() -> bool {
464 true
465 }
466
467 #[inline(always)]
468 fn decode_is_copy() -> bool {
469 false
470 }
471 }
472
473 impl fidl::encoding::ValueTypeMarker for ReportType {
474 type Borrowed<'a> = Self;
475 #[inline(always)]
476 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
477 *value
478 }
479 }
480
481 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReportType {
482 #[inline]
483 unsafe fn encode(
484 self,
485 encoder: &mut fidl::encoding::Encoder<'_, D>,
486 offset: usize,
487 _depth: fidl::encoding::Depth,
488 ) -> fidl::Result<()> {
489 encoder.debug_check_bounds::<Self>(offset);
490 encoder.write_num(self.into_primitive(), offset);
491 Ok(())
492 }
493 }
494
495 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReportType {
496 #[inline(always)]
497 fn new_empty() -> Self {
498 Self::Input
499 }
500
501 #[inline]
502 unsafe fn decode(
503 &mut self,
504 decoder: &mut fidl::encoding::Decoder<'_, D>,
505 offset: usize,
506 _depth: fidl::encoding::Depth,
507 ) -> fidl::Result<()> {
508 decoder.debug_check_bounds::<Self>(offset);
509 let prim = decoder.read_num::<u8>(offset);
510
511 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
512 Ok(())
513 }
514 }
515
516 impl fidl::encoding::ValueTypeMarker for HidbusGetDescriptorRequest {
517 type Borrowed<'a> = &'a Self;
518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
519 value
520 }
521 }
522
523 unsafe impl fidl::encoding::TypeMarker for HidbusGetDescriptorRequest {
524 type Owned = Self;
525
526 #[inline(always)]
527 fn inline_align(_context: fidl::encoding::Context) -> usize {
528 1
529 }
530
531 #[inline(always)]
532 fn inline_size(_context: fidl::encoding::Context) -> usize {
533 1
534 }
535 }
536
537 unsafe impl<D: fidl::encoding::ResourceDialect>
538 fidl::encoding::Encode<HidbusGetDescriptorRequest, D> for &HidbusGetDescriptorRequest
539 {
540 #[inline]
541 unsafe fn encode(
542 self,
543 encoder: &mut fidl::encoding::Encoder<'_, D>,
544 offset: usize,
545 _depth: fidl::encoding::Depth,
546 ) -> fidl::Result<()> {
547 encoder.debug_check_bounds::<HidbusGetDescriptorRequest>(offset);
548 fidl::encoding::Encode::<HidbusGetDescriptorRequest, D>::encode(
550 (<HidDescriptorType as fidl::encoding::ValueTypeMarker>::borrow(&self.desc_type),),
551 encoder,
552 offset,
553 _depth,
554 )
555 }
556 }
557 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidDescriptorType, D>>
558 fidl::encoding::Encode<HidbusGetDescriptorRequest, D> for (T0,)
559 {
560 #[inline]
561 unsafe fn encode(
562 self,
563 encoder: &mut fidl::encoding::Encoder<'_, D>,
564 offset: usize,
565 depth: fidl::encoding::Depth,
566 ) -> fidl::Result<()> {
567 encoder.debug_check_bounds::<HidbusGetDescriptorRequest>(offset);
568 self.0.encode(encoder, offset + 0, depth)?;
572 Ok(())
573 }
574 }
575
576 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
577 for HidbusGetDescriptorRequest
578 {
579 #[inline(always)]
580 fn new_empty() -> Self {
581 Self { desc_type: fidl::new_empty!(HidDescriptorType, D) }
582 }
583
584 #[inline]
585 unsafe fn decode(
586 &mut self,
587 decoder: &mut fidl::encoding::Decoder<'_, D>,
588 offset: usize,
589 _depth: fidl::encoding::Depth,
590 ) -> fidl::Result<()> {
591 decoder.debug_check_bounds::<Self>(offset);
592 fidl::decode!(HidDescriptorType, D, &mut self.desc_type, decoder, offset + 0, _depth)?;
594 Ok(())
595 }
596 }
597
598 impl fidl::encoding::ValueTypeMarker for HidbusGetIdleRequest {
599 type Borrowed<'a> = &'a Self;
600 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
601 value
602 }
603 }
604
605 unsafe impl fidl::encoding::TypeMarker for HidbusGetIdleRequest {
606 type Owned = Self;
607
608 #[inline(always)]
609 fn inline_align(_context: fidl::encoding::Context) -> usize {
610 1
611 }
612
613 #[inline(always)]
614 fn inline_size(_context: fidl::encoding::Context) -> usize {
615 1
616 }
617 #[inline(always)]
618 fn encode_is_copy() -> bool {
619 true
620 }
621
622 #[inline(always)]
623 fn decode_is_copy() -> bool {
624 true
625 }
626 }
627
628 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusGetIdleRequest, D>
629 for &HidbusGetIdleRequest
630 {
631 #[inline]
632 unsafe fn encode(
633 self,
634 encoder: &mut fidl::encoding::Encoder<'_, D>,
635 offset: usize,
636 _depth: fidl::encoding::Depth,
637 ) -> fidl::Result<()> {
638 encoder.debug_check_bounds::<HidbusGetIdleRequest>(offset);
639 unsafe {
640 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
642 (buf_ptr as *mut HidbusGetIdleRequest)
643 .write_unaligned((self as *const HidbusGetIdleRequest).read());
644 }
647 Ok(())
648 }
649 }
650 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
651 fidl::encoding::Encode<HidbusGetIdleRequest, D> for (T0,)
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::<HidbusGetIdleRequest>(offset);
661 self.0.encode(encoder, offset + 0, depth)?;
665 Ok(())
666 }
667 }
668
669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusGetIdleRequest {
670 #[inline(always)]
671 fn new_empty() -> Self {
672 Self { rpt_id: fidl::new_empty!(u8, D) }
673 }
674
675 #[inline]
676 unsafe fn decode(
677 &mut self,
678 decoder: &mut fidl::encoding::Decoder<'_, D>,
679 offset: usize,
680 _depth: fidl::encoding::Depth,
681 ) -> fidl::Result<()> {
682 decoder.debug_check_bounds::<Self>(offset);
683 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
684 unsafe {
687 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
688 }
689 Ok(())
690 }
691 }
692
693 impl fidl::encoding::ValueTypeMarker for HidbusGetReportRequest {
694 type Borrowed<'a> = &'a Self;
695 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
696 value
697 }
698 }
699
700 unsafe impl fidl::encoding::TypeMarker for HidbusGetReportRequest {
701 type Owned = Self;
702
703 #[inline(always)]
704 fn inline_align(_context: fidl::encoding::Context) -> usize {
705 8
706 }
707
708 #[inline(always)]
709 fn inline_size(_context: fidl::encoding::Context) -> usize {
710 16
711 }
712 }
713
714 unsafe impl<D: fidl::encoding::ResourceDialect>
715 fidl::encoding::Encode<HidbusGetReportRequest, D> for &HidbusGetReportRequest
716 {
717 #[inline]
718 unsafe fn encode(
719 self,
720 encoder: &mut fidl::encoding::Encoder<'_, D>,
721 offset: usize,
722 _depth: fidl::encoding::Depth,
723 ) -> fidl::Result<()> {
724 encoder.debug_check_bounds::<HidbusGetReportRequest>(offset);
725 fidl::encoding::Encode::<HidbusGetReportRequest, D>::encode(
727 (
728 <ReportType as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_type),
729 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_id),
730 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.len),
731 ),
732 encoder,
733 offset,
734 _depth,
735 )
736 }
737 }
738 unsafe impl<
739 D: fidl::encoding::ResourceDialect,
740 T0: fidl::encoding::Encode<ReportType, D>,
741 T1: fidl::encoding::Encode<u8, D>,
742 T2: fidl::encoding::Encode<u64, D>,
743 > fidl::encoding::Encode<HidbusGetReportRequest, D> for (T0, T1, T2)
744 {
745 #[inline]
746 unsafe fn encode(
747 self,
748 encoder: &mut fidl::encoding::Encoder<'_, D>,
749 offset: usize,
750 depth: fidl::encoding::Depth,
751 ) -> fidl::Result<()> {
752 encoder.debug_check_bounds::<HidbusGetReportRequest>(offset);
753 unsafe {
756 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
757 (ptr as *mut u64).write_unaligned(0);
758 }
759 self.0.encode(encoder, offset + 0, depth)?;
761 self.1.encode(encoder, offset + 1, depth)?;
762 self.2.encode(encoder, offset + 8, depth)?;
763 Ok(())
764 }
765 }
766
767 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
768 for HidbusGetReportRequest
769 {
770 #[inline(always)]
771 fn new_empty() -> Self {
772 Self {
773 rpt_type: fidl::new_empty!(ReportType, D),
774 rpt_id: fidl::new_empty!(u8, D),
775 len: fidl::new_empty!(u64, D),
776 }
777 }
778
779 #[inline]
780 unsafe fn decode(
781 &mut self,
782 decoder: &mut fidl::encoding::Decoder<'_, D>,
783 offset: usize,
784 _depth: fidl::encoding::Depth,
785 ) -> fidl::Result<()> {
786 decoder.debug_check_bounds::<Self>(offset);
787 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
789 let padval = unsafe { (ptr as *const u64).read_unaligned() };
790 let mask = 0xffffffffffff0000u64;
791 let maskedval = padval & mask;
792 if maskedval != 0 {
793 return Err(fidl::Error::NonZeroPadding {
794 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
795 });
796 }
797 fidl::decode!(ReportType, D, &mut self.rpt_type, decoder, offset + 0, _depth)?;
798 fidl::decode!(u8, D, &mut self.rpt_id, decoder, offset + 1, _depth)?;
799 fidl::decode!(u64, D, &mut self.len, decoder, offset + 8, _depth)?;
800 Ok(())
801 }
802 }
803
804 impl fidl::encoding::ValueTypeMarker for HidbusSetDescriptorRequest {
805 type Borrowed<'a> = &'a Self;
806 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
807 value
808 }
809 }
810
811 unsafe impl fidl::encoding::TypeMarker for HidbusSetDescriptorRequest {
812 type Owned = Self;
813
814 #[inline(always)]
815 fn inline_align(_context: fidl::encoding::Context) -> usize {
816 8
817 }
818
819 #[inline(always)]
820 fn inline_size(_context: fidl::encoding::Context) -> usize {
821 24
822 }
823 }
824
825 unsafe impl<D: fidl::encoding::ResourceDialect>
826 fidl::encoding::Encode<HidbusSetDescriptorRequest, D> for &HidbusSetDescriptorRequest
827 {
828 #[inline]
829 unsafe fn encode(
830 self,
831 encoder: &mut fidl::encoding::Encoder<'_, D>,
832 offset: usize,
833 _depth: fidl::encoding::Depth,
834 ) -> fidl::Result<()> {
835 encoder.debug_check_bounds::<HidbusSetDescriptorRequest>(offset);
836 fidl::encoding::Encode::<HidbusSetDescriptorRequest, D>::encode(
838 (
839 <HidDescriptorType as fidl::encoding::ValueTypeMarker>::borrow(&self.desc_type),
840 <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
841 &self.data,
842 ),
843 ),
844 encoder,
845 offset,
846 _depth,
847 )
848 }
849 }
850 unsafe impl<
851 D: fidl::encoding::ResourceDialect,
852 T0: fidl::encoding::Encode<HidDescriptorType, D>,
853 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
854 > fidl::encoding::Encode<HidbusSetDescriptorRequest, D> for (T0, T1)
855 {
856 #[inline]
857 unsafe fn encode(
858 self,
859 encoder: &mut fidl::encoding::Encoder<'_, D>,
860 offset: usize,
861 depth: fidl::encoding::Depth,
862 ) -> fidl::Result<()> {
863 encoder.debug_check_bounds::<HidbusSetDescriptorRequest>(offset);
864 unsafe {
867 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
868 (ptr as *mut u64).write_unaligned(0);
869 }
870 self.0.encode(encoder, offset + 0, depth)?;
872 self.1.encode(encoder, offset + 8, depth)?;
873 Ok(())
874 }
875 }
876
877 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
878 for HidbusSetDescriptorRequest
879 {
880 #[inline(always)]
881 fn new_empty() -> Self {
882 Self {
883 desc_type: fidl::new_empty!(HidDescriptorType, D),
884 data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
885 }
886 }
887
888 #[inline]
889 unsafe fn decode(
890 &mut self,
891 decoder: &mut fidl::encoding::Decoder<'_, D>,
892 offset: usize,
893 _depth: fidl::encoding::Depth,
894 ) -> fidl::Result<()> {
895 decoder.debug_check_bounds::<Self>(offset);
896 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
898 let padval = unsafe { (ptr as *const u64).read_unaligned() };
899 let mask = 0xffffffffffffff00u64;
900 let maskedval = padval & mask;
901 if maskedval != 0 {
902 return Err(fidl::Error::NonZeroPadding {
903 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
904 });
905 }
906 fidl::decode!(HidDescriptorType, D, &mut self.desc_type, decoder, offset + 0, _depth)?;
907 fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 8, _depth)?;
908 Ok(())
909 }
910 }
911
912 impl fidl::encoding::ValueTypeMarker for HidbusSetIdleRequest {
913 type Borrowed<'a> = &'a Self;
914 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
915 value
916 }
917 }
918
919 unsafe impl fidl::encoding::TypeMarker for HidbusSetIdleRequest {
920 type Owned = Self;
921
922 #[inline(always)]
923 fn inline_align(_context: fidl::encoding::Context) -> usize {
924 8
925 }
926
927 #[inline(always)]
928 fn inline_size(_context: fidl::encoding::Context) -> usize {
929 16
930 }
931 }
932
933 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusSetIdleRequest, D>
934 for &HidbusSetIdleRequest
935 {
936 #[inline]
937 unsafe fn encode(
938 self,
939 encoder: &mut fidl::encoding::Encoder<'_, D>,
940 offset: usize,
941 _depth: fidl::encoding::Depth,
942 ) -> fidl::Result<()> {
943 encoder.debug_check_bounds::<HidbusSetIdleRequest>(offset);
944 unsafe {
945 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
947 (buf_ptr as *mut HidbusSetIdleRequest)
948 .write_unaligned((self as *const HidbusSetIdleRequest).read());
949 let padding_ptr = buf_ptr.offset(0) as *mut u64;
952 let padding_mask = 0xffffffffffffff00u64;
953 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
954 }
955 Ok(())
956 }
957 }
958 unsafe impl<
959 D: fidl::encoding::ResourceDialect,
960 T0: fidl::encoding::Encode<u8, D>,
961 T1: fidl::encoding::Encode<i64, D>,
962 > fidl::encoding::Encode<HidbusSetIdleRequest, D> for (T0, T1)
963 {
964 #[inline]
965 unsafe fn encode(
966 self,
967 encoder: &mut fidl::encoding::Encoder<'_, D>,
968 offset: usize,
969 depth: fidl::encoding::Depth,
970 ) -> fidl::Result<()> {
971 encoder.debug_check_bounds::<HidbusSetIdleRequest>(offset);
972 unsafe {
975 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
976 (ptr as *mut u64).write_unaligned(0);
977 }
978 self.0.encode(encoder, offset + 0, depth)?;
980 self.1.encode(encoder, offset + 8, depth)?;
981 Ok(())
982 }
983 }
984
985 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusSetIdleRequest {
986 #[inline(always)]
987 fn new_empty() -> Self {
988 Self { rpt_id: fidl::new_empty!(u8, D), duration: fidl::new_empty!(i64, D) }
989 }
990
991 #[inline]
992 unsafe fn decode(
993 &mut self,
994 decoder: &mut fidl::encoding::Decoder<'_, D>,
995 offset: usize,
996 _depth: fidl::encoding::Depth,
997 ) -> fidl::Result<()> {
998 decoder.debug_check_bounds::<Self>(offset);
999 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1000 let ptr = unsafe { buf_ptr.offset(0) };
1002 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1003 let mask = 0xffffffffffffff00u64;
1004 let maskedval = padval & mask;
1005 if maskedval != 0 {
1006 return Err(fidl::Error::NonZeroPadding {
1007 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1008 });
1009 }
1010 unsafe {
1012 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1013 }
1014 Ok(())
1015 }
1016 }
1017
1018 impl fidl::encoding::ValueTypeMarker for HidbusSetProtocolRequest {
1019 type Borrowed<'a> = &'a Self;
1020 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1021 value
1022 }
1023 }
1024
1025 unsafe impl fidl::encoding::TypeMarker for HidbusSetProtocolRequest {
1026 type Owned = Self;
1027
1028 #[inline(always)]
1029 fn inline_align(_context: fidl::encoding::Context) -> usize {
1030 1
1031 }
1032
1033 #[inline(always)]
1034 fn inline_size(_context: fidl::encoding::Context) -> usize {
1035 1
1036 }
1037 }
1038
1039 unsafe impl<D: fidl::encoding::ResourceDialect>
1040 fidl::encoding::Encode<HidbusSetProtocolRequest, D> for &HidbusSetProtocolRequest
1041 {
1042 #[inline]
1043 unsafe fn encode(
1044 self,
1045 encoder: &mut fidl::encoding::Encoder<'_, D>,
1046 offset: usize,
1047 _depth: fidl::encoding::Depth,
1048 ) -> fidl::Result<()> {
1049 encoder.debug_check_bounds::<HidbusSetProtocolRequest>(offset);
1050 fidl::encoding::Encode::<HidbusSetProtocolRequest, D>::encode(
1052 (<HidProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),),
1053 encoder,
1054 offset,
1055 _depth,
1056 )
1057 }
1058 }
1059 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidProtocol, D>>
1060 fidl::encoding::Encode<HidbusSetProtocolRequest, D> for (T0,)
1061 {
1062 #[inline]
1063 unsafe fn encode(
1064 self,
1065 encoder: &mut fidl::encoding::Encoder<'_, D>,
1066 offset: usize,
1067 depth: fidl::encoding::Depth,
1068 ) -> fidl::Result<()> {
1069 encoder.debug_check_bounds::<HidbusSetProtocolRequest>(offset);
1070 self.0.encode(encoder, offset + 0, depth)?;
1074 Ok(())
1075 }
1076 }
1077
1078 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1079 for HidbusSetProtocolRequest
1080 {
1081 #[inline(always)]
1082 fn new_empty() -> Self {
1083 Self { protocol: fidl::new_empty!(HidProtocol, D) }
1084 }
1085
1086 #[inline]
1087 unsafe fn decode(
1088 &mut self,
1089 decoder: &mut fidl::encoding::Decoder<'_, D>,
1090 offset: usize,
1091 _depth: fidl::encoding::Depth,
1092 ) -> fidl::Result<()> {
1093 decoder.debug_check_bounds::<Self>(offset);
1094 fidl::decode!(HidProtocol, D, &mut self.protocol, decoder, offset + 0, _depth)?;
1096 Ok(())
1097 }
1098 }
1099
1100 impl fidl::encoding::ValueTypeMarker for HidbusSetReportRequest {
1101 type Borrowed<'a> = &'a Self;
1102 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1103 value
1104 }
1105 }
1106
1107 unsafe impl fidl::encoding::TypeMarker for HidbusSetReportRequest {
1108 type Owned = Self;
1109
1110 #[inline(always)]
1111 fn inline_align(_context: fidl::encoding::Context) -> usize {
1112 8
1113 }
1114
1115 #[inline(always)]
1116 fn inline_size(_context: fidl::encoding::Context) -> usize {
1117 24
1118 }
1119 }
1120
1121 unsafe impl<D: fidl::encoding::ResourceDialect>
1122 fidl::encoding::Encode<HidbusSetReportRequest, D> for &HidbusSetReportRequest
1123 {
1124 #[inline]
1125 unsafe fn encode(
1126 self,
1127 encoder: &mut fidl::encoding::Encoder<'_, D>,
1128 offset: usize,
1129 _depth: fidl::encoding::Depth,
1130 ) -> fidl::Result<()> {
1131 encoder.debug_check_bounds::<HidbusSetReportRequest>(offset);
1132 fidl::encoding::Encode::<HidbusSetReportRequest, D>::encode(
1134 (
1135 <ReportType as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_type),
1136 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_id),
1137 <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1138 &self.data,
1139 ),
1140 ),
1141 encoder,
1142 offset,
1143 _depth,
1144 )
1145 }
1146 }
1147 unsafe impl<
1148 D: fidl::encoding::ResourceDialect,
1149 T0: fidl::encoding::Encode<ReportType, D>,
1150 T1: fidl::encoding::Encode<u8, D>,
1151 T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1152 > fidl::encoding::Encode<HidbusSetReportRequest, 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::<HidbusSetReportRequest>(offset);
1162 unsafe {
1165 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1166 (ptr as *mut u64).write_unaligned(0);
1167 }
1168 self.0.encode(encoder, offset + 0, depth)?;
1170 self.1.encode(encoder, offset + 1, depth)?;
1171 self.2.encode(encoder, offset + 8, depth)?;
1172 Ok(())
1173 }
1174 }
1175
1176 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1177 for HidbusSetReportRequest
1178 {
1179 #[inline(always)]
1180 fn new_empty() -> Self {
1181 Self {
1182 rpt_type: fidl::new_empty!(ReportType, D),
1183 rpt_id: fidl::new_empty!(u8, D),
1184 data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
1185 }
1186 }
1187
1188 #[inline]
1189 unsafe fn decode(
1190 &mut self,
1191 decoder: &mut fidl::encoding::Decoder<'_, D>,
1192 offset: usize,
1193 _depth: fidl::encoding::Depth,
1194 ) -> fidl::Result<()> {
1195 decoder.debug_check_bounds::<Self>(offset);
1196 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1198 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1199 let mask = 0xffffffffffff0000u64;
1200 let maskedval = padval & mask;
1201 if maskedval != 0 {
1202 return Err(fidl::Error::NonZeroPadding {
1203 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1204 });
1205 }
1206 fidl::decode!(ReportType, D, &mut self.rpt_type, decoder, offset + 0, _depth)?;
1207 fidl::decode!(u8, D, &mut self.rpt_id, decoder, offset + 1, _depth)?;
1208 fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 8, _depth)?;
1209 Ok(())
1210 }
1211 }
1212
1213 impl fidl::encoding::ValueTypeMarker for HidbusGetDescriptorResponse {
1214 type Borrowed<'a> = &'a Self;
1215 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1216 value
1217 }
1218 }
1219
1220 unsafe impl fidl::encoding::TypeMarker for HidbusGetDescriptorResponse {
1221 type Owned = Self;
1222
1223 #[inline(always)]
1224 fn inline_align(_context: fidl::encoding::Context) -> usize {
1225 8
1226 }
1227
1228 #[inline(always)]
1229 fn inline_size(_context: fidl::encoding::Context) -> usize {
1230 16
1231 }
1232 }
1233
1234 unsafe impl<D: fidl::encoding::ResourceDialect>
1235 fidl::encoding::Encode<HidbusGetDescriptorResponse, D> for &HidbusGetDescriptorResponse
1236 {
1237 #[inline]
1238 unsafe fn encode(
1239 self,
1240 encoder: &mut fidl::encoding::Encoder<'_, D>,
1241 offset: usize,
1242 _depth: fidl::encoding::Depth,
1243 ) -> fidl::Result<()> {
1244 encoder.debug_check_bounds::<HidbusGetDescriptorResponse>(offset);
1245 fidl::encoding::Encode::<HidbusGetDescriptorResponse, D>::encode(
1247 (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1248 &self.data,
1249 ),),
1250 encoder,
1251 offset,
1252 _depth,
1253 )
1254 }
1255 }
1256 unsafe impl<
1257 D: fidl::encoding::ResourceDialect,
1258 T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1259 > fidl::encoding::Encode<HidbusGetDescriptorResponse, D> for (T0,)
1260 {
1261 #[inline]
1262 unsafe fn encode(
1263 self,
1264 encoder: &mut fidl::encoding::Encoder<'_, D>,
1265 offset: usize,
1266 depth: fidl::encoding::Depth,
1267 ) -> fidl::Result<()> {
1268 encoder.debug_check_bounds::<HidbusGetDescriptorResponse>(offset);
1269 self.0.encode(encoder, offset + 0, depth)?;
1273 Ok(())
1274 }
1275 }
1276
1277 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1278 for HidbusGetDescriptorResponse
1279 {
1280 #[inline(always)]
1281 fn new_empty() -> Self {
1282 Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
1283 }
1284
1285 #[inline]
1286 unsafe fn decode(
1287 &mut self,
1288 decoder: &mut fidl::encoding::Decoder<'_, D>,
1289 offset: usize,
1290 _depth: fidl::encoding::Depth,
1291 ) -> fidl::Result<()> {
1292 decoder.debug_check_bounds::<Self>(offset);
1293 fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 0, _depth)?;
1295 Ok(())
1296 }
1297 }
1298
1299 impl fidl::encoding::ValueTypeMarker for HidbusGetIdleResponse {
1300 type Borrowed<'a> = &'a Self;
1301 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1302 value
1303 }
1304 }
1305
1306 unsafe impl fidl::encoding::TypeMarker for HidbusGetIdleResponse {
1307 type Owned = Self;
1308
1309 #[inline(always)]
1310 fn inline_align(_context: fidl::encoding::Context) -> usize {
1311 8
1312 }
1313
1314 #[inline(always)]
1315 fn inline_size(_context: fidl::encoding::Context) -> usize {
1316 8
1317 }
1318 #[inline(always)]
1319 fn encode_is_copy() -> bool {
1320 true
1321 }
1322
1323 #[inline(always)]
1324 fn decode_is_copy() -> bool {
1325 true
1326 }
1327 }
1328
1329 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusGetIdleResponse, D>
1330 for &HidbusGetIdleResponse
1331 {
1332 #[inline]
1333 unsafe fn encode(
1334 self,
1335 encoder: &mut fidl::encoding::Encoder<'_, D>,
1336 offset: usize,
1337 _depth: fidl::encoding::Depth,
1338 ) -> fidl::Result<()> {
1339 encoder.debug_check_bounds::<HidbusGetIdleResponse>(offset);
1340 unsafe {
1341 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1343 (buf_ptr as *mut HidbusGetIdleResponse)
1344 .write_unaligned((self as *const HidbusGetIdleResponse).read());
1345 }
1348 Ok(())
1349 }
1350 }
1351 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
1352 fidl::encoding::Encode<HidbusGetIdleResponse, D> for (T0,)
1353 {
1354 #[inline]
1355 unsafe fn encode(
1356 self,
1357 encoder: &mut fidl::encoding::Encoder<'_, D>,
1358 offset: usize,
1359 depth: fidl::encoding::Depth,
1360 ) -> fidl::Result<()> {
1361 encoder.debug_check_bounds::<HidbusGetIdleResponse>(offset);
1362 self.0.encode(encoder, offset + 0, depth)?;
1366 Ok(())
1367 }
1368 }
1369
1370 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusGetIdleResponse {
1371 #[inline(always)]
1372 fn new_empty() -> Self {
1373 Self { duration: fidl::new_empty!(i64, D) }
1374 }
1375
1376 #[inline]
1377 unsafe fn decode(
1378 &mut self,
1379 decoder: &mut fidl::encoding::Decoder<'_, D>,
1380 offset: usize,
1381 _depth: fidl::encoding::Depth,
1382 ) -> fidl::Result<()> {
1383 decoder.debug_check_bounds::<Self>(offset);
1384 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1385 unsafe {
1388 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1389 }
1390 Ok(())
1391 }
1392 }
1393
1394 impl fidl::encoding::ValueTypeMarker for HidbusGetProtocolResponse {
1395 type Borrowed<'a> = &'a Self;
1396 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1397 value
1398 }
1399 }
1400
1401 unsafe impl fidl::encoding::TypeMarker for HidbusGetProtocolResponse {
1402 type Owned = Self;
1403
1404 #[inline(always)]
1405 fn inline_align(_context: fidl::encoding::Context) -> usize {
1406 1
1407 }
1408
1409 #[inline(always)]
1410 fn inline_size(_context: fidl::encoding::Context) -> usize {
1411 1
1412 }
1413 }
1414
1415 unsafe impl<D: fidl::encoding::ResourceDialect>
1416 fidl::encoding::Encode<HidbusGetProtocolResponse, D> for &HidbusGetProtocolResponse
1417 {
1418 #[inline]
1419 unsafe fn encode(
1420 self,
1421 encoder: &mut fidl::encoding::Encoder<'_, D>,
1422 offset: usize,
1423 _depth: fidl::encoding::Depth,
1424 ) -> fidl::Result<()> {
1425 encoder.debug_check_bounds::<HidbusGetProtocolResponse>(offset);
1426 fidl::encoding::Encode::<HidbusGetProtocolResponse, D>::encode(
1428 (<HidProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),),
1429 encoder,
1430 offset,
1431 _depth,
1432 )
1433 }
1434 }
1435 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidProtocol, D>>
1436 fidl::encoding::Encode<HidbusGetProtocolResponse, D> for (T0,)
1437 {
1438 #[inline]
1439 unsafe fn encode(
1440 self,
1441 encoder: &mut fidl::encoding::Encoder<'_, D>,
1442 offset: usize,
1443 depth: fidl::encoding::Depth,
1444 ) -> fidl::Result<()> {
1445 encoder.debug_check_bounds::<HidbusGetProtocolResponse>(offset);
1446 self.0.encode(encoder, offset + 0, depth)?;
1450 Ok(())
1451 }
1452 }
1453
1454 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1455 for HidbusGetProtocolResponse
1456 {
1457 #[inline(always)]
1458 fn new_empty() -> Self {
1459 Self { protocol: fidl::new_empty!(HidProtocol, D) }
1460 }
1461
1462 #[inline]
1463 unsafe fn decode(
1464 &mut self,
1465 decoder: &mut fidl::encoding::Decoder<'_, D>,
1466 offset: usize,
1467 _depth: fidl::encoding::Depth,
1468 ) -> fidl::Result<()> {
1469 decoder.debug_check_bounds::<Self>(offset);
1470 fidl::decode!(HidProtocol, D, &mut self.protocol, decoder, offset + 0, _depth)?;
1472 Ok(())
1473 }
1474 }
1475
1476 impl fidl::encoding::ValueTypeMarker for HidbusGetReportResponse {
1477 type Borrowed<'a> = &'a Self;
1478 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1479 value
1480 }
1481 }
1482
1483 unsafe impl fidl::encoding::TypeMarker for HidbusGetReportResponse {
1484 type Owned = Self;
1485
1486 #[inline(always)]
1487 fn inline_align(_context: fidl::encoding::Context) -> usize {
1488 8
1489 }
1490
1491 #[inline(always)]
1492 fn inline_size(_context: fidl::encoding::Context) -> usize {
1493 16
1494 }
1495 }
1496
1497 unsafe impl<D: fidl::encoding::ResourceDialect>
1498 fidl::encoding::Encode<HidbusGetReportResponse, D> for &HidbusGetReportResponse
1499 {
1500 #[inline]
1501 unsafe fn encode(
1502 self,
1503 encoder: &mut fidl::encoding::Encoder<'_, D>,
1504 offset: usize,
1505 _depth: fidl::encoding::Depth,
1506 ) -> fidl::Result<()> {
1507 encoder.debug_check_bounds::<HidbusGetReportResponse>(offset);
1508 fidl::encoding::Encode::<HidbusGetReportResponse, D>::encode(
1510 (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1511 &self.data,
1512 ),),
1513 encoder,
1514 offset,
1515 _depth,
1516 )
1517 }
1518 }
1519 unsafe impl<
1520 D: fidl::encoding::ResourceDialect,
1521 T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1522 > fidl::encoding::Encode<HidbusGetReportResponse, D> for (T0,)
1523 {
1524 #[inline]
1525 unsafe fn encode(
1526 self,
1527 encoder: &mut fidl::encoding::Encoder<'_, D>,
1528 offset: usize,
1529 depth: fidl::encoding::Depth,
1530 ) -> fidl::Result<()> {
1531 encoder.debug_check_bounds::<HidbusGetReportResponse>(offset);
1532 self.0.encode(encoder, offset + 0, depth)?;
1536 Ok(())
1537 }
1538 }
1539
1540 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1541 for HidbusGetReportResponse
1542 {
1543 #[inline(always)]
1544 fn new_empty() -> Self {
1545 Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
1546 }
1547
1548 #[inline]
1549 unsafe fn decode(
1550 &mut self,
1551 decoder: &mut fidl::encoding::Decoder<'_, D>,
1552 offset: usize,
1553 _depth: fidl::encoding::Depth,
1554 ) -> fidl::Result<()> {
1555 decoder.debug_check_bounds::<Self>(offset);
1556 fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 0, _depth)?;
1558 Ok(())
1559 }
1560 }
1561
1562 impl fidl::encoding::ValueTypeMarker for HidbusQueryResponse {
1563 type Borrowed<'a> = &'a Self;
1564 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1565 value
1566 }
1567 }
1568
1569 unsafe impl fidl::encoding::TypeMarker for HidbusQueryResponse {
1570 type Owned = Self;
1571
1572 #[inline(always)]
1573 fn inline_align(_context: fidl::encoding::Context) -> usize {
1574 8
1575 }
1576
1577 #[inline(always)]
1578 fn inline_size(_context: fidl::encoding::Context) -> usize {
1579 16
1580 }
1581 }
1582
1583 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusQueryResponse, D>
1584 for &HidbusQueryResponse
1585 {
1586 #[inline]
1587 unsafe fn encode(
1588 self,
1589 encoder: &mut fidl::encoding::Encoder<'_, D>,
1590 offset: usize,
1591 _depth: fidl::encoding::Depth,
1592 ) -> fidl::Result<()> {
1593 encoder.debug_check_bounds::<HidbusQueryResponse>(offset);
1594 fidl::encoding::Encode::<HidbusQueryResponse, D>::encode(
1596 (<HidInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
1597 encoder,
1598 offset,
1599 _depth,
1600 )
1601 }
1602 }
1603 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidInfo, D>>
1604 fidl::encoding::Encode<HidbusQueryResponse, D> for (T0,)
1605 {
1606 #[inline]
1607 unsafe fn encode(
1608 self,
1609 encoder: &mut fidl::encoding::Encoder<'_, D>,
1610 offset: usize,
1611 depth: fidl::encoding::Depth,
1612 ) -> fidl::Result<()> {
1613 encoder.debug_check_bounds::<HidbusQueryResponse>(offset);
1614 self.0.encode(encoder, offset + 0, depth)?;
1618 Ok(())
1619 }
1620 }
1621
1622 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusQueryResponse {
1623 #[inline(always)]
1624 fn new_empty() -> Self {
1625 Self { info: fidl::new_empty!(HidInfo, D) }
1626 }
1627
1628 #[inline]
1629 unsafe fn decode(
1630 &mut self,
1631 decoder: &mut fidl::encoding::Decoder<'_, D>,
1632 offset: usize,
1633 _depth: fidl::encoding::Depth,
1634 ) -> fidl::Result<()> {
1635 decoder.debug_check_bounds::<Self>(offset);
1636 fidl::decode!(HidInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
1638 Ok(())
1639 }
1640 }
1641
1642 impl HidInfo {
1643 #[inline(always)]
1644 fn max_ordinal_present(&self) -> u64 {
1645 if let Some(_) = self.polling_rate {
1646 return 6;
1647 }
1648 if let Some(_) = self.version {
1649 return 5;
1650 }
1651 if let Some(_) = self.product_id {
1652 return 4;
1653 }
1654 if let Some(_) = self.vendor_id {
1655 return 3;
1656 }
1657 if let Some(_) = self.boot_protocol {
1658 return 2;
1659 }
1660 if let Some(_) = self.dev_num {
1661 return 1;
1662 }
1663 0
1664 }
1665 }
1666
1667 impl fidl::encoding::ValueTypeMarker for HidInfo {
1668 type Borrowed<'a> = &'a Self;
1669 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1670 value
1671 }
1672 }
1673
1674 unsafe impl fidl::encoding::TypeMarker for HidInfo {
1675 type Owned = Self;
1676
1677 #[inline(always)]
1678 fn inline_align(_context: fidl::encoding::Context) -> usize {
1679 8
1680 }
1681
1682 #[inline(always)]
1683 fn inline_size(_context: fidl::encoding::Context) -> usize {
1684 16
1685 }
1686 }
1687
1688 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidInfo, D> for &HidInfo {
1689 unsafe fn encode(
1690 self,
1691 encoder: &mut fidl::encoding::Encoder<'_, D>,
1692 offset: usize,
1693 mut depth: fidl::encoding::Depth,
1694 ) -> fidl::Result<()> {
1695 encoder.debug_check_bounds::<HidInfo>(offset);
1696 let max_ordinal: u64 = self.max_ordinal_present();
1698 encoder.write_num(max_ordinal, offset);
1699 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1700 if max_ordinal == 0 {
1702 return Ok(());
1703 }
1704 depth.increment()?;
1705 let envelope_size = 8;
1706 let bytes_len = max_ordinal as usize * envelope_size;
1707 #[allow(unused_variables)]
1708 let offset = encoder.out_of_line_offset(bytes_len);
1709 let mut _prev_end_offset: usize = 0;
1710 if 1 > max_ordinal {
1711 return Ok(());
1712 }
1713
1714 let cur_offset: usize = (1 - 1) * envelope_size;
1717
1718 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1720
1721 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1726 self.dev_num.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1727 encoder,
1728 offset + cur_offset,
1729 depth,
1730 )?;
1731
1732 _prev_end_offset = cur_offset + envelope_size;
1733 if 2 > max_ordinal {
1734 return Ok(());
1735 }
1736
1737 let cur_offset: usize = (2 - 1) * envelope_size;
1740
1741 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1743
1744 fidl::encoding::encode_in_envelope_optional::<HidBootProtocol, D>(
1749 self.boot_protocol
1750 .as_ref()
1751 .map(<HidBootProtocol as fidl::encoding::ValueTypeMarker>::borrow),
1752 encoder,
1753 offset + cur_offset,
1754 depth,
1755 )?;
1756
1757 _prev_end_offset = cur_offset + envelope_size;
1758 if 3 > max_ordinal {
1759 return Ok(());
1760 }
1761
1762 let cur_offset: usize = (3 - 1) * envelope_size;
1765
1766 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1768
1769 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1774 self.vendor_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1775 encoder,
1776 offset + cur_offset,
1777 depth,
1778 )?;
1779
1780 _prev_end_offset = cur_offset + envelope_size;
1781 if 4 > max_ordinal {
1782 return Ok(());
1783 }
1784
1785 let cur_offset: usize = (4 - 1) * envelope_size;
1788
1789 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1791
1792 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1797 self.product_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1798 encoder,
1799 offset + cur_offset,
1800 depth,
1801 )?;
1802
1803 _prev_end_offset = cur_offset + envelope_size;
1804 if 5 > max_ordinal {
1805 return Ok(());
1806 }
1807
1808 let cur_offset: usize = (5 - 1) * envelope_size;
1811
1812 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1814
1815 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1820 self.version.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1821 encoder,
1822 offset + cur_offset,
1823 depth,
1824 )?;
1825
1826 _prev_end_offset = cur_offset + envelope_size;
1827 if 6 > max_ordinal {
1828 return Ok(());
1829 }
1830
1831 let cur_offset: usize = (6 - 1) * envelope_size;
1834
1835 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1837
1838 fidl::encoding::encode_in_envelope_optional::<i64, D>(
1843 self.polling_rate.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1844 encoder,
1845 offset + cur_offset,
1846 depth,
1847 )?;
1848
1849 _prev_end_offset = cur_offset + envelope_size;
1850
1851 Ok(())
1852 }
1853 }
1854
1855 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidInfo {
1856 #[inline(always)]
1857 fn new_empty() -> Self {
1858 Self::default()
1859 }
1860
1861 unsafe fn decode(
1862 &mut self,
1863 decoder: &mut fidl::encoding::Decoder<'_, D>,
1864 offset: usize,
1865 mut depth: fidl::encoding::Depth,
1866 ) -> fidl::Result<()> {
1867 decoder.debug_check_bounds::<Self>(offset);
1868 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1869 None => return Err(fidl::Error::NotNullable),
1870 Some(len) => len,
1871 };
1872 if len == 0 {
1874 return Ok(());
1875 };
1876 depth.increment()?;
1877 let envelope_size = 8;
1878 let bytes_len = len * envelope_size;
1879 let offset = decoder.out_of_line_offset(bytes_len)?;
1880 let mut _next_ordinal_to_read = 0;
1882 let mut next_offset = offset;
1883 let end_offset = offset + bytes_len;
1884 _next_ordinal_to_read += 1;
1885 if next_offset >= end_offset {
1886 return Ok(());
1887 }
1888
1889 while _next_ordinal_to_read < 1 {
1891 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1892 _next_ordinal_to_read += 1;
1893 next_offset += envelope_size;
1894 }
1895
1896 let next_out_of_line = decoder.next_out_of_line();
1897 let handles_before = decoder.remaining_handles();
1898 if let Some((inlined, num_bytes, num_handles)) =
1899 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1900 {
1901 let member_inline_size =
1902 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1903 if inlined != (member_inline_size <= 4) {
1904 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1905 }
1906 let inner_offset;
1907 let mut inner_depth = depth.clone();
1908 if inlined {
1909 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1910 inner_offset = next_offset;
1911 } else {
1912 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1913 inner_depth.increment()?;
1914 }
1915 let val_ref = self.dev_num.get_or_insert_with(|| fidl::new_empty!(u8, D));
1916 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1917 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1918 {
1919 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1920 }
1921 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1922 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1923 }
1924 }
1925
1926 next_offset += envelope_size;
1927 _next_ordinal_to_read += 1;
1928 if next_offset >= end_offset {
1929 return Ok(());
1930 }
1931
1932 while _next_ordinal_to_read < 2 {
1934 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1935 _next_ordinal_to_read += 1;
1936 next_offset += envelope_size;
1937 }
1938
1939 let next_out_of_line = decoder.next_out_of_line();
1940 let handles_before = decoder.remaining_handles();
1941 if let Some((inlined, num_bytes, num_handles)) =
1942 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1943 {
1944 let member_inline_size =
1945 <HidBootProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1946 if inlined != (member_inline_size <= 4) {
1947 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1948 }
1949 let inner_offset;
1950 let mut inner_depth = depth.clone();
1951 if inlined {
1952 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1953 inner_offset = next_offset;
1954 } else {
1955 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1956 inner_depth.increment()?;
1957 }
1958 let val_ref =
1959 self.boot_protocol.get_or_insert_with(|| fidl::new_empty!(HidBootProtocol, D));
1960 fidl::decode!(HidBootProtocol, D, val_ref, decoder, inner_offset, inner_depth)?;
1961 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1962 {
1963 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1964 }
1965 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1966 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1967 }
1968 }
1969
1970 next_offset += envelope_size;
1971 _next_ordinal_to_read += 1;
1972 if next_offset >= end_offset {
1973 return Ok(());
1974 }
1975
1976 while _next_ordinal_to_read < 3 {
1978 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1979 _next_ordinal_to_read += 1;
1980 next_offset += envelope_size;
1981 }
1982
1983 let next_out_of_line = decoder.next_out_of_line();
1984 let handles_before = decoder.remaining_handles();
1985 if let Some((inlined, num_bytes, num_handles)) =
1986 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1987 {
1988 let member_inline_size =
1989 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1990 if inlined != (member_inline_size <= 4) {
1991 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1992 }
1993 let inner_offset;
1994 let mut inner_depth = depth.clone();
1995 if inlined {
1996 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1997 inner_offset = next_offset;
1998 } else {
1999 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2000 inner_depth.increment()?;
2001 }
2002 let val_ref = self.vendor_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2003 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2004 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2005 {
2006 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2007 }
2008 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2009 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2010 }
2011 }
2012
2013 next_offset += envelope_size;
2014 _next_ordinal_to_read += 1;
2015 if next_offset >= end_offset {
2016 return Ok(());
2017 }
2018
2019 while _next_ordinal_to_read < 4 {
2021 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2022 _next_ordinal_to_read += 1;
2023 next_offset += envelope_size;
2024 }
2025
2026 let next_out_of_line = decoder.next_out_of_line();
2027 let handles_before = decoder.remaining_handles();
2028 if let Some((inlined, num_bytes, num_handles)) =
2029 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2030 {
2031 let member_inline_size =
2032 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2033 if inlined != (member_inline_size <= 4) {
2034 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2035 }
2036 let inner_offset;
2037 let mut inner_depth = depth.clone();
2038 if inlined {
2039 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2040 inner_offset = next_offset;
2041 } else {
2042 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2043 inner_depth.increment()?;
2044 }
2045 let val_ref = self.product_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2046 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2047 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2048 {
2049 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2050 }
2051 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2052 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2053 }
2054 }
2055
2056 next_offset += envelope_size;
2057 _next_ordinal_to_read += 1;
2058 if next_offset >= end_offset {
2059 return Ok(());
2060 }
2061
2062 while _next_ordinal_to_read < 5 {
2064 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2065 _next_ordinal_to_read += 1;
2066 next_offset += envelope_size;
2067 }
2068
2069 let next_out_of_line = decoder.next_out_of_line();
2070 let handles_before = decoder.remaining_handles();
2071 if let Some((inlined, num_bytes, num_handles)) =
2072 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2073 {
2074 let member_inline_size =
2075 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2076 if inlined != (member_inline_size <= 4) {
2077 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2078 }
2079 let inner_offset;
2080 let mut inner_depth = depth.clone();
2081 if inlined {
2082 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2083 inner_offset = next_offset;
2084 } else {
2085 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2086 inner_depth.increment()?;
2087 }
2088 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(u32, D));
2089 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2091 {
2092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2093 }
2094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2096 }
2097 }
2098
2099 next_offset += envelope_size;
2100 _next_ordinal_to_read += 1;
2101 if next_offset >= end_offset {
2102 return Ok(());
2103 }
2104
2105 while _next_ordinal_to_read < 6 {
2107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2108 _next_ordinal_to_read += 1;
2109 next_offset += envelope_size;
2110 }
2111
2112 let next_out_of_line = decoder.next_out_of_line();
2113 let handles_before = decoder.remaining_handles();
2114 if let Some((inlined, num_bytes, num_handles)) =
2115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2116 {
2117 let member_inline_size =
2118 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2119 if inlined != (member_inline_size <= 4) {
2120 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2121 }
2122 let inner_offset;
2123 let mut inner_depth = depth.clone();
2124 if inlined {
2125 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2126 inner_offset = next_offset;
2127 } else {
2128 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2129 inner_depth.increment()?;
2130 }
2131 let val_ref = self.polling_rate.get_or_insert_with(|| fidl::new_empty!(i64, D));
2132 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2133 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2134 {
2135 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2136 }
2137 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2138 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2139 }
2140 }
2141
2142 next_offset += envelope_size;
2143
2144 while next_offset < end_offset {
2146 _next_ordinal_to_read += 1;
2147 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2148 next_offset += envelope_size;
2149 }
2150
2151 Ok(())
2152 }
2153 }
2154}