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

fidl_fuchsia_pkg_internal_common/
fidl_fuchsia_pkg_internal_common.rs
