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_VALUE_SIZE: u8 = 255;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum Architecture {
15 X64,
16 Arm64,
17 #[doc(hidden)]
18 __SourceBreaking {
19 unknown_ordinal: u32,
20 },
21}
22
23#[macro_export]
25macro_rules! ArchitectureUnknown {
26 () => {
27 _
28 };
29}
30
31impl Architecture {
32 #[inline]
33 pub fn from_primitive(prim: u32) -> Option<Self> {
34 match prim {
35 1 => Some(Self::X64),
36 2 => Some(Self::Arm64),
37 _ => None,
38 }
39 }
40
41 #[inline]
42 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43 match prim {
44 1 => Self::X64,
45 2 => Self::Arm64,
46 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
47 }
48 }
49
50 #[inline]
51 pub fn unknown() -> Self {
52 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
53 }
54
55 #[inline]
56 pub const fn into_primitive(self) -> u32 {
57 match self {
58 Self::X64 => 1,
59 Self::Arm64 => 2,
60 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
61 }
62 }
63
64 #[inline]
65 pub fn is_unknown(&self) -> bool {
66 match self {
67 Self::__SourceBreaking { unknown_ordinal: _ } => true,
68 _ => false,
69 }
70 }
71}
72
73#[derive(Clone, Debug, PartialEq)]
74pub struct BoardGetInfoResponse {
75 pub info: BoardInfo,
76}
77
78impl fidl::Persistable for BoardGetInfoResponse {}
79
80#[derive(Clone, Debug, PartialEq)]
81pub struct DeviceGetInfoResponse {
82 pub info: DeviceInfo,
83}
84
85impl fidl::Persistable for DeviceGetInfoResponse {}
86
87#[derive(Clone, Debug, PartialEq)]
88pub struct ProductGetInfoResponse {
89 pub info: ProductInfo,
90}
91
92impl fidl::Persistable for ProductGetInfoResponse {}
93
94#[derive(Clone, Debug, Default, PartialEq)]
97pub struct BoardInfo {
98 pub name: Option<String>,
99 pub revision: Option<String>,
100 pub cpu_architecture: Option<Architecture>,
101 #[doc(hidden)]
102 pub __source_breaking: fidl::marker::SourceBreaking,
103}
104
105impl fidl::Persistable for BoardInfo {}
106
107#[derive(Clone, Debug, Default, PartialEq)]
109pub struct DeviceInfo {
110 pub serial_number: Option<String>,
111 pub is_retail_demo: Option<bool>,
112 pub retail_sku: Option<String>,
113 #[doc(hidden)]
114 pub __source_breaking: fidl::marker::SourceBreaking,
115}
116
117impl fidl::Persistable for DeviceInfo {}
118
119#[derive(Clone, Debug, Default, PartialEq)]
122pub struct ProductInfo {
123 pub sku: Option<String>,
124 pub language: Option<String>,
125 pub regulatory_domain: Option<fidl_fuchsia_intl__common::RegulatoryDomain>,
126 pub locale_list: Option<Vec<fidl_fuchsia_intl__common::LocaleId>>,
127 pub name: Option<String>,
128 pub model: Option<String>,
129 pub manufacturer: Option<String>,
130 pub build_date: Option<String>,
131 pub build_name: Option<String>,
132 pub colorway: Option<String>,
133 pub display: Option<String>,
134 pub memory: Option<String>,
135 pub nand_storage: Option<String>,
136 pub emmc_storage: Option<String>,
137 pub microphone: Option<String>,
138 pub audio_amplifier: Option<String>,
139 #[doc(hidden)]
140 pub __source_breaking: fidl::marker::SourceBreaking,
141}
142
143impl fidl::Persistable for ProductInfo {}
144
145pub mod board_ordinals {
146 pub const GET_INFO: u64 = 0x878a093531d0904;
147}
148
149pub mod device_ordinals {
150 pub const GET_INFO: u64 = 0x4cc66c5e52b0a7d1;
151}
152
153pub mod product_ordinals {
154 pub const GET_INFO: u64 = 0x11a4825cda315828;
155}
156
157mod internal {
158 use super::*;
159 unsafe impl fidl::encoding::TypeMarker for Architecture {
160 type Owned = Self;
161
162 #[inline(always)]
163 fn inline_align(_context: fidl::encoding::Context) -> usize {
164 std::mem::align_of::<u32>()
165 }
166
167 #[inline(always)]
168 fn inline_size(_context: fidl::encoding::Context) -> usize {
169 std::mem::size_of::<u32>()
170 }
171
172 #[inline(always)]
173 fn encode_is_copy() -> bool {
174 false
175 }
176
177 #[inline(always)]
178 fn decode_is_copy() -> bool {
179 false
180 }
181 }
182
183 impl fidl::encoding::ValueTypeMarker for Architecture {
184 type Borrowed<'a> = Self;
185 #[inline(always)]
186 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
187 *value
188 }
189 }
190
191 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Architecture {
192 #[inline]
193 unsafe fn encode(
194 self,
195 encoder: &mut fidl::encoding::Encoder<'_, D>,
196 offset: usize,
197 _depth: fidl::encoding::Depth,
198 ) -> fidl::Result<()> {
199 encoder.debug_check_bounds::<Self>(offset);
200 encoder.write_num(self.into_primitive(), offset);
201 Ok(())
202 }
203 }
204
205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Architecture {
206 #[inline(always)]
207 fn new_empty() -> Self {
208 Self::unknown()
209 }
210
211 #[inline]
212 unsafe fn decode(
213 &mut self,
214 decoder: &mut fidl::encoding::Decoder<'_, D>,
215 offset: usize,
216 _depth: fidl::encoding::Depth,
217 ) -> fidl::Result<()> {
218 decoder.debug_check_bounds::<Self>(offset);
219 let prim = decoder.read_num::<u32>(offset);
220
221 *self = Self::from_primitive_allow_unknown(prim);
222 Ok(())
223 }
224 }
225
226 impl fidl::encoding::ValueTypeMarker for BoardGetInfoResponse {
227 type Borrowed<'a> = &'a Self;
228 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
229 value
230 }
231 }
232
233 unsafe impl fidl::encoding::TypeMarker for BoardGetInfoResponse {
234 type Owned = Self;
235
236 #[inline(always)]
237 fn inline_align(_context: fidl::encoding::Context) -> usize {
238 8
239 }
240
241 #[inline(always)]
242 fn inline_size(_context: fidl::encoding::Context) -> usize {
243 16
244 }
245 }
246
247 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoardGetInfoResponse, D>
248 for &BoardGetInfoResponse
249 {
250 #[inline]
251 unsafe fn encode(
252 self,
253 encoder: &mut fidl::encoding::Encoder<'_, D>,
254 offset: usize,
255 _depth: fidl::encoding::Depth,
256 ) -> fidl::Result<()> {
257 encoder.debug_check_bounds::<BoardGetInfoResponse>(offset);
258 fidl::encoding::Encode::<BoardGetInfoResponse, D>::encode(
260 (<BoardInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
261 encoder,
262 offset,
263 _depth,
264 )
265 }
266 }
267 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BoardInfo, D>>
268 fidl::encoding::Encode<BoardGetInfoResponse, D> for (T0,)
269 {
270 #[inline]
271 unsafe fn encode(
272 self,
273 encoder: &mut fidl::encoding::Encoder<'_, D>,
274 offset: usize,
275 depth: fidl::encoding::Depth,
276 ) -> fidl::Result<()> {
277 encoder.debug_check_bounds::<BoardGetInfoResponse>(offset);
278 self.0.encode(encoder, offset + 0, depth)?;
282 Ok(())
283 }
284 }
285
286 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoardGetInfoResponse {
287 #[inline(always)]
288 fn new_empty() -> Self {
289 Self { info: fidl::new_empty!(BoardInfo, D) }
290 }
291
292 #[inline]
293 unsafe fn decode(
294 &mut self,
295 decoder: &mut fidl::encoding::Decoder<'_, D>,
296 offset: usize,
297 _depth: fidl::encoding::Depth,
298 ) -> fidl::Result<()> {
299 decoder.debug_check_bounds::<Self>(offset);
300 fidl::decode!(BoardInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
302 Ok(())
303 }
304 }
305
306 impl fidl::encoding::ValueTypeMarker for DeviceGetInfoResponse {
307 type Borrowed<'a> = &'a Self;
308 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
309 value
310 }
311 }
312
313 unsafe impl fidl::encoding::TypeMarker for DeviceGetInfoResponse {
314 type Owned = Self;
315
316 #[inline(always)]
317 fn inline_align(_context: fidl::encoding::Context) -> usize {
318 8
319 }
320
321 #[inline(always)]
322 fn inline_size(_context: fidl::encoding::Context) -> usize {
323 16
324 }
325 }
326
327 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceGetInfoResponse, D>
328 for &DeviceGetInfoResponse
329 {
330 #[inline]
331 unsafe fn encode(
332 self,
333 encoder: &mut fidl::encoding::Encoder<'_, D>,
334 offset: usize,
335 _depth: fidl::encoding::Depth,
336 ) -> fidl::Result<()> {
337 encoder.debug_check_bounds::<DeviceGetInfoResponse>(offset);
338 fidl::encoding::Encode::<DeviceGetInfoResponse, D>::encode(
340 (<DeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
341 encoder,
342 offset,
343 _depth,
344 )
345 }
346 }
347 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceInfo, D>>
348 fidl::encoding::Encode<DeviceGetInfoResponse, D> for (T0,)
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::<DeviceGetInfoResponse>(offset);
358 self.0.encode(encoder, offset + 0, depth)?;
362 Ok(())
363 }
364 }
365
366 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceGetInfoResponse {
367 #[inline(always)]
368 fn new_empty() -> Self {
369 Self { info: fidl::new_empty!(DeviceInfo, D) }
370 }
371
372 #[inline]
373 unsafe fn decode(
374 &mut self,
375 decoder: &mut fidl::encoding::Decoder<'_, D>,
376 offset: usize,
377 _depth: fidl::encoding::Depth,
378 ) -> fidl::Result<()> {
379 decoder.debug_check_bounds::<Self>(offset);
380 fidl::decode!(DeviceInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
382 Ok(())
383 }
384 }
385
386 impl fidl::encoding::ValueTypeMarker for ProductGetInfoResponse {
387 type Borrowed<'a> = &'a Self;
388 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
389 value
390 }
391 }
392
393 unsafe impl fidl::encoding::TypeMarker for ProductGetInfoResponse {
394 type Owned = Self;
395
396 #[inline(always)]
397 fn inline_align(_context: fidl::encoding::Context) -> usize {
398 8
399 }
400
401 #[inline(always)]
402 fn inline_size(_context: fidl::encoding::Context) -> usize {
403 16
404 }
405 }
406
407 unsafe impl<D: fidl::encoding::ResourceDialect>
408 fidl::encoding::Encode<ProductGetInfoResponse, D> for &ProductGetInfoResponse
409 {
410 #[inline]
411 unsafe fn encode(
412 self,
413 encoder: &mut fidl::encoding::Encoder<'_, D>,
414 offset: usize,
415 _depth: fidl::encoding::Depth,
416 ) -> fidl::Result<()> {
417 encoder.debug_check_bounds::<ProductGetInfoResponse>(offset);
418 fidl::encoding::Encode::<ProductGetInfoResponse, D>::encode(
420 (<ProductInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
421 encoder,
422 offset,
423 _depth,
424 )
425 }
426 }
427 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProductInfo, D>>
428 fidl::encoding::Encode<ProductGetInfoResponse, D> for (T0,)
429 {
430 #[inline]
431 unsafe fn encode(
432 self,
433 encoder: &mut fidl::encoding::Encoder<'_, D>,
434 offset: usize,
435 depth: fidl::encoding::Depth,
436 ) -> fidl::Result<()> {
437 encoder.debug_check_bounds::<ProductGetInfoResponse>(offset);
438 self.0.encode(encoder, offset + 0, depth)?;
442 Ok(())
443 }
444 }
445
446 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
447 for ProductGetInfoResponse
448 {
449 #[inline(always)]
450 fn new_empty() -> Self {
451 Self { info: fidl::new_empty!(ProductInfo, D) }
452 }
453
454 #[inline]
455 unsafe fn decode(
456 &mut self,
457 decoder: &mut fidl::encoding::Decoder<'_, D>,
458 offset: usize,
459 _depth: fidl::encoding::Depth,
460 ) -> fidl::Result<()> {
461 decoder.debug_check_bounds::<Self>(offset);
462 fidl::decode!(ProductInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
464 Ok(())
465 }
466 }
467
468 impl BoardInfo {
469 #[inline(always)]
470 fn max_ordinal_present(&self) -> u64 {
471 if let Some(_) = self.cpu_architecture {
472 return 3;
473 }
474 if let Some(_) = self.revision {
475 return 2;
476 }
477 if let Some(_) = self.name {
478 return 1;
479 }
480 0
481 }
482 }
483
484 impl fidl::encoding::ValueTypeMarker for BoardInfo {
485 type Borrowed<'a> = &'a Self;
486 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
487 value
488 }
489 }
490
491 unsafe impl fidl::encoding::TypeMarker for BoardInfo {
492 type Owned = Self;
493
494 #[inline(always)]
495 fn inline_align(_context: fidl::encoding::Context) -> usize {
496 8
497 }
498
499 #[inline(always)]
500 fn inline_size(_context: fidl::encoding::Context) -> usize {
501 16
502 }
503 }
504
505 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoardInfo, D>
506 for &BoardInfo
507 {
508 unsafe fn encode(
509 self,
510 encoder: &mut fidl::encoding::Encoder<'_, D>,
511 offset: usize,
512 mut depth: fidl::encoding::Depth,
513 ) -> fidl::Result<()> {
514 encoder.debug_check_bounds::<BoardInfo>(offset);
515 let max_ordinal: u64 = self.max_ordinal_present();
517 encoder.write_num(max_ordinal, offset);
518 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
519 if max_ordinal == 0 {
521 return Ok(());
522 }
523 depth.increment()?;
524 let envelope_size = 8;
525 let bytes_len = max_ordinal as usize * envelope_size;
526 #[allow(unused_variables)]
527 let offset = encoder.out_of_line_offset(bytes_len);
528 let mut _prev_end_offset: usize = 0;
529 if 1 > max_ordinal {
530 return Ok(());
531 }
532
533 let cur_offset: usize = (1 - 1) * envelope_size;
536
537 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
539
540 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
545 self.name.as_ref().map(
546 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
547 ),
548 encoder,
549 offset + cur_offset,
550 depth,
551 )?;
552
553 _prev_end_offset = cur_offset + envelope_size;
554 if 2 > max_ordinal {
555 return Ok(());
556 }
557
558 let cur_offset: usize = (2 - 1) * envelope_size;
561
562 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
564
565 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
570 self.revision.as_ref().map(
571 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
572 ),
573 encoder,
574 offset + cur_offset,
575 depth,
576 )?;
577
578 _prev_end_offset = cur_offset + envelope_size;
579 if 3 > max_ordinal {
580 return Ok(());
581 }
582
583 let cur_offset: usize = (3 - 1) * envelope_size;
586
587 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
589
590 fidl::encoding::encode_in_envelope_optional::<Architecture, D>(
595 self.cpu_architecture
596 .as_ref()
597 .map(<Architecture as fidl::encoding::ValueTypeMarker>::borrow),
598 encoder,
599 offset + cur_offset,
600 depth,
601 )?;
602
603 _prev_end_offset = cur_offset + envelope_size;
604
605 Ok(())
606 }
607 }
608
609 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoardInfo {
610 #[inline(always)]
611 fn new_empty() -> Self {
612 Self::default()
613 }
614
615 unsafe fn decode(
616 &mut self,
617 decoder: &mut fidl::encoding::Decoder<'_, D>,
618 offset: usize,
619 mut depth: fidl::encoding::Depth,
620 ) -> fidl::Result<()> {
621 decoder.debug_check_bounds::<Self>(offset);
622 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
623 None => return Err(fidl::Error::NotNullable),
624 Some(len) => len,
625 };
626 if len == 0 {
628 return Ok(());
629 };
630 depth.increment()?;
631 let envelope_size = 8;
632 let bytes_len = len * envelope_size;
633 let offset = decoder.out_of_line_offset(bytes_len)?;
634 let mut _next_ordinal_to_read = 0;
636 let mut next_offset = offset;
637 let end_offset = offset + bytes_len;
638 _next_ordinal_to_read += 1;
639 if next_offset >= end_offset {
640 return Ok(());
641 }
642
643 while _next_ordinal_to_read < 1 {
645 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
646 _next_ordinal_to_read += 1;
647 next_offset += envelope_size;
648 }
649
650 let next_out_of_line = decoder.next_out_of_line();
651 let handles_before = decoder.remaining_handles();
652 if let Some((inlined, num_bytes, num_handles)) =
653 fidl::encoding::decode_envelope_header(decoder, next_offset)?
654 {
655 let member_inline_size =
656 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
657 decoder.context,
658 );
659 if inlined != (member_inline_size <= 4) {
660 return Err(fidl::Error::InvalidInlineBitInEnvelope);
661 }
662 let inner_offset;
663 let mut inner_depth = depth.clone();
664 if inlined {
665 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
666 inner_offset = next_offset;
667 } else {
668 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
669 inner_depth.increment()?;
670 }
671 let val_ref = self
672 .name
673 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
674 fidl::decode!(
675 fidl::encoding::UnboundedString,
676 D,
677 val_ref,
678 decoder,
679 inner_offset,
680 inner_depth
681 )?;
682 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
683 {
684 return Err(fidl::Error::InvalidNumBytesInEnvelope);
685 }
686 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
687 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
688 }
689 }
690
691 next_offset += envelope_size;
692 _next_ordinal_to_read += 1;
693 if next_offset >= end_offset {
694 return Ok(());
695 }
696
697 while _next_ordinal_to_read < 2 {
699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
700 _next_ordinal_to_read += 1;
701 next_offset += envelope_size;
702 }
703
704 let next_out_of_line = decoder.next_out_of_line();
705 let handles_before = decoder.remaining_handles();
706 if let Some((inlined, num_bytes, num_handles)) =
707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
708 {
709 let member_inline_size =
710 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
711 decoder.context,
712 );
713 if inlined != (member_inline_size <= 4) {
714 return Err(fidl::Error::InvalidInlineBitInEnvelope);
715 }
716 let inner_offset;
717 let mut inner_depth = depth.clone();
718 if inlined {
719 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
720 inner_offset = next_offset;
721 } else {
722 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
723 inner_depth.increment()?;
724 }
725 let val_ref = self
726 .revision
727 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
728 fidl::decode!(
729 fidl::encoding::UnboundedString,
730 D,
731 val_ref,
732 decoder,
733 inner_offset,
734 inner_depth
735 )?;
736 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
737 {
738 return Err(fidl::Error::InvalidNumBytesInEnvelope);
739 }
740 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
741 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
742 }
743 }
744
745 next_offset += envelope_size;
746 _next_ordinal_to_read += 1;
747 if next_offset >= end_offset {
748 return Ok(());
749 }
750
751 while _next_ordinal_to_read < 3 {
753 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
754 _next_ordinal_to_read += 1;
755 next_offset += envelope_size;
756 }
757
758 let next_out_of_line = decoder.next_out_of_line();
759 let handles_before = decoder.remaining_handles();
760 if let Some((inlined, num_bytes, num_handles)) =
761 fidl::encoding::decode_envelope_header(decoder, next_offset)?
762 {
763 let member_inline_size =
764 <Architecture as fidl::encoding::TypeMarker>::inline_size(decoder.context);
765 if inlined != (member_inline_size <= 4) {
766 return Err(fidl::Error::InvalidInlineBitInEnvelope);
767 }
768 let inner_offset;
769 let mut inner_depth = depth.clone();
770 if inlined {
771 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
772 inner_offset = next_offset;
773 } else {
774 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
775 inner_depth.increment()?;
776 }
777 let val_ref =
778 self.cpu_architecture.get_or_insert_with(|| fidl::new_empty!(Architecture, D));
779 fidl::decode!(Architecture, D, val_ref, decoder, inner_offset, inner_depth)?;
780 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
781 {
782 return Err(fidl::Error::InvalidNumBytesInEnvelope);
783 }
784 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
785 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
786 }
787 }
788
789 next_offset += envelope_size;
790
791 while next_offset < end_offset {
793 _next_ordinal_to_read += 1;
794 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
795 next_offset += envelope_size;
796 }
797
798 Ok(())
799 }
800 }
801
802 impl DeviceInfo {
803 #[inline(always)]
804 fn max_ordinal_present(&self) -> u64 {
805 if let Some(_) = self.retail_sku {
806 return 3;
807 }
808 if let Some(_) = self.is_retail_demo {
809 return 2;
810 }
811 if let Some(_) = self.serial_number {
812 return 1;
813 }
814 0
815 }
816 }
817
818 impl fidl::encoding::ValueTypeMarker for DeviceInfo {
819 type Borrowed<'a> = &'a Self;
820 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
821 value
822 }
823 }
824
825 unsafe impl fidl::encoding::TypeMarker for DeviceInfo {
826 type Owned = Self;
827
828 #[inline(always)]
829 fn inline_align(_context: fidl::encoding::Context) -> usize {
830 8
831 }
832
833 #[inline(always)]
834 fn inline_size(_context: fidl::encoding::Context) -> usize {
835 16
836 }
837 }
838
839 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceInfo, D>
840 for &DeviceInfo
841 {
842 unsafe fn encode(
843 self,
844 encoder: &mut fidl::encoding::Encoder<'_, D>,
845 offset: usize,
846 mut depth: fidl::encoding::Depth,
847 ) -> fidl::Result<()> {
848 encoder.debug_check_bounds::<DeviceInfo>(offset);
849 let max_ordinal: u64 = self.max_ordinal_present();
851 encoder.write_num(max_ordinal, offset);
852 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
853 if max_ordinal == 0 {
855 return Ok(());
856 }
857 depth.increment()?;
858 let envelope_size = 8;
859 let bytes_len = max_ordinal as usize * envelope_size;
860 #[allow(unused_variables)]
861 let offset = encoder.out_of_line_offset(bytes_len);
862 let mut _prev_end_offset: usize = 0;
863 if 1 > max_ordinal {
864 return Ok(());
865 }
866
867 let cur_offset: usize = (1 - 1) * envelope_size;
870
871 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
873
874 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
879 self.serial_number.as_ref().map(
880 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
881 ),
882 encoder,
883 offset + cur_offset,
884 depth,
885 )?;
886
887 _prev_end_offset = cur_offset + envelope_size;
888 if 2 > max_ordinal {
889 return Ok(());
890 }
891
892 let cur_offset: usize = (2 - 1) * envelope_size;
895
896 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
898
899 fidl::encoding::encode_in_envelope_optional::<bool, D>(
904 self.is_retail_demo.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
905 encoder,
906 offset + cur_offset,
907 depth,
908 )?;
909
910 _prev_end_offset = cur_offset + envelope_size;
911 if 3 > max_ordinal {
912 return Ok(());
913 }
914
915 let cur_offset: usize = (3 - 1) * envelope_size;
918
919 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
921
922 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
927 self.retail_sku.as_ref().map(
928 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
929 ),
930 encoder,
931 offset + cur_offset,
932 depth,
933 )?;
934
935 _prev_end_offset = cur_offset + envelope_size;
936
937 Ok(())
938 }
939 }
940
941 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceInfo {
942 #[inline(always)]
943 fn new_empty() -> Self {
944 Self::default()
945 }
946
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 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
955 None => return Err(fidl::Error::NotNullable),
956 Some(len) => len,
957 };
958 if len == 0 {
960 return Ok(());
961 };
962 depth.increment()?;
963 let envelope_size = 8;
964 let bytes_len = len * envelope_size;
965 let offset = decoder.out_of_line_offset(bytes_len)?;
966 let mut _next_ordinal_to_read = 0;
968 let mut next_offset = offset;
969 let end_offset = offset + bytes_len;
970 _next_ordinal_to_read += 1;
971 if next_offset >= end_offset {
972 return Ok(());
973 }
974
975 while _next_ordinal_to_read < 1 {
977 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
978 _next_ordinal_to_read += 1;
979 next_offset += envelope_size;
980 }
981
982 let next_out_of_line = decoder.next_out_of_line();
983 let handles_before = decoder.remaining_handles();
984 if let Some((inlined, num_bytes, num_handles)) =
985 fidl::encoding::decode_envelope_header(decoder, next_offset)?
986 {
987 let member_inline_size =
988 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
989 decoder.context,
990 );
991 if inlined != (member_inline_size <= 4) {
992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
993 }
994 let inner_offset;
995 let mut inner_depth = depth.clone();
996 if inlined {
997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
998 inner_offset = next_offset;
999 } else {
1000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1001 inner_depth.increment()?;
1002 }
1003 let val_ref = self
1004 .serial_number
1005 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1006 fidl::decode!(
1007 fidl::encoding::BoundedString<255>,
1008 D,
1009 val_ref,
1010 decoder,
1011 inner_offset,
1012 inner_depth
1013 )?;
1014 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1015 {
1016 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1017 }
1018 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1019 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1020 }
1021 }
1022
1023 next_offset += envelope_size;
1024 _next_ordinal_to_read += 1;
1025 if next_offset >= end_offset {
1026 return Ok(());
1027 }
1028
1029 while _next_ordinal_to_read < 2 {
1031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1032 _next_ordinal_to_read += 1;
1033 next_offset += envelope_size;
1034 }
1035
1036 let next_out_of_line = decoder.next_out_of_line();
1037 let handles_before = decoder.remaining_handles();
1038 if let Some((inlined, num_bytes, num_handles)) =
1039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1040 {
1041 let member_inline_size =
1042 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1043 if inlined != (member_inline_size <= 4) {
1044 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1045 }
1046 let inner_offset;
1047 let mut inner_depth = depth.clone();
1048 if inlined {
1049 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1050 inner_offset = next_offset;
1051 } else {
1052 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1053 inner_depth.increment()?;
1054 }
1055 let val_ref = self.is_retail_demo.get_or_insert_with(|| fidl::new_empty!(bool, D));
1056 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1057 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1058 {
1059 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1060 }
1061 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1062 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1063 }
1064 }
1065
1066 next_offset += envelope_size;
1067 _next_ordinal_to_read += 1;
1068 if next_offset >= end_offset {
1069 return Ok(());
1070 }
1071
1072 while _next_ordinal_to_read < 3 {
1074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1075 _next_ordinal_to_read += 1;
1076 next_offset += envelope_size;
1077 }
1078
1079 let next_out_of_line = decoder.next_out_of_line();
1080 let handles_before = decoder.remaining_handles();
1081 if let Some((inlined, num_bytes, num_handles)) =
1082 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1083 {
1084 let member_inline_size =
1085 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1086 decoder.context,
1087 );
1088 if inlined != (member_inline_size <= 4) {
1089 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1090 }
1091 let inner_offset;
1092 let mut inner_depth = depth.clone();
1093 if inlined {
1094 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1095 inner_offset = next_offset;
1096 } else {
1097 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1098 inner_depth.increment()?;
1099 }
1100 let val_ref = self
1101 .retail_sku
1102 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1103 fidl::decode!(
1104 fidl::encoding::BoundedString<255>,
1105 D,
1106 val_ref,
1107 decoder,
1108 inner_offset,
1109 inner_depth
1110 )?;
1111 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1112 {
1113 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1114 }
1115 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1116 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1117 }
1118 }
1119
1120 next_offset += envelope_size;
1121
1122 while next_offset < end_offset {
1124 _next_ordinal_to_read += 1;
1125 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1126 next_offset += envelope_size;
1127 }
1128
1129 Ok(())
1130 }
1131 }
1132
1133 impl ProductInfo {
1134 #[inline(always)]
1135 fn max_ordinal_present(&self) -> u64 {
1136 if let Some(_) = self.audio_amplifier {
1137 return 16;
1138 }
1139 if let Some(_) = self.microphone {
1140 return 15;
1141 }
1142 if let Some(_) = self.emmc_storage {
1143 return 14;
1144 }
1145 if let Some(_) = self.nand_storage {
1146 return 13;
1147 }
1148 if let Some(_) = self.memory {
1149 return 12;
1150 }
1151 if let Some(_) = self.display {
1152 return 11;
1153 }
1154 if let Some(_) = self.colorway {
1155 return 10;
1156 }
1157 if let Some(_) = self.build_name {
1158 return 9;
1159 }
1160 if let Some(_) = self.build_date {
1161 return 8;
1162 }
1163 if let Some(_) = self.manufacturer {
1164 return 7;
1165 }
1166 if let Some(_) = self.model {
1167 return 6;
1168 }
1169 if let Some(_) = self.name {
1170 return 5;
1171 }
1172 if let Some(_) = self.locale_list {
1173 return 4;
1174 }
1175 if let Some(_) = self.regulatory_domain {
1176 return 3;
1177 }
1178 if let Some(_) = self.language {
1179 return 2;
1180 }
1181 if let Some(_) = self.sku {
1182 return 1;
1183 }
1184 0
1185 }
1186 }
1187
1188 impl fidl::encoding::ValueTypeMarker for ProductInfo {
1189 type Borrowed<'a> = &'a Self;
1190 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1191 value
1192 }
1193 }
1194
1195 unsafe impl fidl::encoding::TypeMarker for ProductInfo {
1196 type Owned = Self;
1197
1198 #[inline(always)]
1199 fn inline_align(_context: fidl::encoding::Context) -> usize {
1200 8
1201 }
1202
1203 #[inline(always)]
1204 fn inline_size(_context: fidl::encoding::Context) -> usize {
1205 16
1206 }
1207 }
1208
1209 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProductInfo, D>
1210 for &ProductInfo
1211 {
1212 unsafe fn encode(
1213 self,
1214 encoder: &mut fidl::encoding::Encoder<'_, D>,
1215 offset: usize,
1216 mut depth: fidl::encoding::Depth,
1217 ) -> fidl::Result<()> {
1218 encoder.debug_check_bounds::<ProductInfo>(offset);
1219 let max_ordinal: u64 = self.max_ordinal_present();
1221 encoder.write_num(max_ordinal, offset);
1222 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1223 if max_ordinal == 0 {
1225 return Ok(());
1226 }
1227 depth.increment()?;
1228 let envelope_size = 8;
1229 let bytes_len = max_ordinal as usize * envelope_size;
1230 #[allow(unused_variables)]
1231 let offset = encoder.out_of_line_offset(bytes_len);
1232 let mut _prev_end_offset: usize = 0;
1233 if 1 > max_ordinal {
1234 return Ok(());
1235 }
1236
1237 let cur_offset: usize = (1 - 1) * envelope_size;
1240
1241 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1243
1244 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1249 self.sku.as_ref().map(
1250 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1251 ),
1252 encoder,
1253 offset + cur_offset,
1254 depth,
1255 )?;
1256
1257 _prev_end_offset = cur_offset + envelope_size;
1258 if 2 > max_ordinal {
1259 return Ok(());
1260 }
1261
1262 let cur_offset: usize = (2 - 1) * envelope_size;
1265
1266 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1268
1269 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1274 self.language.as_ref().map(
1275 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1276 ),
1277 encoder,
1278 offset + cur_offset,
1279 depth,
1280 )?;
1281
1282 _prev_end_offset = cur_offset + envelope_size;
1283 if 3 > max_ordinal {
1284 return Ok(());
1285 }
1286
1287 let cur_offset: usize = (3 - 1) * envelope_size;
1290
1291 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1293
1294 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_intl__common::RegulatoryDomain, D>(
1299 self.regulatory_domain.as_ref().map(<fidl_fuchsia_intl__common::RegulatoryDomain as fidl::encoding::ValueTypeMarker>::borrow),
1300 encoder, offset + cur_offset, depth
1301 )?;
1302
1303 _prev_end_offset = cur_offset + envelope_size;
1304 if 4 > max_ordinal {
1305 return Ok(());
1306 }
1307
1308 let cur_offset: usize = (4 - 1) * envelope_size;
1311
1312 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1314
1315 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>, D>(
1320 self.locale_list.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId> as fidl::encoding::ValueTypeMarker>::borrow),
1321 encoder, offset + cur_offset, depth
1322 )?;
1323
1324 _prev_end_offset = cur_offset + envelope_size;
1325 if 5 > max_ordinal {
1326 return Ok(());
1327 }
1328
1329 let cur_offset: usize = (5 - 1) * envelope_size;
1332
1333 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1335
1336 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1341 self.name.as_ref().map(
1342 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1343 ),
1344 encoder,
1345 offset + cur_offset,
1346 depth,
1347 )?;
1348
1349 _prev_end_offset = cur_offset + envelope_size;
1350 if 6 > max_ordinal {
1351 return Ok(());
1352 }
1353
1354 let cur_offset: usize = (6 - 1) * envelope_size;
1357
1358 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1360
1361 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1366 self.model.as_ref().map(
1367 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1368 ),
1369 encoder,
1370 offset + cur_offset,
1371 depth,
1372 )?;
1373
1374 _prev_end_offset = cur_offset + envelope_size;
1375 if 7 > max_ordinal {
1376 return Ok(());
1377 }
1378
1379 let cur_offset: usize = (7 - 1) * envelope_size;
1382
1383 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1385
1386 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1391 self.manufacturer.as_ref().map(
1392 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1393 ),
1394 encoder,
1395 offset + cur_offset,
1396 depth,
1397 )?;
1398
1399 _prev_end_offset = cur_offset + envelope_size;
1400 if 8 > max_ordinal {
1401 return Ok(());
1402 }
1403
1404 let cur_offset: usize = (8 - 1) * envelope_size;
1407
1408 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1410
1411 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1416 self.build_date.as_ref().map(
1417 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1418 ),
1419 encoder,
1420 offset + cur_offset,
1421 depth,
1422 )?;
1423
1424 _prev_end_offset = cur_offset + envelope_size;
1425 if 9 > max_ordinal {
1426 return Ok(());
1427 }
1428
1429 let cur_offset: usize = (9 - 1) * envelope_size;
1432
1433 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1435
1436 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1441 self.build_name.as_ref().map(
1442 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1443 ),
1444 encoder,
1445 offset + cur_offset,
1446 depth,
1447 )?;
1448
1449 _prev_end_offset = cur_offset + envelope_size;
1450 if 10 > max_ordinal {
1451 return Ok(());
1452 }
1453
1454 let cur_offset: usize = (10 - 1) * envelope_size;
1457
1458 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1460
1461 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1466 self.colorway.as_ref().map(
1467 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1468 ),
1469 encoder,
1470 offset + cur_offset,
1471 depth,
1472 )?;
1473
1474 _prev_end_offset = cur_offset + envelope_size;
1475 if 11 > max_ordinal {
1476 return Ok(());
1477 }
1478
1479 let cur_offset: usize = (11 - 1) * envelope_size;
1482
1483 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1485
1486 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1491 self.display.as_ref().map(
1492 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1493 ),
1494 encoder,
1495 offset + cur_offset,
1496 depth,
1497 )?;
1498
1499 _prev_end_offset = cur_offset + envelope_size;
1500 if 12 > max_ordinal {
1501 return Ok(());
1502 }
1503
1504 let cur_offset: usize = (12 - 1) * envelope_size;
1507
1508 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1510
1511 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1516 self.memory.as_ref().map(
1517 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1518 ),
1519 encoder,
1520 offset + cur_offset,
1521 depth,
1522 )?;
1523
1524 _prev_end_offset = cur_offset + envelope_size;
1525 if 13 > max_ordinal {
1526 return Ok(());
1527 }
1528
1529 let cur_offset: usize = (13 - 1) * envelope_size;
1532
1533 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1535
1536 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1541 self.nand_storage.as_ref().map(
1542 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1543 ),
1544 encoder,
1545 offset + cur_offset,
1546 depth,
1547 )?;
1548
1549 _prev_end_offset = cur_offset + envelope_size;
1550 if 14 > max_ordinal {
1551 return Ok(());
1552 }
1553
1554 let cur_offset: usize = (14 - 1) * envelope_size;
1557
1558 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1560
1561 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1566 self.emmc_storage.as_ref().map(
1567 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1568 ),
1569 encoder,
1570 offset + cur_offset,
1571 depth,
1572 )?;
1573
1574 _prev_end_offset = cur_offset + envelope_size;
1575 if 15 > max_ordinal {
1576 return Ok(());
1577 }
1578
1579 let cur_offset: usize = (15 - 1) * envelope_size;
1582
1583 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1585
1586 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1591 self.microphone.as_ref().map(
1592 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1593 ),
1594 encoder,
1595 offset + cur_offset,
1596 depth,
1597 )?;
1598
1599 _prev_end_offset = cur_offset + envelope_size;
1600 if 16 > max_ordinal {
1601 return Ok(());
1602 }
1603
1604 let cur_offset: usize = (16 - 1) * envelope_size;
1607
1608 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1610
1611 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1616 self.audio_amplifier.as_ref().map(
1617 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1618 ),
1619 encoder,
1620 offset + cur_offset,
1621 depth,
1622 )?;
1623
1624 _prev_end_offset = cur_offset + envelope_size;
1625
1626 Ok(())
1627 }
1628 }
1629
1630 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProductInfo {
1631 #[inline(always)]
1632 fn new_empty() -> Self {
1633 Self::default()
1634 }
1635
1636 unsafe fn decode(
1637 &mut self,
1638 decoder: &mut fidl::encoding::Decoder<'_, D>,
1639 offset: usize,
1640 mut depth: fidl::encoding::Depth,
1641 ) -> fidl::Result<()> {
1642 decoder.debug_check_bounds::<Self>(offset);
1643 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1644 None => return Err(fidl::Error::NotNullable),
1645 Some(len) => len,
1646 };
1647 if len == 0 {
1649 return Ok(());
1650 };
1651 depth.increment()?;
1652 let envelope_size = 8;
1653 let bytes_len = len * envelope_size;
1654 let offset = decoder.out_of_line_offset(bytes_len)?;
1655 let mut _next_ordinal_to_read = 0;
1657 let mut next_offset = offset;
1658 let end_offset = offset + bytes_len;
1659 _next_ordinal_to_read += 1;
1660 if next_offset >= end_offset {
1661 return Ok(());
1662 }
1663
1664 while _next_ordinal_to_read < 1 {
1666 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1667 _next_ordinal_to_read += 1;
1668 next_offset += envelope_size;
1669 }
1670
1671 let next_out_of_line = decoder.next_out_of_line();
1672 let handles_before = decoder.remaining_handles();
1673 if let Some((inlined, num_bytes, num_handles)) =
1674 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1675 {
1676 let member_inline_size =
1677 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1678 decoder.context,
1679 );
1680 if inlined != (member_inline_size <= 4) {
1681 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1682 }
1683 let inner_offset;
1684 let mut inner_depth = depth.clone();
1685 if inlined {
1686 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1687 inner_offset = next_offset;
1688 } else {
1689 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1690 inner_depth.increment()?;
1691 }
1692 let val_ref = self
1693 .sku
1694 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1695 fidl::decode!(
1696 fidl::encoding::UnboundedString,
1697 D,
1698 val_ref,
1699 decoder,
1700 inner_offset,
1701 inner_depth
1702 )?;
1703 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1704 {
1705 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1706 }
1707 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1708 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1709 }
1710 }
1711
1712 next_offset += envelope_size;
1713 _next_ordinal_to_read += 1;
1714 if next_offset >= end_offset {
1715 return Ok(());
1716 }
1717
1718 while _next_ordinal_to_read < 2 {
1720 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1721 _next_ordinal_to_read += 1;
1722 next_offset += envelope_size;
1723 }
1724
1725 let next_out_of_line = decoder.next_out_of_line();
1726 let handles_before = decoder.remaining_handles();
1727 if let Some((inlined, num_bytes, num_handles)) =
1728 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1729 {
1730 let member_inline_size =
1731 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1732 decoder.context,
1733 );
1734 if inlined != (member_inline_size <= 4) {
1735 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1736 }
1737 let inner_offset;
1738 let mut inner_depth = depth.clone();
1739 if inlined {
1740 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1741 inner_offset = next_offset;
1742 } else {
1743 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1744 inner_depth.increment()?;
1745 }
1746 let val_ref = self
1747 .language
1748 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1749 fidl::decode!(
1750 fidl::encoding::UnboundedString,
1751 D,
1752 val_ref,
1753 decoder,
1754 inner_offset,
1755 inner_depth
1756 )?;
1757 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1758 {
1759 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1760 }
1761 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1762 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1763 }
1764 }
1765
1766 next_offset += envelope_size;
1767 _next_ordinal_to_read += 1;
1768 if next_offset >= end_offset {
1769 return Ok(());
1770 }
1771
1772 while _next_ordinal_to_read < 3 {
1774 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1775 _next_ordinal_to_read += 1;
1776 next_offset += envelope_size;
1777 }
1778
1779 let next_out_of_line = decoder.next_out_of_line();
1780 let handles_before = decoder.remaining_handles();
1781 if let Some((inlined, num_bytes, num_handles)) =
1782 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1783 {
1784 let member_inline_size = <fidl_fuchsia_intl__common::RegulatoryDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1785 if inlined != (member_inline_size <= 4) {
1786 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1787 }
1788 let inner_offset;
1789 let mut inner_depth = depth.clone();
1790 if inlined {
1791 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1792 inner_offset = next_offset;
1793 } else {
1794 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1795 inner_depth.increment()?;
1796 }
1797 let val_ref = self.regulatory_domain.get_or_insert_with(|| {
1798 fidl::new_empty!(fidl_fuchsia_intl__common::RegulatoryDomain, D)
1799 });
1800 fidl::decode!(
1801 fidl_fuchsia_intl__common::RegulatoryDomain,
1802 D,
1803 val_ref,
1804 decoder,
1805 inner_offset,
1806 inner_depth
1807 )?;
1808 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1809 {
1810 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1811 }
1812 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1813 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1814 }
1815 }
1816
1817 next_offset += envelope_size;
1818 _next_ordinal_to_read += 1;
1819 if next_offset >= end_offset {
1820 return Ok(());
1821 }
1822
1823 while _next_ordinal_to_read < 4 {
1825 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1826 _next_ordinal_to_read += 1;
1827 next_offset += envelope_size;
1828 }
1829
1830 let next_out_of_line = decoder.next_out_of_line();
1831 let handles_before = decoder.remaining_handles();
1832 if let Some((inlined, num_bytes, num_handles)) =
1833 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1834 {
1835 let member_inline_size = <fidl::encoding::UnboundedVector<
1836 fidl_fuchsia_intl__common::LocaleId,
1837 > as fidl::encoding::TypeMarker>::inline_size(
1838 decoder.context
1839 );
1840 if inlined != (member_inline_size <= 4) {
1841 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1842 }
1843 let inner_offset;
1844 let mut inner_depth = depth.clone();
1845 if inlined {
1846 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1847 inner_offset = next_offset;
1848 } else {
1849 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1850 inner_depth.increment()?;
1851 }
1852 let val_ref = self.locale_list.get_or_insert_with(|| {
1853 fidl::new_empty!(
1854 fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
1855 D
1856 )
1857 });
1858 fidl::decode!(
1859 fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
1860 D,
1861 val_ref,
1862 decoder,
1863 inner_offset,
1864 inner_depth
1865 )?;
1866 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1867 {
1868 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1869 }
1870 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1871 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1872 }
1873 }
1874
1875 next_offset += envelope_size;
1876 _next_ordinal_to_read += 1;
1877 if next_offset >= end_offset {
1878 return Ok(());
1879 }
1880
1881 while _next_ordinal_to_read < 5 {
1883 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1884 _next_ordinal_to_read += 1;
1885 next_offset += envelope_size;
1886 }
1887
1888 let next_out_of_line = decoder.next_out_of_line();
1889 let handles_before = decoder.remaining_handles();
1890 if let Some((inlined, num_bytes, num_handles)) =
1891 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1892 {
1893 let member_inline_size =
1894 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1895 decoder.context,
1896 );
1897 if inlined != (member_inline_size <= 4) {
1898 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1899 }
1900 let inner_offset;
1901 let mut inner_depth = depth.clone();
1902 if inlined {
1903 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1904 inner_offset = next_offset;
1905 } else {
1906 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1907 inner_depth.increment()?;
1908 }
1909 let val_ref = self
1910 .name
1911 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1912 fidl::decode!(
1913 fidl::encoding::UnboundedString,
1914 D,
1915 val_ref,
1916 decoder,
1917 inner_offset,
1918 inner_depth
1919 )?;
1920 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1921 {
1922 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1923 }
1924 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1925 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1926 }
1927 }
1928
1929 next_offset += envelope_size;
1930 _next_ordinal_to_read += 1;
1931 if next_offset >= end_offset {
1932 return Ok(());
1933 }
1934
1935 while _next_ordinal_to_read < 6 {
1937 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1938 _next_ordinal_to_read += 1;
1939 next_offset += envelope_size;
1940 }
1941
1942 let next_out_of_line = decoder.next_out_of_line();
1943 let handles_before = decoder.remaining_handles();
1944 if let Some((inlined, num_bytes, num_handles)) =
1945 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1946 {
1947 let member_inline_size =
1948 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1949 decoder.context,
1950 );
1951 if inlined != (member_inline_size <= 4) {
1952 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1953 }
1954 let inner_offset;
1955 let mut inner_depth = depth.clone();
1956 if inlined {
1957 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1958 inner_offset = next_offset;
1959 } else {
1960 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1961 inner_depth.increment()?;
1962 }
1963 let val_ref = self
1964 .model
1965 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1966 fidl::decode!(
1967 fidl::encoding::UnboundedString,
1968 D,
1969 val_ref,
1970 decoder,
1971 inner_offset,
1972 inner_depth
1973 )?;
1974 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1975 {
1976 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1977 }
1978 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1979 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1980 }
1981 }
1982
1983 next_offset += envelope_size;
1984 _next_ordinal_to_read += 1;
1985 if next_offset >= end_offset {
1986 return Ok(());
1987 }
1988
1989 while _next_ordinal_to_read < 7 {
1991 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1992 _next_ordinal_to_read += 1;
1993 next_offset += envelope_size;
1994 }
1995
1996 let next_out_of_line = decoder.next_out_of_line();
1997 let handles_before = decoder.remaining_handles();
1998 if let Some((inlined, num_bytes, num_handles)) =
1999 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2000 {
2001 let member_inline_size =
2002 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2003 decoder.context,
2004 );
2005 if inlined != (member_inline_size <= 4) {
2006 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2007 }
2008 let inner_offset;
2009 let mut inner_depth = depth.clone();
2010 if inlined {
2011 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2012 inner_offset = next_offset;
2013 } else {
2014 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2015 inner_depth.increment()?;
2016 }
2017 let val_ref = self
2018 .manufacturer
2019 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2020 fidl::decode!(
2021 fidl::encoding::UnboundedString,
2022 D,
2023 val_ref,
2024 decoder,
2025 inner_offset,
2026 inner_depth
2027 )?;
2028 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2029 {
2030 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2031 }
2032 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2033 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2034 }
2035 }
2036
2037 next_offset += envelope_size;
2038 _next_ordinal_to_read += 1;
2039 if next_offset >= end_offset {
2040 return Ok(());
2041 }
2042
2043 while _next_ordinal_to_read < 8 {
2045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2046 _next_ordinal_to_read += 1;
2047 next_offset += envelope_size;
2048 }
2049
2050 let next_out_of_line = decoder.next_out_of_line();
2051 let handles_before = decoder.remaining_handles();
2052 if let Some((inlined, num_bytes, num_handles)) =
2053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2054 {
2055 let member_inline_size =
2056 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2057 decoder.context,
2058 );
2059 if inlined != (member_inline_size <= 4) {
2060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2061 }
2062 let inner_offset;
2063 let mut inner_depth = depth.clone();
2064 if inlined {
2065 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2066 inner_offset = next_offset;
2067 } else {
2068 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2069 inner_depth.increment()?;
2070 }
2071 let val_ref = self
2072 .build_date
2073 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2074 fidl::decode!(
2075 fidl::encoding::UnboundedString,
2076 D,
2077 val_ref,
2078 decoder,
2079 inner_offset,
2080 inner_depth
2081 )?;
2082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2083 {
2084 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2085 }
2086 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2087 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2088 }
2089 }
2090
2091 next_offset += envelope_size;
2092 _next_ordinal_to_read += 1;
2093 if next_offset >= end_offset {
2094 return Ok(());
2095 }
2096
2097 while _next_ordinal_to_read < 9 {
2099 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2100 _next_ordinal_to_read += 1;
2101 next_offset += envelope_size;
2102 }
2103
2104 let next_out_of_line = decoder.next_out_of_line();
2105 let handles_before = decoder.remaining_handles();
2106 if let Some((inlined, num_bytes, num_handles)) =
2107 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2108 {
2109 let member_inline_size =
2110 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2111 decoder.context,
2112 );
2113 if inlined != (member_inline_size <= 4) {
2114 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2115 }
2116 let inner_offset;
2117 let mut inner_depth = depth.clone();
2118 if inlined {
2119 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2120 inner_offset = next_offset;
2121 } else {
2122 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2123 inner_depth.increment()?;
2124 }
2125 let val_ref = self
2126 .build_name
2127 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2128 fidl::decode!(
2129 fidl::encoding::BoundedString<255>,
2130 D,
2131 val_ref,
2132 decoder,
2133 inner_offset,
2134 inner_depth
2135 )?;
2136 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2137 {
2138 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2139 }
2140 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2141 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2142 }
2143 }
2144
2145 next_offset += envelope_size;
2146 _next_ordinal_to_read += 1;
2147 if next_offset >= end_offset {
2148 return Ok(());
2149 }
2150
2151 while _next_ordinal_to_read < 10 {
2153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2154 _next_ordinal_to_read += 1;
2155 next_offset += envelope_size;
2156 }
2157
2158 let next_out_of_line = decoder.next_out_of_line();
2159 let handles_before = decoder.remaining_handles();
2160 if let Some((inlined, num_bytes, num_handles)) =
2161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2162 {
2163 let member_inline_size =
2164 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2165 decoder.context,
2166 );
2167 if inlined != (member_inline_size <= 4) {
2168 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2169 }
2170 let inner_offset;
2171 let mut inner_depth = depth.clone();
2172 if inlined {
2173 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2174 inner_offset = next_offset;
2175 } else {
2176 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2177 inner_depth.increment()?;
2178 }
2179 let val_ref = self
2180 .colorway
2181 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2182 fidl::decode!(
2183 fidl::encoding::BoundedString<255>,
2184 D,
2185 val_ref,
2186 decoder,
2187 inner_offset,
2188 inner_depth
2189 )?;
2190 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2191 {
2192 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2193 }
2194 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2195 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2196 }
2197 }
2198
2199 next_offset += envelope_size;
2200 _next_ordinal_to_read += 1;
2201 if next_offset >= end_offset {
2202 return Ok(());
2203 }
2204
2205 while _next_ordinal_to_read < 11 {
2207 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2208 _next_ordinal_to_read += 1;
2209 next_offset += envelope_size;
2210 }
2211
2212 let next_out_of_line = decoder.next_out_of_line();
2213 let handles_before = decoder.remaining_handles();
2214 if let Some((inlined, num_bytes, num_handles)) =
2215 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2216 {
2217 let member_inline_size =
2218 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2219 decoder.context,
2220 );
2221 if inlined != (member_inline_size <= 4) {
2222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2223 }
2224 let inner_offset;
2225 let mut inner_depth = depth.clone();
2226 if inlined {
2227 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2228 inner_offset = next_offset;
2229 } else {
2230 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2231 inner_depth.increment()?;
2232 }
2233 let val_ref = self
2234 .display
2235 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2236 fidl::decode!(
2237 fidl::encoding::BoundedString<255>,
2238 D,
2239 val_ref,
2240 decoder,
2241 inner_offset,
2242 inner_depth
2243 )?;
2244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2245 {
2246 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2247 }
2248 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2249 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2250 }
2251 }
2252
2253 next_offset += envelope_size;
2254 _next_ordinal_to_read += 1;
2255 if next_offset >= end_offset {
2256 return Ok(());
2257 }
2258
2259 while _next_ordinal_to_read < 12 {
2261 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2262 _next_ordinal_to_read += 1;
2263 next_offset += envelope_size;
2264 }
2265
2266 let next_out_of_line = decoder.next_out_of_line();
2267 let handles_before = decoder.remaining_handles();
2268 if let Some((inlined, num_bytes, num_handles)) =
2269 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2270 {
2271 let member_inline_size =
2272 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2273 decoder.context,
2274 );
2275 if inlined != (member_inline_size <= 4) {
2276 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2277 }
2278 let inner_offset;
2279 let mut inner_depth = depth.clone();
2280 if inlined {
2281 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2282 inner_offset = next_offset;
2283 } else {
2284 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2285 inner_depth.increment()?;
2286 }
2287 let val_ref = self
2288 .memory
2289 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2290 fidl::decode!(
2291 fidl::encoding::BoundedString<255>,
2292 D,
2293 val_ref,
2294 decoder,
2295 inner_offset,
2296 inner_depth
2297 )?;
2298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2299 {
2300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2301 }
2302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2304 }
2305 }
2306
2307 next_offset += envelope_size;
2308 _next_ordinal_to_read += 1;
2309 if next_offset >= end_offset {
2310 return Ok(());
2311 }
2312
2313 while _next_ordinal_to_read < 13 {
2315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2316 _next_ordinal_to_read += 1;
2317 next_offset += envelope_size;
2318 }
2319
2320 let next_out_of_line = decoder.next_out_of_line();
2321 let handles_before = decoder.remaining_handles();
2322 if let Some((inlined, num_bytes, num_handles)) =
2323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2324 {
2325 let member_inline_size =
2326 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2327 decoder.context,
2328 );
2329 if inlined != (member_inline_size <= 4) {
2330 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2331 }
2332 let inner_offset;
2333 let mut inner_depth = depth.clone();
2334 if inlined {
2335 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2336 inner_offset = next_offset;
2337 } else {
2338 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2339 inner_depth.increment()?;
2340 }
2341 let val_ref = self
2342 .nand_storage
2343 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2344 fidl::decode!(
2345 fidl::encoding::BoundedString<255>,
2346 D,
2347 val_ref,
2348 decoder,
2349 inner_offset,
2350 inner_depth
2351 )?;
2352 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2353 {
2354 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2355 }
2356 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2357 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2358 }
2359 }
2360
2361 next_offset += envelope_size;
2362 _next_ordinal_to_read += 1;
2363 if next_offset >= end_offset {
2364 return Ok(());
2365 }
2366
2367 while _next_ordinal_to_read < 14 {
2369 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2370 _next_ordinal_to_read += 1;
2371 next_offset += envelope_size;
2372 }
2373
2374 let next_out_of_line = decoder.next_out_of_line();
2375 let handles_before = decoder.remaining_handles();
2376 if let Some((inlined, num_bytes, num_handles)) =
2377 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2378 {
2379 let member_inline_size =
2380 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2381 decoder.context,
2382 );
2383 if inlined != (member_inline_size <= 4) {
2384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2385 }
2386 let inner_offset;
2387 let mut inner_depth = depth.clone();
2388 if inlined {
2389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2390 inner_offset = next_offset;
2391 } else {
2392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2393 inner_depth.increment()?;
2394 }
2395 let val_ref = self
2396 .emmc_storage
2397 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2398 fidl::decode!(
2399 fidl::encoding::BoundedString<255>,
2400 D,
2401 val_ref,
2402 decoder,
2403 inner_offset,
2404 inner_depth
2405 )?;
2406 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2407 {
2408 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2409 }
2410 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2411 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2412 }
2413 }
2414
2415 next_offset += envelope_size;
2416 _next_ordinal_to_read += 1;
2417 if next_offset >= end_offset {
2418 return Ok(());
2419 }
2420
2421 while _next_ordinal_to_read < 15 {
2423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2424 _next_ordinal_to_read += 1;
2425 next_offset += envelope_size;
2426 }
2427
2428 let next_out_of_line = decoder.next_out_of_line();
2429 let handles_before = decoder.remaining_handles();
2430 if let Some((inlined, num_bytes, num_handles)) =
2431 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2432 {
2433 let member_inline_size =
2434 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2435 decoder.context,
2436 );
2437 if inlined != (member_inline_size <= 4) {
2438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2439 }
2440 let inner_offset;
2441 let mut inner_depth = depth.clone();
2442 if inlined {
2443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2444 inner_offset = next_offset;
2445 } else {
2446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2447 inner_depth.increment()?;
2448 }
2449 let val_ref = self
2450 .microphone
2451 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2452 fidl::decode!(
2453 fidl::encoding::BoundedString<255>,
2454 D,
2455 val_ref,
2456 decoder,
2457 inner_offset,
2458 inner_depth
2459 )?;
2460 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2461 {
2462 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2463 }
2464 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2465 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2466 }
2467 }
2468
2469 next_offset += envelope_size;
2470 _next_ordinal_to_read += 1;
2471 if next_offset >= end_offset {
2472 return Ok(());
2473 }
2474
2475 while _next_ordinal_to_read < 16 {
2477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2478 _next_ordinal_to_read += 1;
2479 next_offset += envelope_size;
2480 }
2481
2482 let next_out_of_line = decoder.next_out_of_line();
2483 let handles_before = decoder.remaining_handles();
2484 if let Some((inlined, num_bytes, num_handles)) =
2485 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2486 {
2487 let member_inline_size =
2488 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2489 decoder.context,
2490 );
2491 if inlined != (member_inline_size <= 4) {
2492 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2493 }
2494 let inner_offset;
2495 let mut inner_depth = depth.clone();
2496 if inlined {
2497 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2498 inner_offset = next_offset;
2499 } else {
2500 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2501 inner_depth.increment()?;
2502 }
2503 let val_ref = self
2504 .audio_amplifier
2505 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2506 fidl::decode!(
2507 fidl::encoding::BoundedString<255>,
2508 D,
2509 val_ref,
2510 decoder,
2511 inner_offset,
2512 inner_depth
2513 )?;
2514 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2515 {
2516 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2517 }
2518 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2519 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2520 }
2521 }
2522
2523 next_offset += envelope_size;
2524
2525 while next_offset < end_offset {
2527 _next_ordinal_to_read += 1;
2528 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2529 next_offset += envelope_size;
2530 }
2531
2532 Ok(())
2533 }
2534 }
2535}