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 const MAX_RECORDS: u8 = 3;
13
14pub const MAX_SERVICE_DESCRIPTION_LENGTH: u8 = 128;
16
17#[derive(Clone, Debug, Default, PartialEq)]
19pub struct DeviceIdentificationRecord {
20 pub vendor_id: Option<VendorId>,
22 pub product_id: Option<u16>,
24 pub version: Option<DeviceReleaseNumber>,
26 pub primary: Option<bool>,
29 pub service_description: Option<String>,
32 #[doc(hidden)]
33 pub __source_breaking: fidl::marker::SourceBreaking,
34}
35
36impl fidl::Persistable for DeviceIdentificationRecord {}
37
38#[derive(Clone, Debug, Default, PartialEq)]
42pub struct DeviceReleaseNumber {
43 pub major: Option<u8>,
45 pub minor: Option<u8>,
47 pub subminor: Option<u8>,
49 #[doc(hidden)]
50 pub __source_breaking: fidl::marker::SourceBreaking,
51}
52
53impl fidl::Persistable for DeviceReleaseNumber {}
54
55#[derive(Clone, Debug)]
58pub enum VendorId {
59 BluetoothSigId(u16),
62 UsbIfId(u16),
65 #[doc(hidden)]
66 __SourceBreaking { unknown_ordinal: u64 },
67}
68
69#[macro_export]
71macro_rules! VendorIdUnknown {
72 () => {
73 _
74 };
75}
76
77impl PartialEq for VendorId {
79 fn eq(&self, other: &Self) -> bool {
80 match (self, other) {
81 (Self::BluetoothSigId(x), Self::BluetoothSigId(y)) => *x == *y,
82 (Self::UsbIfId(x), Self::UsbIfId(y)) => *x == *y,
83 _ => false,
84 }
85 }
86}
87
88impl VendorId {
89 #[inline]
90 pub fn ordinal(&self) -> u64 {
91 match *self {
92 Self::BluetoothSigId(_) => 1,
93 Self::UsbIfId(_) => 2,
94 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
95 }
96 }
97
98 #[inline]
99 pub fn unknown_variant_for_testing() -> Self {
100 Self::__SourceBreaking { unknown_ordinal: 0 }
101 }
102
103 #[inline]
104 pub fn is_unknown(&self) -> bool {
105 match self {
106 Self::__SourceBreaking { .. } => true,
107 _ => false,
108 }
109 }
110}
111
112impl fidl::Persistable for VendorId {}
113
114pub mod device_identification_ordinals {
115 pub const SET_DEVICE_IDENTIFICATION: u64 = 0x12ada3cb3fbcbd0a;
116}
117
118pub mod device_identification_handle_ordinals {}
119
120mod internal {
121 use super::*;
122
123 impl DeviceIdentificationRecord {
124 #[inline(always)]
125 fn max_ordinal_present(&self) -> u64 {
126 if let Some(_) = self.service_description {
127 return 5;
128 }
129 if let Some(_) = self.primary {
130 return 4;
131 }
132 if let Some(_) = self.version {
133 return 3;
134 }
135 if let Some(_) = self.product_id {
136 return 2;
137 }
138 if let Some(_) = self.vendor_id {
139 return 1;
140 }
141 0
142 }
143 }
144
145 impl fidl::encoding::ValueTypeMarker for DeviceIdentificationRecord {
146 type Borrowed<'a> = &'a Self;
147 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
148 value
149 }
150 }
151
152 unsafe impl fidl::encoding::TypeMarker for DeviceIdentificationRecord {
153 type Owned = Self;
154
155 #[inline(always)]
156 fn inline_align(_context: fidl::encoding::Context) -> usize {
157 8
158 }
159
160 #[inline(always)]
161 fn inline_size(_context: fidl::encoding::Context) -> usize {
162 16
163 }
164 }
165
166 unsafe impl<D: fidl::encoding::ResourceDialect>
167 fidl::encoding::Encode<DeviceIdentificationRecord, D> for &DeviceIdentificationRecord
168 {
169 unsafe fn encode(
170 self,
171 encoder: &mut fidl::encoding::Encoder<'_, D>,
172 offset: usize,
173 mut depth: fidl::encoding::Depth,
174 ) -> fidl::Result<()> {
175 encoder.debug_check_bounds::<DeviceIdentificationRecord>(offset);
176 let max_ordinal: u64 = self.max_ordinal_present();
178 encoder.write_num(max_ordinal, offset);
179 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
180 if max_ordinal == 0 {
182 return Ok(());
183 }
184 depth.increment()?;
185 let envelope_size = 8;
186 let bytes_len = max_ordinal as usize * envelope_size;
187 #[allow(unused_variables)]
188 let offset = encoder.out_of_line_offset(bytes_len);
189 let mut _prev_end_offset: usize = 0;
190 if 1 > max_ordinal {
191 return Ok(());
192 }
193
194 let cur_offset: usize = (1 - 1) * envelope_size;
197
198 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
200
201 fidl::encoding::encode_in_envelope_optional::<VendorId, D>(
206 self.vendor_id.as_ref().map(<VendorId as fidl::encoding::ValueTypeMarker>::borrow),
207 encoder,
208 offset + cur_offset,
209 depth,
210 )?;
211
212 _prev_end_offset = cur_offset + envelope_size;
213 if 2 > max_ordinal {
214 return Ok(());
215 }
216
217 let cur_offset: usize = (2 - 1) * envelope_size;
220
221 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
223
224 fidl::encoding::encode_in_envelope_optional::<u16, D>(
229 self.product_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
230 encoder,
231 offset + cur_offset,
232 depth,
233 )?;
234
235 _prev_end_offset = cur_offset + envelope_size;
236 if 3 > max_ordinal {
237 return Ok(());
238 }
239
240 let cur_offset: usize = (3 - 1) * envelope_size;
243
244 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
246
247 fidl::encoding::encode_in_envelope_optional::<DeviceReleaseNumber, D>(
252 self.version
253 .as_ref()
254 .map(<DeviceReleaseNumber as fidl::encoding::ValueTypeMarker>::borrow),
255 encoder,
256 offset + cur_offset,
257 depth,
258 )?;
259
260 _prev_end_offset = cur_offset + envelope_size;
261 if 4 > max_ordinal {
262 return Ok(());
263 }
264
265 let cur_offset: usize = (4 - 1) * envelope_size;
268
269 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
271
272 fidl::encoding::encode_in_envelope_optional::<bool, D>(
277 self.primary.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
278 encoder,
279 offset + cur_offset,
280 depth,
281 )?;
282
283 _prev_end_offset = cur_offset + envelope_size;
284 if 5 > max_ordinal {
285 return Ok(());
286 }
287
288 let cur_offset: usize = (5 - 1) * envelope_size;
291
292 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
294
295 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
300 self.service_description.as_ref().map(
301 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
302 ),
303 encoder,
304 offset + cur_offset,
305 depth,
306 )?;
307
308 _prev_end_offset = cur_offset + envelope_size;
309
310 Ok(())
311 }
312 }
313
314 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
315 for DeviceIdentificationRecord
316 {
317 #[inline(always)]
318 fn new_empty() -> Self {
319 Self::default()
320 }
321
322 unsafe fn decode(
323 &mut self,
324 decoder: &mut fidl::encoding::Decoder<'_, D>,
325 offset: usize,
326 mut depth: fidl::encoding::Depth,
327 ) -> fidl::Result<()> {
328 decoder.debug_check_bounds::<Self>(offset);
329 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
330 None => return Err(fidl::Error::NotNullable),
331 Some(len) => len,
332 };
333 if len == 0 {
335 return Ok(());
336 };
337 depth.increment()?;
338 let envelope_size = 8;
339 let bytes_len = len * envelope_size;
340 let offset = decoder.out_of_line_offset(bytes_len)?;
341 let mut _next_ordinal_to_read = 0;
343 let mut next_offset = offset;
344 let end_offset = offset + bytes_len;
345 _next_ordinal_to_read += 1;
346 if next_offset >= end_offset {
347 return Ok(());
348 }
349
350 while _next_ordinal_to_read < 1 {
352 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
353 _next_ordinal_to_read += 1;
354 next_offset += envelope_size;
355 }
356
357 let next_out_of_line = decoder.next_out_of_line();
358 let handles_before = decoder.remaining_handles();
359 if let Some((inlined, num_bytes, num_handles)) =
360 fidl::encoding::decode_envelope_header(decoder, next_offset)?
361 {
362 let member_inline_size =
363 <VendorId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
364 if inlined != (member_inline_size <= 4) {
365 return Err(fidl::Error::InvalidInlineBitInEnvelope);
366 }
367 let inner_offset;
368 let mut inner_depth = depth.clone();
369 if inlined {
370 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
371 inner_offset = next_offset;
372 } else {
373 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
374 inner_depth.increment()?;
375 }
376 let val_ref = self.vendor_id.get_or_insert_with(|| fidl::new_empty!(VendorId, D));
377 fidl::decode!(VendorId, D, val_ref, decoder, inner_offset, inner_depth)?;
378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
379 {
380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
381 }
382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
384 }
385 }
386
387 next_offset += envelope_size;
388 _next_ordinal_to_read += 1;
389 if next_offset >= end_offset {
390 return Ok(());
391 }
392
393 while _next_ordinal_to_read < 2 {
395 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
396 _next_ordinal_to_read += 1;
397 next_offset += envelope_size;
398 }
399
400 let next_out_of_line = decoder.next_out_of_line();
401 let handles_before = decoder.remaining_handles();
402 if let Some((inlined, num_bytes, num_handles)) =
403 fidl::encoding::decode_envelope_header(decoder, next_offset)?
404 {
405 let member_inline_size =
406 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
407 if inlined != (member_inline_size <= 4) {
408 return Err(fidl::Error::InvalidInlineBitInEnvelope);
409 }
410 let inner_offset;
411 let mut inner_depth = depth.clone();
412 if inlined {
413 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
414 inner_offset = next_offset;
415 } else {
416 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
417 inner_depth.increment()?;
418 }
419 let val_ref = self.product_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
420 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
421 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
422 {
423 return Err(fidl::Error::InvalidNumBytesInEnvelope);
424 }
425 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
426 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
427 }
428 }
429
430 next_offset += envelope_size;
431 _next_ordinal_to_read += 1;
432 if next_offset >= end_offset {
433 return Ok(());
434 }
435
436 while _next_ordinal_to_read < 3 {
438 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
439 _next_ordinal_to_read += 1;
440 next_offset += envelope_size;
441 }
442
443 let next_out_of_line = decoder.next_out_of_line();
444 let handles_before = decoder.remaining_handles();
445 if let Some((inlined, num_bytes, num_handles)) =
446 fidl::encoding::decode_envelope_header(decoder, next_offset)?
447 {
448 let member_inline_size =
449 <DeviceReleaseNumber as fidl::encoding::TypeMarker>::inline_size(
450 decoder.context,
451 );
452 if inlined != (member_inline_size <= 4) {
453 return Err(fidl::Error::InvalidInlineBitInEnvelope);
454 }
455 let inner_offset;
456 let mut inner_depth = depth.clone();
457 if inlined {
458 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
459 inner_offset = next_offset;
460 } else {
461 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
462 inner_depth.increment()?;
463 }
464 let val_ref =
465 self.version.get_or_insert_with(|| fidl::new_empty!(DeviceReleaseNumber, D));
466 fidl::decode!(DeviceReleaseNumber, D, val_ref, decoder, inner_offset, inner_depth)?;
467 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
468 {
469 return Err(fidl::Error::InvalidNumBytesInEnvelope);
470 }
471 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
472 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
473 }
474 }
475
476 next_offset += envelope_size;
477 _next_ordinal_to_read += 1;
478 if next_offset >= end_offset {
479 return Ok(());
480 }
481
482 while _next_ordinal_to_read < 4 {
484 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
485 _next_ordinal_to_read += 1;
486 next_offset += envelope_size;
487 }
488
489 let next_out_of_line = decoder.next_out_of_line();
490 let handles_before = decoder.remaining_handles();
491 if let Some((inlined, num_bytes, num_handles)) =
492 fidl::encoding::decode_envelope_header(decoder, next_offset)?
493 {
494 let member_inline_size =
495 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
496 if inlined != (member_inline_size <= 4) {
497 return Err(fidl::Error::InvalidInlineBitInEnvelope);
498 }
499 let inner_offset;
500 let mut inner_depth = depth.clone();
501 if inlined {
502 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
503 inner_offset = next_offset;
504 } else {
505 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
506 inner_depth.increment()?;
507 }
508 let val_ref = self.primary.get_or_insert_with(|| fidl::new_empty!(bool, D));
509 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
510 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
511 {
512 return Err(fidl::Error::InvalidNumBytesInEnvelope);
513 }
514 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
515 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
516 }
517 }
518
519 next_offset += envelope_size;
520 _next_ordinal_to_read += 1;
521 if next_offset >= end_offset {
522 return Ok(());
523 }
524
525 while _next_ordinal_to_read < 5 {
527 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
528 _next_ordinal_to_read += 1;
529 next_offset += envelope_size;
530 }
531
532 let next_out_of_line = decoder.next_out_of_line();
533 let handles_before = decoder.remaining_handles();
534 if let Some((inlined, num_bytes, num_handles)) =
535 fidl::encoding::decode_envelope_header(decoder, next_offset)?
536 {
537 let member_inline_size =
538 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
539 decoder.context,
540 );
541 if inlined != (member_inline_size <= 4) {
542 return Err(fidl::Error::InvalidInlineBitInEnvelope);
543 }
544 let inner_offset;
545 let mut inner_depth = depth.clone();
546 if inlined {
547 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
548 inner_offset = next_offset;
549 } else {
550 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
551 inner_depth.increment()?;
552 }
553 let val_ref = self
554 .service_description
555 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
556 fidl::decode!(
557 fidl::encoding::BoundedString<128>,
558 D,
559 val_ref,
560 decoder,
561 inner_offset,
562 inner_depth
563 )?;
564 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
565 {
566 return Err(fidl::Error::InvalidNumBytesInEnvelope);
567 }
568 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
569 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
570 }
571 }
572
573 next_offset += envelope_size;
574
575 while next_offset < end_offset {
577 _next_ordinal_to_read += 1;
578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
579 next_offset += envelope_size;
580 }
581
582 Ok(())
583 }
584 }
585
586 impl DeviceReleaseNumber {
587 #[inline(always)]
588 fn max_ordinal_present(&self) -> u64 {
589 if let Some(_) = self.subminor {
590 return 3;
591 }
592 if let Some(_) = self.minor {
593 return 2;
594 }
595 if let Some(_) = self.major {
596 return 1;
597 }
598 0
599 }
600 }
601
602 impl fidl::encoding::ValueTypeMarker for DeviceReleaseNumber {
603 type Borrowed<'a> = &'a Self;
604 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
605 value
606 }
607 }
608
609 unsafe impl fidl::encoding::TypeMarker for DeviceReleaseNumber {
610 type Owned = Self;
611
612 #[inline(always)]
613 fn inline_align(_context: fidl::encoding::Context) -> usize {
614 8
615 }
616
617 #[inline(always)]
618 fn inline_size(_context: fidl::encoding::Context) -> usize {
619 16
620 }
621 }
622
623 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceReleaseNumber, D>
624 for &DeviceReleaseNumber
625 {
626 unsafe fn encode(
627 self,
628 encoder: &mut fidl::encoding::Encoder<'_, D>,
629 offset: usize,
630 mut depth: fidl::encoding::Depth,
631 ) -> fidl::Result<()> {
632 encoder.debug_check_bounds::<DeviceReleaseNumber>(offset);
633 let max_ordinal: u64 = self.max_ordinal_present();
635 encoder.write_num(max_ordinal, offset);
636 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
637 if max_ordinal == 0 {
639 return Ok(());
640 }
641 depth.increment()?;
642 let envelope_size = 8;
643 let bytes_len = max_ordinal as usize * envelope_size;
644 #[allow(unused_variables)]
645 let offset = encoder.out_of_line_offset(bytes_len);
646 let mut _prev_end_offset: usize = 0;
647 if 1 > max_ordinal {
648 return Ok(());
649 }
650
651 let cur_offset: usize = (1 - 1) * envelope_size;
654
655 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
657
658 fidl::encoding::encode_in_envelope_optional::<u8, D>(
663 self.major.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
664 encoder,
665 offset + cur_offset,
666 depth,
667 )?;
668
669 _prev_end_offset = cur_offset + envelope_size;
670 if 2 > max_ordinal {
671 return Ok(());
672 }
673
674 let cur_offset: usize = (2 - 1) * envelope_size;
677
678 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
680
681 fidl::encoding::encode_in_envelope_optional::<u8, D>(
686 self.minor.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
687 encoder,
688 offset + cur_offset,
689 depth,
690 )?;
691
692 _prev_end_offset = cur_offset + envelope_size;
693 if 3 > max_ordinal {
694 return Ok(());
695 }
696
697 let cur_offset: usize = (3 - 1) * envelope_size;
700
701 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
703
704 fidl::encoding::encode_in_envelope_optional::<u8, D>(
709 self.subminor.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
710 encoder,
711 offset + cur_offset,
712 depth,
713 )?;
714
715 _prev_end_offset = cur_offset + envelope_size;
716
717 Ok(())
718 }
719 }
720
721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceReleaseNumber {
722 #[inline(always)]
723 fn new_empty() -> Self {
724 Self::default()
725 }
726
727 unsafe fn decode(
728 &mut self,
729 decoder: &mut fidl::encoding::Decoder<'_, D>,
730 offset: usize,
731 mut depth: fidl::encoding::Depth,
732 ) -> fidl::Result<()> {
733 decoder.debug_check_bounds::<Self>(offset);
734 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
735 None => return Err(fidl::Error::NotNullable),
736 Some(len) => len,
737 };
738 if len == 0 {
740 return Ok(());
741 };
742 depth.increment()?;
743 let envelope_size = 8;
744 let bytes_len = len * envelope_size;
745 let offset = decoder.out_of_line_offset(bytes_len)?;
746 let mut _next_ordinal_to_read = 0;
748 let mut next_offset = offset;
749 let end_offset = offset + bytes_len;
750 _next_ordinal_to_read += 1;
751 if next_offset >= end_offset {
752 return Ok(());
753 }
754
755 while _next_ordinal_to_read < 1 {
757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
758 _next_ordinal_to_read += 1;
759 next_offset += envelope_size;
760 }
761
762 let next_out_of_line = decoder.next_out_of_line();
763 let handles_before = decoder.remaining_handles();
764 if let Some((inlined, num_bytes, num_handles)) =
765 fidl::encoding::decode_envelope_header(decoder, next_offset)?
766 {
767 let member_inline_size =
768 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
769 if inlined != (member_inline_size <= 4) {
770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
771 }
772 let inner_offset;
773 let mut inner_depth = depth.clone();
774 if inlined {
775 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
776 inner_offset = next_offset;
777 } else {
778 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
779 inner_depth.increment()?;
780 }
781 let val_ref = self.major.get_or_insert_with(|| fidl::new_empty!(u8, D));
782 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
783 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
784 {
785 return Err(fidl::Error::InvalidNumBytesInEnvelope);
786 }
787 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
788 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
789 }
790 }
791
792 next_offset += envelope_size;
793 _next_ordinal_to_read += 1;
794 if next_offset >= end_offset {
795 return Ok(());
796 }
797
798 while _next_ordinal_to_read < 2 {
800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
801 _next_ordinal_to_read += 1;
802 next_offset += envelope_size;
803 }
804
805 let next_out_of_line = decoder.next_out_of_line();
806 let handles_before = decoder.remaining_handles();
807 if let Some((inlined, num_bytes, num_handles)) =
808 fidl::encoding::decode_envelope_header(decoder, next_offset)?
809 {
810 let member_inline_size =
811 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
812 if inlined != (member_inline_size <= 4) {
813 return Err(fidl::Error::InvalidInlineBitInEnvelope);
814 }
815 let inner_offset;
816 let mut inner_depth = depth.clone();
817 if inlined {
818 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
819 inner_offset = next_offset;
820 } else {
821 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
822 inner_depth.increment()?;
823 }
824 let val_ref = self.minor.get_or_insert_with(|| fidl::new_empty!(u8, D));
825 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
826 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
827 {
828 return Err(fidl::Error::InvalidNumBytesInEnvelope);
829 }
830 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
831 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
832 }
833 }
834
835 next_offset += envelope_size;
836 _next_ordinal_to_read += 1;
837 if next_offset >= end_offset {
838 return Ok(());
839 }
840
841 while _next_ordinal_to_read < 3 {
843 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
844 _next_ordinal_to_read += 1;
845 next_offset += envelope_size;
846 }
847
848 let next_out_of_line = decoder.next_out_of_line();
849 let handles_before = decoder.remaining_handles();
850 if let Some((inlined, num_bytes, num_handles)) =
851 fidl::encoding::decode_envelope_header(decoder, next_offset)?
852 {
853 let member_inline_size =
854 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
855 if inlined != (member_inline_size <= 4) {
856 return Err(fidl::Error::InvalidInlineBitInEnvelope);
857 }
858 let inner_offset;
859 let mut inner_depth = depth.clone();
860 if inlined {
861 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
862 inner_offset = next_offset;
863 } else {
864 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
865 inner_depth.increment()?;
866 }
867 let val_ref = self.subminor.get_or_insert_with(|| fidl::new_empty!(u8, D));
868 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
869 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
870 {
871 return Err(fidl::Error::InvalidNumBytesInEnvelope);
872 }
873 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
874 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
875 }
876 }
877
878 next_offset += envelope_size;
879
880 while next_offset < end_offset {
882 _next_ordinal_to_read += 1;
883 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
884 next_offset += envelope_size;
885 }
886
887 Ok(())
888 }
889 }
890
891 impl fidl::encoding::ValueTypeMarker for VendorId {
892 type Borrowed<'a> = &'a Self;
893 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
894 value
895 }
896 }
897
898 unsafe impl fidl::encoding::TypeMarker for VendorId {
899 type Owned = Self;
900
901 #[inline(always)]
902 fn inline_align(_context: fidl::encoding::Context) -> usize {
903 8
904 }
905
906 #[inline(always)]
907 fn inline_size(_context: fidl::encoding::Context) -> usize {
908 16
909 }
910 }
911
912 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VendorId, D> for &VendorId {
913 #[inline]
914 unsafe fn encode(
915 self,
916 encoder: &mut fidl::encoding::Encoder<'_, D>,
917 offset: usize,
918 _depth: fidl::encoding::Depth,
919 ) -> fidl::Result<()> {
920 encoder.debug_check_bounds::<VendorId>(offset);
921 encoder.write_num::<u64>(self.ordinal(), offset);
922 match self {
923 VendorId::BluetoothSigId(ref val) => fidl::encoding::encode_in_envelope::<u16, D>(
924 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
925 encoder,
926 offset + 8,
927 _depth,
928 ),
929 VendorId::UsbIfId(ref val) => fidl::encoding::encode_in_envelope::<u16, D>(
930 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
931 encoder,
932 offset + 8,
933 _depth,
934 ),
935 VendorId::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
936 }
937 }
938 }
939
940 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VendorId {
941 #[inline(always)]
942 fn new_empty() -> Self {
943 Self::__SourceBreaking { unknown_ordinal: 0 }
944 }
945
946 #[inline]
947 unsafe fn decode(
948 &mut self,
949 decoder: &mut fidl::encoding::Decoder<'_, D>,
950 offset: usize,
951 mut depth: fidl::encoding::Depth,
952 ) -> fidl::Result<()> {
953 decoder.debug_check_bounds::<Self>(offset);
954 #[allow(unused_variables)]
955 let next_out_of_line = decoder.next_out_of_line();
956 let handles_before = decoder.remaining_handles();
957 let (ordinal, inlined, num_bytes, num_handles) =
958 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
959
960 let member_inline_size = match ordinal {
961 1 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
962 2 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
963 0 => return Err(fidl::Error::UnknownUnionTag),
964 _ => num_bytes as usize,
965 };
966
967 if inlined != (member_inline_size <= 4) {
968 return Err(fidl::Error::InvalidInlineBitInEnvelope);
969 }
970 let _inner_offset;
971 if inlined {
972 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
973 _inner_offset = offset + 8;
974 } else {
975 depth.increment()?;
976 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
977 }
978 match ordinal {
979 1 => {
980 #[allow(irrefutable_let_patterns)]
981 if let VendorId::BluetoothSigId(_) = self {
982 } else {
984 *self = VendorId::BluetoothSigId(fidl::new_empty!(u16, D));
986 }
987 #[allow(irrefutable_let_patterns)]
988 if let VendorId::BluetoothSigId(ref mut val) = self {
989 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
990 } else {
991 unreachable!()
992 }
993 }
994 2 => {
995 #[allow(irrefutable_let_patterns)]
996 if let VendorId::UsbIfId(_) = self {
997 } else {
999 *self = VendorId::UsbIfId(fidl::new_empty!(u16, D));
1001 }
1002 #[allow(irrefutable_let_patterns)]
1003 if let VendorId::UsbIfId(ref mut val) = self {
1004 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
1005 } else {
1006 unreachable!()
1007 }
1008 }
1009 #[allow(deprecated)]
1010 ordinal => {
1011 for _ in 0..num_handles {
1012 decoder.drop_next_handle()?;
1013 }
1014 *self = VendorId::__SourceBreaking { unknown_ordinal: ordinal };
1015 }
1016 }
1017 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1018 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1019 }
1020 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1021 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1022 }
1023 Ok(())
1024 }
1025 }
1026}