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

fidl_fuchsia_pkg_internal__common/
fidl_fuchsia_pkg_internal__common.rs
