1#![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 PROXY_NAME_LEN: u32 = 1024;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum SuspendError {
15 WakeLocksExist,
16 SuspendFailure,
17 #[doc(hidden)]
18 __SourceBreaking {
19 unknown_ordinal: u32,
20 },
21}
22
23#[macro_export]
25macro_rules! SuspendErrorUnknown {
26 () => {
27 _
28 };
29}
30
31impl SuspendError {
32 #[inline]
33 pub fn from_primitive(prim: u32) -> Option<Self> {
34 match prim {
35 1 => Some(Self::WakeLocksExist),
36 2 => Some(Self::SuspendFailure),
37 _ => None,
38 }
39 }
40
41 #[inline]
42 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43 match prim {
44 1 => Self::WakeLocksExist,
45 2 => Self::SuspendFailure,
46 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
47 }
48 }
49
50 #[inline]
51 pub fn unknown() -> Self {
52 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
53 }
54
55 #[inline]
56 pub const fn into_primitive(self) -> u32 {
57 match self {
58 Self::WakeLocksExist => 1,
59 Self::SuspendFailure => 2,
60 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
61 }
62 }
63
64 #[inline]
65 pub fn is_unknown(&self) -> bool {
66 match self {
67 Self::__SourceBreaking { unknown_ordinal: _ } => true,
68 _ => false,
69 }
70 }
71}
72
73#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
74#[repr(C)]
75pub struct PagerExtent {
76 pub logical_start: u32,
77 pub logical_end: u32,
78 pub physical_block: u64,
79}
80
81impl fidl::Persistable for PagerExtent {}
82
83#[derive(Clone, Debug, Default, PartialEq)]
84pub struct ManagerSuspendContainerResponse {
85 pub suspend_time: Option<i64>,
89 pub resume_reason: Option<String>,
91 #[doc(hidden)]
92 pub __source_breaking: fidl::marker::SourceBreaking,
93}
94
95impl fidl::Persistable for ManagerSuspendContainerResponse {}
96
97#[derive(Clone, Debug, Default, PartialEq)]
98pub struct PagerRegisterFileRequest {
99 pub name: Option<String>,
101 pub inode_num: Option<u32>,
103 pub size: Option<u64>,
105 pub extents: Option<Vec<PagerExtent>>,
107 #[doc(hidden)]
108 pub __source_breaking: fidl::marker::SourceBreaking,
109}
110
111impl fidl::Persistable for PagerRegisterFileRequest {}
112
113pub mod manager_ordinals {
114 pub const SUSPEND_CONTAINER: u64 = 0x928527927c9f2a7;
115 pub const PROXY_WAKE_CHANNEL: u64 = 0x46a374ab73b23714;
116 pub const REGISTER_WAKE_WATCHER: u64 = 0x456d74519eb65b41;
117 pub const CREATE_PAGER: u64 = 0x49d14958b736198b;
118}
119
120pub mod pager_ordinals {
121 pub const REGISTER_FILE: u64 = 0x4f85a2ce6cae4aed;
122}
123
124mod internal {
125 use super::*;
126 unsafe impl fidl::encoding::TypeMarker for SuspendError {
127 type Owned = Self;
128
129 #[inline(always)]
130 fn inline_align(_context: fidl::encoding::Context) -> usize {
131 std::mem::align_of::<u32>()
132 }
133
134 #[inline(always)]
135 fn inline_size(_context: fidl::encoding::Context) -> usize {
136 std::mem::size_of::<u32>()
137 }
138
139 #[inline(always)]
140 fn encode_is_copy() -> bool {
141 false
142 }
143
144 #[inline(always)]
145 fn decode_is_copy() -> bool {
146 false
147 }
148 }
149
150 impl fidl::encoding::ValueTypeMarker for SuspendError {
151 type Borrowed<'a> = Self;
152 #[inline(always)]
153 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
154 *value
155 }
156 }
157
158 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SuspendError {
159 #[inline]
160 unsafe fn encode(
161 self,
162 encoder: &mut fidl::encoding::Encoder<'_, D>,
163 offset: usize,
164 _depth: fidl::encoding::Depth,
165 ) -> fidl::Result<()> {
166 encoder.debug_check_bounds::<Self>(offset);
167 encoder.write_num(self.into_primitive(), offset);
168 Ok(())
169 }
170 }
171
172 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendError {
173 #[inline(always)]
174 fn new_empty() -> Self {
175 Self::unknown()
176 }
177
178 #[inline]
179 unsafe fn decode(
180 &mut self,
181 decoder: &mut fidl::encoding::Decoder<'_, D>,
182 offset: usize,
183 _depth: fidl::encoding::Depth,
184 ) -> fidl::Result<()> {
185 decoder.debug_check_bounds::<Self>(offset);
186 let prim = decoder.read_num::<u32>(offset);
187
188 *self = Self::from_primitive_allow_unknown(prim);
189 Ok(())
190 }
191 }
192
193 impl fidl::encoding::ValueTypeMarker for PagerExtent {
194 type Borrowed<'a> = &'a Self;
195 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
196 value
197 }
198 }
199
200 unsafe impl fidl::encoding::TypeMarker for PagerExtent {
201 type Owned = Self;
202
203 #[inline(always)]
204 fn inline_align(_context: fidl::encoding::Context) -> usize {
205 8
206 }
207
208 #[inline(always)]
209 fn inline_size(_context: fidl::encoding::Context) -> usize {
210 16
211 }
212 #[inline(always)]
213 fn encode_is_copy() -> bool {
214 true
215 }
216
217 #[inline(always)]
218 fn decode_is_copy() -> bool {
219 true
220 }
221 }
222
223 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PagerExtent, D>
224 for &PagerExtent
225 {
226 #[inline]
227 unsafe fn encode(
228 self,
229 encoder: &mut fidl::encoding::Encoder<'_, D>,
230 offset: usize,
231 _depth: fidl::encoding::Depth,
232 ) -> fidl::Result<()> {
233 encoder.debug_check_bounds::<PagerExtent>(offset);
234 unsafe {
235 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
237 (buf_ptr as *mut PagerExtent).write_unaligned((self as *const PagerExtent).read());
238 }
241 Ok(())
242 }
243 }
244 unsafe impl<
245 D: fidl::encoding::ResourceDialect,
246 T0: fidl::encoding::Encode<u32, D>,
247 T1: fidl::encoding::Encode<u32, D>,
248 T2: fidl::encoding::Encode<u64, D>,
249 > fidl::encoding::Encode<PagerExtent, D> for (T0, T1, T2)
250 {
251 #[inline]
252 unsafe fn encode(
253 self,
254 encoder: &mut fidl::encoding::Encoder<'_, D>,
255 offset: usize,
256 depth: fidl::encoding::Depth,
257 ) -> fidl::Result<()> {
258 encoder.debug_check_bounds::<PagerExtent>(offset);
259 self.0.encode(encoder, offset + 0, depth)?;
263 self.1.encode(encoder, offset + 4, depth)?;
264 self.2.encode(encoder, offset + 8, depth)?;
265 Ok(())
266 }
267 }
268
269 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PagerExtent {
270 #[inline(always)]
271 fn new_empty() -> Self {
272 Self {
273 logical_start: fidl::new_empty!(u32, D),
274 logical_end: fidl::new_empty!(u32, D),
275 physical_block: fidl::new_empty!(u64, D),
276 }
277 }
278
279 #[inline]
280 unsafe fn decode(
281 &mut self,
282 decoder: &mut fidl::encoding::Decoder<'_, D>,
283 offset: usize,
284 _depth: fidl::encoding::Depth,
285 ) -> fidl::Result<()> {
286 decoder.debug_check_bounds::<Self>(offset);
287 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
288 unsafe {
291 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
292 }
293 Ok(())
294 }
295 }
296
297 impl ManagerSuspendContainerResponse {
298 #[inline(always)]
299 fn max_ordinal_present(&self) -> u64 {
300 if let Some(_) = self.resume_reason {
301 return 2;
302 }
303 if let Some(_) = self.suspend_time {
304 return 1;
305 }
306 0
307 }
308 }
309
310 impl fidl::encoding::ValueTypeMarker for ManagerSuspendContainerResponse {
311 type Borrowed<'a> = &'a Self;
312 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
313 value
314 }
315 }
316
317 unsafe impl fidl::encoding::TypeMarker for ManagerSuspendContainerResponse {
318 type Owned = Self;
319
320 #[inline(always)]
321 fn inline_align(_context: fidl::encoding::Context) -> usize {
322 8
323 }
324
325 #[inline(always)]
326 fn inline_size(_context: fidl::encoding::Context) -> usize {
327 16
328 }
329 }
330
331 unsafe impl<D: fidl::encoding::ResourceDialect>
332 fidl::encoding::Encode<ManagerSuspendContainerResponse, D>
333 for &ManagerSuspendContainerResponse
334 {
335 unsafe fn encode(
336 self,
337 encoder: &mut fidl::encoding::Encoder<'_, D>,
338 offset: usize,
339 mut depth: fidl::encoding::Depth,
340 ) -> fidl::Result<()> {
341 encoder.debug_check_bounds::<ManagerSuspendContainerResponse>(offset);
342 let max_ordinal: u64 = self.max_ordinal_present();
344 encoder.write_num(max_ordinal, offset);
345 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
346 if max_ordinal == 0 {
348 return Ok(());
349 }
350 depth.increment()?;
351 let envelope_size = 8;
352 let bytes_len = max_ordinal as usize * envelope_size;
353 #[allow(unused_variables)]
354 let offset = encoder.out_of_line_offset(bytes_len);
355 let mut _prev_end_offset: usize = 0;
356 if 1 > max_ordinal {
357 return Ok(());
358 }
359
360 let cur_offset: usize = (1 - 1) * envelope_size;
363
364 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
366
367 fidl::encoding::encode_in_envelope_optional::<i64, D>(
372 self.suspend_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
373 encoder,
374 offset + cur_offset,
375 depth,
376 )?;
377
378 _prev_end_offset = cur_offset + envelope_size;
379 if 2 > max_ordinal {
380 return Ok(());
381 }
382
383 let cur_offset: usize = (2 - 1) * envelope_size;
386
387 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
389
390 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
395 self.resume_reason.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
396 encoder, offset + cur_offset, depth
397 )?;
398
399 _prev_end_offset = cur_offset + envelope_size;
400
401 Ok(())
402 }
403 }
404
405 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
406 for ManagerSuspendContainerResponse
407 {
408 #[inline(always)]
409 fn new_empty() -> Self {
410 Self::default()
411 }
412
413 unsafe fn decode(
414 &mut self,
415 decoder: &mut fidl::encoding::Decoder<'_, D>,
416 offset: usize,
417 mut depth: fidl::encoding::Depth,
418 ) -> fidl::Result<()> {
419 decoder.debug_check_bounds::<Self>(offset);
420 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
421 None => return Err(fidl::Error::NotNullable),
422 Some(len) => len,
423 };
424 if len == 0 {
426 return Ok(());
427 };
428 depth.increment()?;
429 let envelope_size = 8;
430 let bytes_len = len * envelope_size;
431 let offset = decoder.out_of_line_offset(bytes_len)?;
432 let mut _next_ordinal_to_read = 0;
434 let mut next_offset = offset;
435 let end_offset = offset + bytes_len;
436 _next_ordinal_to_read += 1;
437 if next_offset >= end_offset {
438 return Ok(());
439 }
440
441 while _next_ordinal_to_read < 1 {
443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
444 _next_ordinal_to_read += 1;
445 next_offset += envelope_size;
446 }
447
448 let next_out_of_line = decoder.next_out_of_line();
449 let handles_before = decoder.remaining_handles();
450 if let Some((inlined, num_bytes, num_handles)) =
451 fidl::encoding::decode_envelope_header(decoder, next_offset)?
452 {
453 let member_inline_size =
454 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
455 if inlined != (member_inline_size <= 4) {
456 return Err(fidl::Error::InvalidInlineBitInEnvelope);
457 }
458 let inner_offset;
459 let mut inner_depth = depth.clone();
460 if inlined {
461 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
462 inner_offset = next_offset;
463 } else {
464 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
465 inner_depth.increment()?;
466 }
467 let val_ref = self.suspend_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
468 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
469 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
470 {
471 return Err(fidl::Error::InvalidNumBytesInEnvelope);
472 }
473 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
474 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
475 }
476 }
477
478 next_offset += envelope_size;
479 _next_ordinal_to_read += 1;
480 if next_offset >= end_offset {
481 return Ok(());
482 }
483
484 while _next_ordinal_to_read < 2 {
486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
487 _next_ordinal_to_read += 1;
488 next_offset += envelope_size;
489 }
490
491 let next_out_of_line = decoder.next_out_of_line();
492 let handles_before = decoder.remaining_handles();
493 if let Some((inlined, num_bytes, num_handles)) =
494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
495 {
496 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
497 if inlined != (member_inline_size <= 4) {
498 return Err(fidl::Error::InvalidInlineBitInEnvelope);
499 }
500 let inner_offset;
501 let mut inner_depth = depth.clone();
502 if inlined {
503 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
504 inner_offset = next_offset;
505 } else {
506 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
507 inner_depth.increment()?;
508 }
509 let val_ref = self.resume_reason.get_or_insert_with(|| {
510 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
511 });
512 fidl::decode!(
513 fidl::encoding::BoundedString<1024>,
514 D,
515 val_ref,
516 decoder,
517 inner_offset,
518 inner_depth
519 )?;
520 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
521 {
522 return Err(fidl::Error::InvalidNumBytesInEnvelope);
523 }
524 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
525 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
526 }
527 }
528
529 next_offset += envelope_size;
530
531 while next_offset < end_offset {
533 _next_ordinal_to_read += 1;
534 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
535 next_offset += envelope_size;
536 }
537
538 Ok(())
539 }
540 }
541
542 impl PagerRegisterFileRequest {
543 #[inline(always)]
544 fn max_ordinal_present(&self) -> u64 {
545 if let Some(_) = self.extents {
546 return 4;
547 }
548 if let Some(_) = self.size {
549 return 3;
550 }
551 if let Some(_) = self.inode_num {
552 return 2;
553 }
554 if let Some(_) = self.name {
555 return 1;
556 }
557 0
558 }
559 }
560
561 impl fidl::encoding::ValueTypeMarker for PagerRegisterFileRequest {
562 type Borrowed<'a> = &'a Self;
563 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
564 value
565 }
566 }
567
568 unsafe impl fidl::encoding::TypeMarker for PagerRegisterFileRequest {
569 type Owned = Self;
570
571 #[inline(always)]
572 fn inline_align(_context: fidl::encoding::Context) -> usize {
573 8
574 }
575
576 #[inline(always)]
577 fn inline_size(_context: fidl::encoding::Context) -> usize {
578 16
579 }
580 }
581
582 unsafe impl<D: fidl::encoding::ResourceDialect>
583 fidl::encoding::Encode<PagerRegisterFileRequest, D> for &PagerRegisterFileRequest
584 {
585 unsafe fn encode(
586 self,
587 encoder: &mut fidl::encoding::Encoder<'_, D>,
588 offset: usize,
589 mut depth: fidl::encoding::Depth,
590 ) -> fidl::Result<()> {
591 encoder.debug_check_bounds::<PagerRegisterFileRequest>(offset);
592 let max_ordinal: u64 = self.max_ordinal_present();
594 encoder.write_num(max_ordinal, offset);
595 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
596 if max_ordinal == 0 {
598 return Ok(());
599 }
600 depth.increment()?;
601 let envelope_size = 8;
602 let bytes_len = max_ordinal as usize * envelope_size;
603 #[allow(unused_variables)]
604 let offset = encoder.out_of_line_offset(bytes_len);
605 let mut _prev_end_offset: usize = 0;
606 if 1 > max_ordinal {
607 return Ok(());
608 }
609
610 let cur_offset: usize = (1 - 1) * envelope_size;
613
614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
616
617 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
622 self.name.as_ref().map(
623 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
624 ),
625 encoder,
626 offset + cur_offset,
627 depth,
628 )?;
629
630 _prev_end_offset = cur_offset + envelope_size;
631 if 2 > max_ordinal {
632 return Ok(());
633 }
634
635 let cur_offset: usize = (2 - 1) * envelope_size;
638
639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
641
642 fidl::encoding::encode_in_envelope_optional::<u32, D>(
647 self.inode_num.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
648 encoder,
649 offset + cur_offset,
650 depth,
651 )?;
652
653 _prev_end_offset = cur_offset + envelope_size;
654 if 3 > max_ordinal {
655 return Ok(());
656 }
657
658 let cur_offset: usize = (3 - 1) * envelope_size;
661
662 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
664
665 fidl::encoding::encode_in_envelope_optional::<u64, D>(
670 self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
671 encoder,
672 offset + cur_offset,
673 depth,
674 )?;
675
676 _prev_end_offset = cur_offset + envelope_size;
677 if 4 > max_ordinal {
678 return Ok(());
679 }
680
681 let cur_offset: usize = (4 - 1) * envelope_size;
684
685 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
687
688 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PagerExtent, 1024>, D>(
693 self.extents.as_ref().map(<fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
694 encoder, offset + cur_offset, depth
695 )?;
696
697 _prev_end_offset = cur_offset + envelope_size;
698
699 Ok(())
700 }
701 }
702
703 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
704 for PagerRegisterFileRequest
705 {
706 #[inline(always)]
707 fn new_empty() -> Self {
708 Self::default()
709 }
710
711 unsafe fn decode(
712 &mut self,
713 decoder: &mut fidl::encoding::Decoder<'_, D>,
714 offset: usize,
715 mut depth: fidl::encoding::Depth,
716 ) -> fidl::Result<()> {
717 decoder.debug_check_bounds::<Self>(offset);
718 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
719 None => return Err(fidl::Error::NotNullable),
720 Some(len) => len,
721 };
722 if len == 0 {
724 return Ok(());
725 };
726 depth.increment()?;
727 let envelope_size = 8;
728 let bytes_len = len * envelope_size;
729 let offset = decoder.out_of_line_offset(bytes_len)?;
730 let mut _next_ordinal_to_read = 0;
732 let mut next_offset = offset;
733 let end_offset = offset + bytes_len;
734 _next_ordinal_to_read += 1;
735 if next_offset >= end_offset {
736 return Ok(());
737 }
738
739 while _next_ordinal_to_read < 1 {
741 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
742 _next_ordinal_to_read += 1;
743 next_offset += envelope_size;
744 }
745
746 let next_out_of_line = decoder.next_out_of_line();
747 let handles_before = decoder.remaining_handles();
748 if let Some((inlined, num_bytes, num_handles)) =
749 fidl::encoding::decode_envelope_header(decoder, next_offset)?
750 {
751 let member_inline_size =
752 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
753 decoder.context,
754 );
755 if inlined != (member_inline_size <= 4) {
756 return Err(fidl::Error::InvalidInlineBitInEnvelope);
757 }
758 let inner_offset;
759 let mut inner_depth = depth.clone();
760 if inlined {
761 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
762 inner_offset = next_offset;
763 } else {
764 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
765 inner_depth.increment()?;
766 }
767 let val_ref = self
768 .name
769 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
770 fidl::decode!(
771 fidl::encoding::UnboundedString,
772 D,
773 val_ref,
774 decoder,
775 inner_offset,
776 inner_depth
777 )?;
778 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
779 {
780 return Err(fidl::Error::InvalidNumBytesInEnvelope);
781 }
782 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
783 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
784 }
785 }
786
787 next_offset += envelope_size;
788 _next_ordinal_to_read += 1;
789 if next_offset >= end_offset {
790 return Ok(());
791 }
792
793 while _next_ordinal_to_read < 2 {
795 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
796 _next_ordinal_to_read += 1;
797 next_offset += envelope_size;
798 }
799
800 let next_out_of_line = decoder.next_out_of_line();
801 let handles_before = decoder.remaining_handles();
802 if let Some((inlined, num_bytes, num_handles)) =
803 fidl::encoding::decode_envelope_header(decoder, next_offset)?
804 {
805 let member_inline_size =
806 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
807 if inlined != (member_inline_size <= 4) {
808 return Err(fidl::Error::InvalidInlineBitInEnvelope);
809 }
810 let inner_offset;
811 let mut inner_depth = depth.clone();
812 if inlined {
813 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
814 inner_offset = next_offset;
815 } else {
816 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
817 inner_depth.increment()?;
818 }
819 let val_ref = self.inode_num.get_or_insert_with(|| fidl::new_empty!(u32, D));
820 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
821 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
822 {
823 return Err(fidl::Error::InvalidNumBytesInEnvelope);
824 }
825 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
826 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
827 }
828 }
829
830 next_offset += envelope_size;
831 _next_ordinal_to_read += 1;
832 if next_offset >= end_offset {
833 return Ok(());
834 }
835
836 while _next_ordinal_to_read < 3 {
838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
839 _next_ordinal_to_read += 1;
840 next_offset += envelope_size;
841 }
842
843 let next_out_of_line = decoder.next_out_of_line();
844 let handles_before = decoder.remaining_handles();
845 if let Some((inlined, num_bytes, num_handles)) =
846 fidl::encoding::decode_envelope_header(decoder, next_offset)?
847 {
848 let member_inline_size =
849 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
850 if inlined != (member_inline_size <= 4) {
851 return Err(fidl::Error::InvalidInlineBitInEnvelope);
852 }
853 let inner_offset;
854 let mut inner_depth = depth.clone();
855 if inlined {
856 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
857 inner_offset = next_offset;
858 } else {
859 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
860 inner_depth.increment()?;
861 }
862 let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
863 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
864 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
865 {
866 return Err(fidl::Error::InvalidNumBytesInEnvelope);
867 }
868 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
869 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
870 }
871 }
872
873 next_offset += envelope_size;
874 _next_ordinal_to_read += 1;
875 if next_offset >= end_offset {
876 return Ok(());
877 }
878
879 while _next_ordinal_to_read < 4 {
881 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
882 _next_ordinal_to_read += 1;
883 next_offset += envelope_size;
884 }
885
886 let next_out_of_line = decoder.next_out_of_line();
887 let handles_before = decoder.remaining_handles();
888 if let Some((inlined, num_bytes, num_handles)) =
889 fidl::encoding::decode_envelope_header(decoder, next_offset)?
890 {
891 let member_inline_size = <fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
892 if inlined != (member_inline_size <= 4) {
893 return Err(fidl::Error::InvalidInlineBitInEnvelope);
894 }
895 let inner_offset;
896 let mut inner_depth = depth.clone();
897 if inlined {
898 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
899 inner_offset = next_offset;
900 } else {
901 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
902 inner_depth.increment()?;
903 }
904 let val_ref = self.extents.get_or_insert_with(
905 || fidl::new_empty!(fidl::encoding::Vector<PagerExtent, 1024>, D),
906 );
907 fidl::decode!(fidl::encoding::Vector<PagerExtent, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
908 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
909 {
910 return Err(fidl::Error::InvalidNumBytesInEnvelope);
911 }
912 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
913 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
914 }
915 }
916
917 next_offset += envelope_size;
918
919 while next_offset < end_offset {
921 _next_ordinal_to_read += 1;
922 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
923 next_offset += envelope_size;
924 }
925
926 Ok(())
927 }
928 }
929}