fidl_fuchsia_buildinfo__common/
fidl_fuchsia_buildinfo__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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_STRING_LENGTH: u64 = 100;
12
13#[derive(Clone, Debug, PartialEq)]
14pub struct ProviderGetBuildInfoResponse {
15    pub build_info: BuildInfo,
16}
17
18impl fidl::Persistable for ProviderGetBuildInfoResponse {}
19
20#[derive(Clone, Debug, Default, PartialEq)]
21pub struct BuildInfo {
22    /// A description of the product configuration used at build time, determined
23    /// by the value passed as PRODUCT in 'fx set'. See 'fx list-products' for a
24    /// list of possible values.
25    pub product_config: Option<String>,
26    /// A description of the board configuration used at build time, determined by
27    /// the value passed as BOARD in 'fx set'. See `fx list-boards` for a list of
28    /// possible values.
29    pub board_config: Option<String>,
30    /// A description of the version of the build. Defaults to the same string as
31    /// latest_commit_date.
32    pub version: Option<String>,
33    /// The timestamp of the most recent commit to the integration repository
34    /// (specifically, the "CommitDate" field) formatted in strict ISO 8601 format in
35    /// the UTC timezone. Example: "2019-03-28T15:42:20+00:00"
36    pub latest_commit_date: Option<String>,
37    /// The version of the Fuchsia platform included in the build.
38    /// Provided by Assembly from platform artifacts.
39    pub platform_version: Option<String>,
40    /// The product version of this build.
41    /// Provided in Assembly product configuration.
42    /// Defaults to the same value as `version`.
43    pub product_version: Option<String>,
44    #[doc(hidden)]
45    pub __source_breaking: fidl::marker::SourceBreaking,
46}
47
48impl fidl::Persistable for BuildInfo {}
49
50pub mod provider_ordinals {
51    pub const GET_BUILD_INFO: u64 = 0x2cf46f6b8e681b93;
52}
53
54mod internal {
55    use super::*;
56
57    impl fidl::encoding::ValueTypeMarker for ProviderGetBuildInfoResponse {
58        type Borrowed<'a> = &'a Self;
59        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
60            value
61        }
62    }
63
64    unsafe impl fidl::encoding::TypeMarker for ProviderGetBuildInfoResponse {
65        type Owned = Self;
66
67        #[inline(always)]
68        fn inline_align(_context: fidl::encoding::Context) -> usize {
69            8
70        }
71
72        #[inline(always)]
73        fn inline_size(_context: fidl::encoding::Context) -> usize {
74            16
75        }
76    }
77
78    unsafe impl<D: fidl::encoding::ResourceDialect>
79        fidl::encoding::Encode<ProviderGetBuildInfoResponse, D> for &ProviderGetBuildInfoResponse
80    {
81        #[inline]
82        unsafe fn encode(
83            self,
84            encoder: &mut fidl::encoding::Encoder<'_, D>,
85            offset: usize,
86            _depth: fidl::encoding::Depth,
87        ) -> fidl::Result<()> {
88            encoder.debug_check_bounds::<ProviderGetBuildInfoResponse>(offset);
89            // Delegate to tuple encoding.
90            fidl::encoding::Encode::<ProviderGetBuildInfoResponse, D>::encode(
91                (<BuildInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.build_info),),
92                encoder,
93                offset,
94                _depth,
95            )
96        }
97    }
98    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BuildInfo, D>>
99        fidl::encoding::Encode<ProviderGetBuildInfoResponse, D> for (T0,)
100    {
101        #[inline]
102        unsafe fn encode(
103            self,
104            encoder: &mut fidl::encoding::Encoder<'_, D>,
105            offset: usize,
106            depth: fidl::encoding::Depth,
107        ) -> fidl::Result<()> {
108            encoder.debug_check_bounds::<ProviderGetBuildInfoResponse>(offset);
109            // Zero out padding regions. There's no need to apply masks
110            // because the unmasked parts will be overwritten by fields.
111            // Write the fields.
112            self.0.encode(encoder, offset + 0, depth)?;
113            Ok(())
114        }
115    }
116
117    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
118        for ProviderGetBuildInfoResponse
119    {
120        #[inline(always)]
121        fn new_empty() -> Self {
122            Self { build_info: fidl::new_empty!(BuildInfo, D) }
123        }
124
125        #[inline]
126        unsafe fn decode(
127            &mut self,
128            decoder: &mut fidl::encoding::Decoder<'_, D>,
129            offset: usize,
130            _depth: fidl::encoding::Depth,
131        ) -> fidl::Result<()> {
132            decoder.debug_check_bounds::<Self>(offset);
133            // Verify that padding bytes are zero.
134            fidl::decode!(BuildInfo, D, &mut self.build_info, decoder, offset + 0, _depth)?;
135            Ok(())
136        }
137    }
138
139    impl BuildInfo {
140        #[inline(always)]
141        fn max_ordinal_present(&self) -> u64 {
142            if let Some(_) = self.product_version {
143                return 6;
144            }
145            if let Some(_) = self.platform_version {
146                return 5;
147            }
148            if let Some(_) = self.latest_commit_date {
149                return 4;
150            }
151            if let Some(_) = self.version {
152                return 3;
153            }
154            if let Some(_) = self.board_config {
155                return 2;
156            }
157            if let Some(_) = self.product_config {
158                return 1;
159            }
160            0
161        }
162    }
163
164    impl fidl::encoding::ValueTypeMarker for BuildInfo {
165        type Borrowed<'a> = &'a Self;
166        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
167            value
168        }
169    }
170
171    unsafe impl fidl::encoding::TypeMarker for BuildInfo {
172        type Owned = Self;
173
174        #[inline(always)]
175        fn inline_align(_context: fidl::encoding::Context) -> usize {
176            8
177        }
178
179        #[inline(always)]
180        fn inline_size(_context: fidl::encoding::Context) -> usize {
181            16
182        }
183    }
184
185    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BuildInfo, D>
186        for &BuildInfo
187    {
188        unsafe fn encode(
189            self,
190            encoder: &mut fidl::encoding::Encoder<'_, D>,
191            offset: usize,
192            mut depth: fidl::encoding::Depth,
193        ) -> fidl::Result<()> {
194            encoder.debug_check_bounds::<BuildInfo>(offset);
195            // Vector header
196            let max_ordinal: u64 = self.max_ordinal_present();
197            encoder.write_num(max_ordinal, offset);
198            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
199            // Calling encoder.out_of_line_offset(0) is not allowed.
200            if max_ordinal == 0 {
201                return Ok(());
202            }
203            depth.increment()?;
204            let envelope_size = 8;
205            let bytes_len = max_ordinal as usize * envelope_size;
206            #[allow(unused_variables)]
207            let offset = encoder.out_of_line_offset(bytes_len);
208            let mut _prev_end_offset: usize = 0;
209            if 1 > max_ordinal {
210                return Ok(());
211            }
212
213            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
214            // are envelope_size bytes.
215            let cur_offset: usize = (1 - 1) * envelope_size;
216
217            // Zero reserved fields.
218            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
219
220            // Safety:
221            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
222            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
223            //   envelope_size bytes, there is always sufficient room.
224            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
225                self.product_config.as_ref().map(
226                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
227                ),
228                encoder,
229                offset + cur_offset,
230                depth,
231            )?;
232
233            _prev_end_offset = cur_offset + envelope_size;
234            if 2 > max_ordinal {
235                return Ok(());
236            }
237
238            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
239            // are envelope_size bytes.
240            let cur_offset: usize = (2 - 1) * envelope_size;
241
242            // Zero reserved fields.
243            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
244
245            // Safety:
246            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
247            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
248            //   envelope_size bytes, there is always sufficient room.
249            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
250                self.board_config.as_ref().map(
251                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
252                ),
253                encoder,
254                offset + cur_offset,
255                depth,
256            )?;
257
258            _prev_end_offset = cur_offset + envelope_size;
259            if 3 > max_ordinal {
260                return Ok(());
261            }
262
263            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
264            // are envelope_size bytes.
265            let cur_offset: usize = (3 - 1) * envelope_size;
266
267            // Zero reserved fields.
268            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
269
270            // Safety:
271            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
272            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
273            //   envelope_size bytes, there is always sufficient room.
274            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
275                self.version.as_ref().map(
276                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
277                ),
278                encoder,
279                offset + cur_offset,
280                depth,
281            )?;
282
283            _prev_end_offset = cur_offset + envelope_size;
284            if 4 > max_ordinal {
285                return Ok(());
286            }
287
288            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
289            // are envelope_size bytes.
290            let cur_offset: usize = (4 - 1) * envelope_size;
291
292            // Zero reserved fields.
293            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
294
295            // Safety:
296            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
297            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
298            //   envelope_size bytes, there is always sufficient room.
299            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
300                self.latest_commit_date.as_ref().map(
301                    <fidl::encoding::BoundedString<100> 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            if 5 > max_ordinal {
310                return Ok(());
311            }
312
313            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
314            // are envelope_size bytes.
315            let cur_offset: usize = (5 - 1) * envelope_size;
316
317            // Zero reserved fields.
318            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
319
320            // Safety:
321            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
322            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
323            //   envelope_size bytes, there is always sufficient room.
324            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
325                self.platform_version.as_ref().map(
326                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
327                ),
328                encoder,
329                offset + cur_offset,
330                depth,
331            )?;
332
333            _prev_end_offset = cur_offset + envelope_size;
334            if 6 > max_ordinal {
335                return Ok(());
336            }
337
338            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
339            // are envelope_size bytes.
340            let cur_offset: usize = (6 - 1) * envelope_size;
341
342            // Zero reserved fields.
343            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
344
345            // Safety:
346            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
347            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
348            //   envelope_size bytes, there is always sufficient room.
349            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
350                self.product_version.as_ref().map(
351                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
352                ),
353                encoder,
354                offset + cur_offset,
355                depth,
356            )?;
357
358            _prev_end_offset = cur_offset + envelope_size;
359
360            Ok(())
361        }
362    }
363
364    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuildInfo {
365        #[inline(always)]
366        fn new_empty() -> Self {
367            Self::default()
368        }
369
370        unsafe fn decode(
371            &mut self,
372            decoder: &mut fidl::encoding::Decoder<'_, D>,
373            offset: usize,
374            mut depth: fidl::encoding::Depth,
375        ) -> fidl::Result<()> {
376            decoder.debug_check_bounds::<Self>(offset);
377            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
378                None => return Err(fidl::Error::NotNullable),
379                Some(len) => len,
380            };
381            // Calling decoder.out_of_line_offset(0) is not allowed.
382            if len == 0 {
383                return Ok(());
384            };
385            depth.increment()?;
386            let envelope_size = 8;
387            let bytes_len = len * envelope_size;
388            let offset = decoder.out_of_line_offset(bytes_len)?;
389            // Decode the envelope for each type.
390            let mut _next_ordinal_to_read = 0;
391            let mut next_offset = offset;
392            let end_offset = offset + bytes_len;
393            _next_ordinal_to_read += 1;
394            if next_offset >= end_offset {
395                return Ok(());
396            }
397
398            // Decode unknown envelopes for gaps in ordinals.
399            while _next_ordinal_to_read < 1 {
400                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
401                _next_ordinal_to_read += 1;
402                next_offset += envelope_size;
403            }
404
405            let next_out_of_line = decoder.next_out_of_line();
406            let handles_before = decoder.remaining_handles();
407            if let Some((inlined, num_bytes, num_handles)) =
408                fidl::encoding::decode_envelope_header(decoder, next_offset)?
409            {
410                let member_inline_size =
411                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
412                        decoder.context,
413                    );
414                if inlined != (member_inline_size <= 4) {
415                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
416                }
417                let inner_offset;
418                let mut inner_depth = depth.clone();
419                if inlined {
420                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
421                    inner_offset = next_offset;
422                } else {
423                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
424                    inner_depth.increment()?;
425                }
426                let val_ref = self
427                    .product_config
428                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
429                fidl::decode!(
430                    fidl::encoding::BoundedString<100>,
431                    D,
432                    val_ref,
433                    decoder,
434                    inner_offset,
435                    inner_depth
436                )?;
437                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
438                {
439                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
440                }
441                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
442                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
443                }
444            }
445
446            next_offset += envelope_size;
447            _next_ordinal_to_read += 1;
448            if next_offset >= end_offset {
449                return Ok(());
450            }
451
452            // Decode unknown envelopes for gaps in ordinals.
453            while _next_ordinal_to_read < 2 {
454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
455                _next_ordinal_to_read += 1;
456                next_offset += envelope_size;
457            }
458
459            let next_out_of_line = decoder.next_out_of_line();
460            let handles_before = decoder.remaining_handles();
461            if let Some((inlined, num_bytes, num_handles)) =
462                fidl::encoding::decode_envelope_header(decoder, next_offset)?
463            {
464                let member_inline_size =
465                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
466                        decoder.context,
467                    );
468                if inlined != (member_inline_size <= 4) {
469                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
470                }
471                let inner_offset;
472                let mut inner_depth = depth.clone();
473                if inlined {
474                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
475                    inner_offset = next_offset;
476                } else {
477                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
478                    inner_depth.increment()?;
479                }
480                let val_ref = self
481                    .board_config
482                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
483                fidl::decode!(
484                    fidl::encoding::BoundedString<100>,
485                    D,
486                    val_ref,
487                    decoder,
488                    inner_offset,
489                    inner_depth
490                )?;
491                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
492                {
493                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
494                }
495                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
496                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
497                }
498            }
499
500            next_offset += envelope_size;
501            _next_ordinal_to_read += 1;
502            if next_offset >= end_offset {
503                return Ok(());
504            }
505
506            // Decode unknown envelopes for gaps in ordinals.
507            while _next_ordinal_to_read < 3 {
508                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
509                _next_ordinal_to_read += 1;
510                next_offset += envelope_size;
511            }
512
513            let next_out_of_line = decoder.next_out_of_line();
514            let handles_before = decoder.remaining_handles();
515            if let Some((inlined, num_bytes, num_handles)) =
516                fidl::encoding::decode_envelope_header(decoder, next_offset)?
517            {
518                let member_inline_size =
519                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
520                        decoder.context,
521                    );
522                if inlined != (member_inline_size <= 4) {
523                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
524                }
525                let inner_offset;
526                let mut inner_depth = depth.clone();
527                if inlined {
528                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
529                    inner_offset = next_offset;
530                } else {
531                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
532                    inner_depth.increment()?;
533                }
534                let val_ref = self
535                    .version
536                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
537                fidl::decode!(
538                    fidl::encoding::BoundedString<100>,
539                    D,
540                    val_ref,
541                    decoder,
542                    inner_offset,
543                    inner_depth
544                )?;
545                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
546                {
547                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
548                }
549                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
550                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
551                }
552            }
553
554            next_offset += envelope_size;
555            _next_ordinal_to_read += 1;
556            if next_offset >= end_offset {
557                return Ok(());
558            }
559
560            // Decode unknown envelopes for gaps in ordinals.
561            while _next_ordinal_to_read < 4 {
562                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
563                _next_ordinal_to_read += 1;
564                next_offset += envelope_size;
565            }
566
567            let next_out_of_line = decoder.next_out_of_line();
568            let handles_before = decoder.remaining_handles();
569            if let Some((inlined, num_bytes, num_handles)) =
570                fidl::encoding::decode_envelope_header(decoder, next_offset)?
571            {
572                let member_inline_size =
573                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
574                        decoder.context,
575                    );
576                if inlined != (member_inline_size <= 4) {
577                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
578                }
579                let inner_offset;
580                let mut inner_depth = depth.clone();
581                if inlined {
582                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
583                    inner_offset = next_offset;
584                } else {
585                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
586                    inner_depth.increment()?;
587                }
588                let val_ref = self
589                    .latest_commit_date
590                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
591                fidl::decode!(
592                    fidl::encoding::BoundedString<100>,
593                    D,
594                    val_ref,
595                    decoder,
596                    inner_offset,
597                    inner_depth
598                )?;
599                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
600                {
601                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
602                }
603                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
604                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
605                }
606            }
607
608            next_offset += envelope_size;
609            _next_ordinal_to_read += 1;
610            if next_offset >= end_offset {
611                return Ok(());
612            }
613
614            // Decode unknown envelopes for gaps in ordinals.
615            while _next_ordinal_to_read < 5 {
616                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
617                _next_ordinal_to_read += 1;
618                next_offset += envelope_size;
619            }
620
621            let next_out_of_line = decoder.next_out_of_line();
622            let handles_before = decoder.remaining_handles();
623            if let Some((inlined, num_bytes, num_handles)) =
624                fidl::encoding::decode_envelope_header(decoder, next_offset)?
625            {
626                let member_inline_size =
627                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
628                        decoder.context,
629                    );
630                if inlined != (member_inline_size <= 4) {
631                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
632                }
633                let inner_offset;
634                let mut inner_depth = depth.clone();
635                if inlined {
636                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
637                    inner_offset = next_offset;
638                } else {
639                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
640                    inner_depth.increment()?;
641                }
642                let val_ref = self
643                    .platform_version
644                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
645                fidl::decode!(
646                    fidl::encoding::BoundedString<100>,
647                    D,
648                    val_ref,
649                    decoder,
650                    inner_offset,
651                    inner_depth
652                )?;
653                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
654                {
655                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
656                }
657                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
658                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
659                }
660            }
661
662            next_offset += envelope_size;
663            _next_ordinal_to_read += 1;
664            if next_offset >= end_offset {
665                return Ok(());
666            }
667
668            // Decode unknown envelopes for gaps in ordinals.
669            while _next_ordinal_to_read < 6 {
670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
671                _next_ordinal_to_read += 1;
672                next_offset += envelope_size;
673            }
674
675            let next_out_of_line = decoder.next_out_of_line();
676            let handles_before = decoder.remaining_handles();
677            if let Some((inlined, num_bytes, num_handles)) =
678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
679            {
680                let member_inline_size =
681                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
682                        decoder.context,
683                    );
684                if inlined != (member_inline_size <= 4) {
685                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
686                }
687                let inner_offset;
688                let mut inner_depth = depth.clone();
689                if inlined {
690                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
691                    inner_offset = next_offset;
692                } else {
693                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
694                    inner_depth.increment()?;
695                }
696                let val_ref = self
697                    .product_version
698                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
699                fidl::decode!(
700                    fidl::encoding::BoundedString<100>,
701                    D,
702                    val_ref,
703                    decoder,
704                    inner_offset,
705                    inner_depth
706                )?;
707                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
708                {
709                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
710                }
711                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
712                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
713                }
714            }
715
716            next_offset += envelope_size;
717
718            // Decode the remaining unknown envelopes.
719            while next_offset < end_offset {
720                _next_ordinal_to_read += 1;
721                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
722                next_offset += envelope_size;
723            }
724
725            Ok(())
726        }
727    }
728}