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, Default, PartialEq)]
12pub struct PersistentEagerPackage {
13    pub url: Option<fidl_fuchsia_pkg__common::PackageUrl>,
14    pub cup: Option<fidl_fuchsia_pkg__common::CupData>,
15    #[doc(hidden)]
16    pub __source_breaking: fidl::marker::SourceBreaking,
17}
18
19impl fidl::Persistable for PersistentEagerPackage {}
20
21/// Type used for persisting eager package data in pkg-resolver.
22#[derive(Clone, Debug, Default, PartialEq)]
23pub struct PersistentEagerPackages {
24    pub packages: Option<Vec<PersistentEagerPackage>>,
25    #[doc(hidden)]
26    pub __source_breaking: fidl::marker::SourceBreaking,
27}
28
29impl fidl::Persistable for PersistentEagerPackages {}
30
31mod internal {
32    use super::*;
33
34    impl PersistentEagerPackage {
35        #[inline(always)]
36        fn max_ordinal_present(&self) -> u64 {
37            if let Some(_) = self.cup {
38                return 2;
39            }
40            if let Some(_) = self.url {
41                return 1;
42            }
43            0
44        }
45    }
46
47    impl fidl::encoding::ValueTypeMarker for PersistentEagerPackage {
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 PersistentEagerPackage {
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            16
65        }
66    }
67
68    unsafe impl<D: fidl::encoding::ResourceDialect>
69        fidl::encoding::Encode<PersistentEagerPackage, D> for &PersistentEagerPackage
70    {
71        unsafe fn encode(
72            self,
73            encoder: &mut fidl::encoding::Encoder<'_, D>,
74            offset: usize,
75            mut depth: fidl::encoding::Depth,
76        ) -> fidl::Result<()> {
77            encoder.debug_check_bounds::<PersistentEagerPackage>(offset);
78            // Vector header
79            let max_ordinal: u64 = self.max_ordinal_present();
80            encoder.write_num(max_ordinal, offset);
81            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
82            // Calling encoder.out_of_line_offset(0) is not allowed.
83            if max_ordinal == 0 {
84                return Ok(());
85            }
86            depth.increment()?;
87            let envelope_size = 8;
88            let bytes_len = max_ordinal as usize * envelope_size;
89            #[allow(unused_variables)]
90            let offset = encoder.out_of_line_offset(bytes_len);
91            let mut _prev_end_offset: usize = 0;
92            if 1 > max_ordinal {
93                return Ok(());
94            }
95
96            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
97            // are envelope_size bytes.
98            let cur_offset: usize = (1 - 1) * envelope_size;
99
100            // Zero reserved fields.
101            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
102
103            // Safety:
104            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
105            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
106            //   envelope_size bytes, there is always sufficient room.
107            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_pkg__common::PackageUrl, D>(
108            self.url.as_ref().map(<fidl_fuchsia_pkg__common::PackageUrl as fidl::encoding::ValueTypeMarker>::borrow),
109            encoder, offset + cur_offset, depth
110        )?;
111
112            _prev_end_offset = cur_offset + envelope_size;
113            if 2 > max_ordinal {
114                return Ok(());
115            }
116
117            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
118            // are envelope_size bytes.
119            let cur_offset: usize = (2 - 1) * envelope_size;
120
121            // Zero reserved fields.
122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
123
124            // Safety:
125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
127            //   envelope_size bytes, there is always sufficient room.
128            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_pkg__common::CupData, D>(
129                self.cup.as_ref().map(
130                    <fidl_fuchsia_pkg__common::CupData as fidl::encoding::ValueTypeMarker>::borrow,
131                ),
132                encoder,
133                offset + cur_offset,
134                depth,
135            )?;
136
137            _prev_end_offset = cur_offset + envelope_size;
138
139            Ok(())
140        }
141    }
142
143    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
144        for PersistentEagerPackage
145    {
146        #[inline(always)]
147        fn new_empty() -> Self {
148            Self::default()
149        }
150
151        unsafe fn decode(
152            &mut self,
153            decoder: &mut fidl::encoding::Decoder<'_, D>,
154            offset: usize,
155            mut depth: fidl::encoding::Depth,
156        ) -> fidl::Result<()> {
157            decoder.debug_check_bounds::<Self>(offset);
158            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
159                None => return Err(fidl::Error::NotNullable),
160                Some(len) => len,
161            };
162            // Calling decoder.out_of_line_offset(0) is not allowed.
163            if len == 0 {
164                return Ok(());
165            };
166            depth.increment()?;
167            let envelope_size = 8;
168            let bytes_len = len * envelope_size;
169            let offset = decoder.out_of_line_offset(bytes_len)?;
170            // Decode the envelope for each type.
171            let mut _next_ordinal_to_read = 0;
172            let mut next_offset = offset;
173            let end_offset = offset + bytes_len;
174            _next_ordinal_to_read += 1;
175            if next_offset >= end_offset {
176                return Ok(());
177            }
178
179            // Decode unknown envelopes for gaps in ordinals.
180            while _next_ordinal_to_read < 1 {
181                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
182                _next_ordinal_to_read += 1;
183                next_offset += envelope_size;
184            }
185
186            let next_out_of_line = decoder.next_out_of_line();
187            let handles_before = decoder.remaining_handles();
188            if let Some((inlined, num_bytes, num_handles)) =
189                fidl::encoding::decode_envelope_header(decoder, next_offset)?
190            {
191                let member_inline_size = <fidl_fuchsia_pkg__common::PackageUrl as fidl::encoding::TypeMarker>::inline_size(decoder.context);
192                if inlined != (member_inline_size <= 4) {
193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
194                }
195                let inner_offset;
196                let mut inner_depth = depth.clone();
197                if inlined {
198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
199                    inner_offset = next_offset;
200                } else {
201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
202                    inner_depth.increment()?;
203                }
204                let val_ref = self.url.get_or_insert_with(|| {
205                    fidl::new_empty!(fidl_fuchsia_pkg__common::PackageUrl, D)
206                });
207                fidl::decode!(
208                    fidl_fuchsia_pkg__common::PackageUrl,
209                    D,
210                    val_ref,
211                    decoder,
212                    inner_offset,
213                    inner_depth
214                )?;
215                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
216                {
217                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
218                }
219                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
220                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
221                }
222            }
223
224            next_offset += envelope_size;
225            _next_ordinal_to_read += 1;
226            if next_offset >= end_offset {
227                return Ok(());
228            }
229
230            // Decode unknown envelopes for gaps in ordinals.
231            while _next_ordinal_to_read < 2 {
232                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
233                _next_ordinal_to_read += 1;
234                next_offset += envelope_size;
235            }
236
237            let next_out_of_line = decoder.next_out_of_line();
238            let handles_before = decoder.remaining_handles();
239            if let Some((inlined, num_bytes, num_handles)) =
240                fidl::encoding::decode_envelope_header(decoder, next_offset)?
241            {
242                let member_inline_size =
243                    <fidl_fuchsia_pkg__common::CupData as fidl::encoding::TypeMarker>::inline_size(
244                        decoder.context,
245                    );
246                if inlined != (member_inline_size <= 4) {
247                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
248                }
249                let inner_offset;
250                let mut inner_depth = depth.clone();
251                if inlined {
252                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
253                    inner_offset = next_offset;
254                } else {
255                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
256                    inner_depth.increment()?;
257                }
258                let val_ref = self
259                    .cup
260                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_pkg__common::CupData, D));
261                fidl::decode!(
262                    fidl_fuchsia_pkg__common::CupData,
263                    D,
264                    val_ref,
265                    decoder,
266                    inner_offset,
267                    inner_depth
268                )?;
269                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
270                {
271                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
272                }
273                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
274                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
275                }
276            }
277
278            next_offset += envelope_size;
279
280            // Decode the remaining unknown envelopes.
281            while next_offset < end_offset {
282                _next_ordinal_to_read += 1;
283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
284                next_offset += envelope_size;
285            }
286
287            Ok(())
288        }
289    }
290
291    impl PersistentEagerPackages {
292        #[inline(always)]
293        fn max_ordinal_present(&self) -> u64 {
294            if let Some(_) = self.packages {
295                return 1;
296            }
297            0
298        }
299    }
300
301    impl fidl::encoding::ValueTypeMarker for PersistentEagerPackages {
302        type Borrowed<'a> = &'a Self;
303        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
304            value
305        }
306    }
307
308    unsafe impl fidl::encoding::TypeMarker for PersistentEagerPackages {
309        type Owned = Self;
310
311        #[inline(always)]
312        fn inline_align(_context: fidl::encoding::Context) -> usize {
313            8
314        }
315
316        #[inline(always)]
317        fn inline_size(_context: fidl::encoding::Context) -> usize {
318            16
319        }
320    }
321
322    unsafe impl<D: fidl::encoding::ResourceDialect>
323        fidl::encoding::Encode<PersistentEagerPackages, D> for &PersistentEagerPackages
324    {
325        unsafe fn encode(
326            self,
327            encoder: &mut fidl::encoding::Encoder<'_, D>,
328            offset: usize,
329            mut depth: fidl::encoding::Depth,
330        ) -> fidl::Result<()> {
331            encoder.debug_check_bounds::<PersistentEagerPackages>(offset);
332            // Vector header
333            let max_ordinal: u64 = self.max_ordinal_present();
334            encoder.write_num(max_ordinal, offset);
335            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
336            // Calling encoder.out_of_line_offset(0) is not allowed.
337            if max_ordinal == 0 {
338                return Ok(());
339            }
340            depth.increment()?;
341            let envelope_size = 8;
342            let bytes_len = max_ordinal as usize * envelope_size;
343            #[allow(unused_variables)]
344            let offset = encoder.out_of_line_offset(bytes_len);
345            let mut _prev_end_offset: usize = 0;
346            if 1 > max_ordinal {
347                return Ok(());
348            }
349
350            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
351            // are envelope_size bytes.
352            let cur_offset: usize = (1 - 1) * envelope_size;
353
354            // Zero reserved fields.
355            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
356
357            // Safety:
358            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
359            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
360            //   envelope_size bytes, there is always sufficient room.
361            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PersistentEagerPackage, 128>, D>(
362            self.packages.as_ref().map(<fidl::encoding::Vector<PersistentEagerPackage, 128> as fidl::encoding::ValueTypeMarker>::borrow),
363            encoder, offset + cur_offset, depth
364        )?;
365
366            _prev_end_offset = cur_offset + envelope_size;
367
368            Ok(())
369        }
370    }
371
372    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
373        for PersistentEagerPackages
374    {
375        #[inline(always)]
376        fn new_empty() -> Self {
377            Self::default()
378        }
379
380        unsafe fn decode(
381            &mut self,
382            decoder: &mut fidl::encoding::Decoder<'_, D>,
383            offset: usize,
384            mut depth: fidl::encoding::Depth,
385        ) -> fidl::Result<()> {
386            decoder.debug_check_bounds::<Self>(offset);
387            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
388                None => return Err(fidl::Error::NotNullable),
389                Some(len) => len,
390            };
391            // Calling decoder.out_of_line_offset(0) is not allowed.
392            if len == 0 {
393                return Ok(());
394            };
395            depth.increment()?;
396            let envelope_size = 8;
397            let bytes_len = len * envelope_size;
398            let offset = decoder.out_of_line_offset(bytes_len)?;
399            // Decode the envelope for each type.
400            let mut _next_ordinal_to_read = 0;
401            let mut next_offset = offset;
402            let end_offset = offset + bytes_len;
403            _next_ordinal_to_read += 1;
404            if next_offset >= end_offset {
405                return Ok(());
406            }
407
408            // Decode unknown envelopes for gaps in ordinals.
409            while _next_ordinal_to_read < 1 {
410                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
411                _next_ordinal_to_read += 1;
412                next_offset += envelope_size;
413            }
414
415            let next_out_of_line = decoder.next_out_of_line();
416            let handles_before = decoder.remaining_handles();
417            if let Some((inlined, num_bytes, num_handles)) =
418                fidl::encoding::decode_envelope_header(decoder, next_offset)?
419            {
420                let member_inline_size = <fidl::encoding::Vector<PersistentEagerPackage, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
421                if inlined != (member_inline_size <= 4) {
422                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
423                }
424                let inner_offset;
425                let mut inner_depth = depth.clone();
426                if inlined {
427                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
428                    inner_offset = next_offset;
429                } else {
430                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
431                    inner_depth.increment()?;
432                }
433                let val_ref = self.packages.get_or_insert_with(
434                    || fidl::new_empty!(fidl::encoding::Vector<PersistentEagerPackage, 128>, D),
435                );
436                fidl::decode!(fidl::encoding::Vector<PersistentEagerPackage, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
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
448            // Decode the remaining unknown envelopes.
449            while next_offset < end_offset {
450                _next_ordinal_to_read += 1;
451                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
452                next_offset += envelope_size;
453            }
454
455            Ok(())
456        }
457    }
458}