fidl_fuchsia_pkg_internal__common/
fidl_fuchsia_pkg_internal__common.rs1#![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#[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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
99
100 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
102
103 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 let cur_offset: usize = (2 - 1) * envelope_size;
120
121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
123
124 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
353
354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
356
357 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 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 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 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 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}