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
113mod internal {
114 use super::*;
115 unsafe impl fidl::encoding::TypeMarker for SuspendError {
116 type Owned = Self;
117
118 #[inline(always)]
119 fn inline_align(_context: fidl::encoding::Context) -> usize {
120 std::mem::align_of::<u32>()
121 }
122
123 #[inline(always)]
124 fn inline_size(_context: fidl::encoding::Context) -> usize {
125 std::mem::size_of::<u32>()
126 }
127
128 #[inline(always)]
129 fn encode_is_copy() -> bool {
130 false
131 }
132
133 #[inline(always)]
134 fn decode_is_copy() -> bool {
135 false
136 }
137 }
138
139 impl fidl::encoding::ValueTypeMarker for SuspendError {
140 type Borrowed<'a> = Self;
141 #[inline(always)]
142 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
143 *value
144 }
145 }
146
147 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SuspendError {
148 #[inline]
149 unsafe fn encode(
150 self,
151 encoder: &mut fidl::encoding::Encoder<'_, D>,
152 offset: usize,
153 _depth: fidl::encoding::Depth,
154 ) -> fidl::Result<()> {
155 encoder.debug_check_bounds::<Self>(offset);
156 encoder.write_num(self.into_primitive(), offset);
157 Ok(())
158 }
159 }
160
161 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendError {
162 #[inline(always)]
163 fn new_empty() -> Self {
164 Self::unknown()
165 }
166
167 #[inline]
168 unsafe fn decode(
169 &mut self,
170 decoder: &mut fidl::encoding::Decoder<'_, D>,
171 offset: usize,
172 _depth: fidl::encoding::Depth,
173 ) -> fidl::Result<()> {
174 decoder.debug_check_bounds::<Self>(offset);
175 let prim = decoder.read_num::<u32>(offset);
176
177 *self = Self::from_primitive_allow_unknown(prim);
178 Ok(())
179 }
180 }
181
182 impl fidl::encoding::ValueTypeMarker for PagerExtent {
183 type Borrowed<'a> = &'a Self;
184 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
185 value
186 }
187 }
188
189 unsafe impl fidl::encoding::TypeMarker for PagerExtent {
190 type Owned = Self;
191
192 #[inline(always)]
193 fn inline_align(_context: fidl::encoding::Context) -> usize {
194 8
195 }
196
197 #[inline(always)]
198 fn inline_size(_context: fidl::encoding::Context) -> usize {
199 16
200 }
201 #[inline(always)]
202 fn encode_is_copy() -> bool {
203 true
204 }
205
206 #[inline(always)]
207 fn decode_is_copy() -> bool {
208 true
209 }
210 }
211
212 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PagerExtent, D>
213 for &PagerExtent
214 {
215 #[inline]
216 unsafe fn encode(
217 self,
218 encoder: &mut fidl::encoding::Encoder<'_, D>,
219 offset: usize,
220 _depth: fidl::encoding::Depth,
221 ) -> fidl::Result<()> {
222 encoder.debug_check_bounds::<PagerExtent>(offset);
223 unsafe {
224 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
226 (buf_ptr as *mut PagerExtent).write_unaligned((self as *const PagerExtent).read());
227 }
230 Ok(())
231 }
232 }
233 unsafe impl<
234 D: fidl::encoding::ResourceDialect,
235 T0: fidl::encoding::Encode<u32, D>,
236 T1: fidl::encoding::Encode<u32, D>,
237 T2: fidl::encoding::Encode<u64, D>,
238 > fidl::encoding::Encode<PagerExtent, D> for (T0, T1, T2)
239 {
240 #[inline]
241 unsafe fn encode(
242 self,
243 encoder: &mut fidl::encoding::Encoder<'_, D>,
244 offset: usize,
245 depth: fidl::encoding::Depth,
246 ) -> fidl::Result<()> {
247 encoder.debug_check_bounds::<PagerExtent>(offset);
248 self.0.encode(encoder, offset + 0, depth)?;
252 self.1.encode(encoder, offset + 4, depth)?;
253 self.2.encode(encoder, offset + 8, depth)?;
254 Ok(())
255 }
256 }
257
258 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PagerExtent {
259 #[inline(always)]
260 fn new_empty() -> Self {
261 Self {
262 logical_start: fidl::new_empty!(u32, D),
263 logical_end: fidl::new_empty!(u32, D),
264 physical_block: fidl::new_empty!(u64, D),
265 }
266 }
267
268 #[inline]
269 unsafe fn decode(
270 &mut self,
271 decoder: &mut fidl::encoding::Decoder<'_, D>,
272 offset: usize,
273 _depth: fidl::encoding::Depth,
274 ) -> fidl::Result<()> {
275 decoder.debug_check_bounds::<Self>(offset);
276 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
277 unsafe {
280 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
281 }
282 Ok(())
283 }
284 }
285
286 impl ManagerSuspendContainerResponse {
287 #[inline(always)]
288 fn max_ordinal_present(&self) -> u64 {
289 if let Some(_) = self.resume_reason {
290 return 2;
291 }
292 if let Some(_) = self.suspend_time {
293 return 1;
294 }
295 0
296 }
297 }
298
299 impl fidl::encoding::ValueTypeMarker for ManagerSuspendContainerResponse {
300 type Borrowed<'a> = &'a Self;
301 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
302 value
303 }
304 }
305
306 unsafe impl fidl::encoding::TypeMarker for ManagerSuspendContainerResponse {
307 type Owned = Self;
308
309 #[inline(always)]
310 fn inline_align(_context: fidl::encoding::Context) -> usize {
311 8
312 }
313
314 #[inline(always)]
315 fn inline_size(_context: fidl::encoding::Context) -> usize {
316 16
317 }
318 }
319
320 unsafe impl<D: fidl::encoding::ResourceDialect>
321 fidl::encoding::Encode<ManagerSuspendContainerResponse, D>
322 for &ManagerSuspendContainerResponse
323 {
324 unsafe fn encode(
325 self,
326 encoder: &mut fidl::encoding::Encoder<'_, D>,
327 offset: usize,
328 mut depth: fidl::encoding::Depth,
329 ) -> fidl::Result<()> {
330 encoder.debug_check_bounds::<ManagerSuspendContainerResponse>(offset);
331 let max_ordinal: u64 = self.max_ordinal_present();
333 encoder.write_num(max_ordinal, offset);
334 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
335 if max_ordinal == 0 {
337 return Ok(());
338 }
339 depth.increment()?;
340 let envelope_size = 8;
341 let bytes_len = max_ordinal as usize * envelope_size;
342 #[allow(unused_variables)]
343 let offset = encoder.out_of_line_offset(bytes_len);
344 let mut _prev_end_offset: usize = 0;
345 if 1 > max_ordinal {
346 return Ok(());
347 }
348
349 let cur_offset: usize = (1 - 1) * envelope_size;
352
353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
355
356 fidl::encoding::encode_in_envelope_optional::<i64, D>(
361 self.suspend_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
362 encoder,
363 offset + cur_offset,
364 depth,
365 )?;
366
367 _prev_end_offset = cur_offset + envelope_size;
368 if 2 > max_ordinal {
369 return Ok(());
370 }
371
372 let cur_offset: usize = (2 - 1) * envelope_size;
375
376 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
378
379 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
384 self.resume_reason.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
385 encoder, offset + cur_offset, depth
386 )?;
387
388 _prev_end_offset = cur_offset + envelope_size;
389
390 Ok(())
391 }
392 }
393
394 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
395 for ManagerSuspendContainerResponse
396 {
397 #[inline(always)]
398 fn new_empty() -> Self {
399 Self::default()
400 }
401
402 unsafe fn decode(
403 &mut self,
404 decoder: &mut fidl::encoding::Decoder<'_, D>,
405 offset: usize,
406 mut depth: fidl::encoding::Depth,
407 ) -> fidl::Result<()> {
408 decoder.debug_check_bounds::<Self>(offset);
409 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
410 None => return Err(fidl::Error::NotNullable),
411 Some(len) => len,
412 };
413 if len == 0 {
415 return Ok(());
416 };
417 depth.increment()?;
418 let envelope_size = 8;
419 let bytes_len = len * envelope_size;
420 let offset = decoder.out_of_line_offset(bytes_len)?;
421 let mut _next_ordinal_to_read = 0;
423 let mut next_offset = offset;
424 let end_offset = offset + bytes_len;
425 _next_ordinal_to_read += 1;
426 if next_offset >= end_offset {
427 return Ok(());
428 }
429
430 while _next_ordinal_to_read < 1 {
432 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
433 _next_ordinal_to_read += 1;
434 next_offset += envelope_size;
435 }
436
437 let next_out_of_line = decoder.next_out_of_line();
438 let handles_before = decoder.remaining_handles();
439 if let Some((inlined, num_bytes, num_handles)) =
440 fidl::encoding::decode_envelope_header(decoder, next_offset)?
441 {
442 let member_inline_size =
443 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
444 if inlined != (member_inline_size <= 4) {
445 return Err(fidl::Error::InvalidInlineBitInEnvelope);
446 }
447 let inner_offset;
448 let mut inner_depth = depth.clone();
449 if inlined {
450 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
451 inner_offset = next_offset;
452 } else {
453 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
454 inner_depth.increment()?;
455 }
456 let val_ref = self.suspend_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
457 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
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 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 = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
486 if inlined != (member_inline_size <= 4) {
487 return Err(fidl::Error::InvalidInlineBitInEnvelope);
488 }
489 let inner_offset;
490 let mut inner_depth = depth.clone();
491 if inlined {
492 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
493 inner_offset = next_offset;
494 } else {
495 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
496 inner_depth.increment()?;
497 }
498 let val_ref = self.resume_reason.get_or_insert_with(|| {
499 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
500 });
501 fidl::decode!(
502 fidl::encoding::BoundedString<1024>,
503 D,
504 val_ref,
505 decoder,
506 inner_offset,
507 inner_depth
508 )?;
509 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
510 {
511 return Err(fidl::Error::InvalidNumBytesInEnvelope);
512 }
513 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
514 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
515 }
516 }
517
518 next_offset += envelope_size;
519
520 while next_offset < end_offset {
522 _next_ordinal_to_read += 1;
523 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
524 next_offset += envelope_size;
525 }
526
527 Ok(())
528 }
529 }
530
531 impl PagerRegisterFileRequest {
532 #[inline(always)]
533 fn max_ordinal_present(&self) -> u64 {
534 if let Some(_) = self.extents {
535 return 4;
536 }
537 if let Some(_) = self.size {
538 return 3;
539 }
540 if let Some(_) = self.inode_num {
541 return 2;
542 }
543 if let Some(_) = self.name {
544 return 1;
545 }
546 0
547 }
548 }
549
550 impl fidl::encoding::ValueTypeMarker for PagerRegisterFileRequest {
551 type Borrowed<'a> = &'a Self;
552 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
553 value
554 }
555 }
556
557 unsafe impl fidl::encoding::TypeMarker for PagerRegisterFileRequest {
558 type Owned = Self;
559
560 #[inline(always)]
561 fn inline_align(_context: fidl::encoding::Context) -> usize {
562 8
563 }
564
565 #[inline(always)]
566 fn inline_size(_context: fidl::encoding::Context) -> usize {
567 16
568 }
569 }
570
571 unsafe impl<D: fidl::encoding::ResourceDialect>
572 fidl::encoding::Encode<PagerRegisterFileRequest, D> for &PagerRegisterFileRequest
573 {
574 unsafe fn encode(
575 self,
576 encoder: &mut fidl::encoding::Encoder<'_, D>,
577 offset: usize,
578 mut depth: fidl::encoding::Depth,
579 ) -> fidl::Result<()> {
580 encoder.debug_check_bounds::<PagerRegisterFileRequest>(offset);
581 let max_ordinal: u64 = self.max_ordinal_present();
583 encoder.write_num(max_ordinal, offset);
584 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
585 if max_ordinal == 0 {
587 return Ok(());
588 }
589 depth.increment()?;
590 let envelope_size = 8;
591 let bytes_len = max_ordinal as usize * envelope_size;
592 #[allow(unused_variables)]
593 let offset = encoder.out_of_line_offset(bytes_len);
594 let mut _prev_end_offset: usize = 0;
595 if 1 > max_ordinal {
596 return Ok(());
597 }
598
599 let cur_offset: usize = (1 - 1) * envelope_size;
602
603 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
605
606 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
611 self.name.as_ref().map(
612 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
613 ),
614 encoder,
615 offset + cur_offset,
616 depth,
617 )?;
618
619 _prev_end_offset = cur_offset + envelope_size;
620 if 2 > max_ordinal {
621 return Ok(());
622 }
623
624 let cur_offset: usize = (2 - 1) * envelope_size;
627
628 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
630
631 fidl::encoding::encode_in_envelope_optional::<u32, D>(
636 self.inode_num.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
637 encoder,
638 offset + cur_offset,
639 depth,
640 )?;
641
642 _prev_end_offset = cur_offset + envelope_size;
643 if 3 > max_ordinal {
644 return Ok(());
645 }
646
647 let cur_offset: usize = (3 - 1) * envelope_size;
650
651 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
653
654 fidl::encoding::encode_in_envelope_optional::<u64, D>(
659 self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
660 encoder,
661 offset + cur_offset,
662 depth,
663 )?;
664
665 _prev_end_offset = cur_offset + envelope_size;
666 if 4 > max_ordinal {
667 return Ok(());
668 }
669
670 let cur_offset: usize = (4 - 1) * envelope_size;
673
674 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
676
677 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PagerExtent, 1024>, D>(
682 self.extents.as_ref().map(<fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
683 encoder, offset + cur_offset, depth
684 )?;
685
686 _prev_end_offset = cur_offset + envelope_size;
687
688 Ok(())
689 }
690 }
691
692 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
693 for PagerRegisterFileRequest
694 {
695 #[inline(always)]
696 fn new_empty() -> Self {
697 Self::default()
698 }
699
700 unsafe fn decode(
701 &mut self,
702 decoder: &mut fidl::encoding::Decoder<'_, D>,
703 offset: usize,
704 mut depth: fidl::encoding::Depth,
705 ) -> fidl::Result<()> {
706 decoder.debug_check_bounds::<Self>(offset);
707 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
708 None => return Err(fidl::Error::NotNullable),
709 Some(len) => len,
710 };
711 if len == 0 {
713 return Ok(());
714 };
715 depth.increment()?;
716 let envelope_size = 8;
717 let bytes_len = len * envelope_size;
718 let offset = decoder.out_of_line_offset(bytes_len)?;
719 let mut _next_ordinal_to_read = 0;
721 let mut next_offset = offset;
722 let end_offset = offset + bytes_len;
723 _next_ordinal_to_read += 1;
724 if next_offset >= end_offset {
725 return Ok(());
726 }
727
728 while _next_ordinal_to_read < 1 {
730 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
731 _next_ordinal_to_read += 1;
732 next_offset += envelope_size;
733 }
734
735 let next_out_of_line = decoder.next_out_of_line();
736 let handles_before = decoder.remaining_handles();
737 if let Some((inlined, num_bytes, num_handles)) =
738 fidl::encoding::decode_envelope_header(decoder, next_offset)?
739 {
740 let member_inline_size =
741 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
742 decoder.context,
743 );
744 if inlined != (member_inline_size <= 4) {
745 return Err(fidl::Error::InvalidInlineBitInEnvelope);
746 }
747 let inner_offset;
748 let mut inner_depth = depth.clone();
749 if inlined {
750 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
751 inner_offset = next_offset;
752 } else {
753 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
754 inner_depth.increment()?;
755 }
756 let val_ref = self
757 .name
758 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
759 fidl::decode!(
760 fidl::encoding::UnboundedString,
761 D,
762 val_ref,
763 decoder,
764 inner_offset,
765 inner_depth
766 )?;
767 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
768 {
769 return Err(fidl::Error::InvalidNumBytesInEnvelope);
770 }
771 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
772 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
773 }
774 }
775
776 next_offset += envelope_size;
777 _next_ordinal_to_read += 1;
778 if next_offset >= end_offset {
779 return Ok(());
780 }
781
782 while _next_ordinal_to_read < 2 {
784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
785 _next_ordinal_to_read += 1;
786 next_offset += envelope_size;
787 }
788
789 let next_out_of_line = decoder.next_out_of_line();
790 let handles_before = decoder.remaining_handles();
791 if let Some((inlined, num_bytes, num_handles)) =
792 fidl::encoding::decode_envelope_header(decoder, next_offset)?
793 {
794 let member_inline_size =
795 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
796 if inlined != (member_inline_size <= 4) {
797 return Err(fidl::Error::InvalidInlineBitInEnvelope);
798 }
799 let inner_offset;
800 let mut inner_depth = depth.clone();
801 if inlined {
802 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
803 inner_offset = next_offset;
804 } else {
805 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
806 inner_depth.increment()?;
807 }
808 let val_ref = self.inode_num.get_or_insert_with(|| fidl::new_empty!(u32, D));
809 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
810 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
811 {
812 return Err(fidl::Error::InvalidNumBytesInEnvelope);
813 }
814 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
815 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
816 }
817 }
818
819 next_offset += envelope_size;
820 _next_ordinal_to_read += 1;
821 if next_offset >= end_offset {
822 return Ok(());
823 }
824
825 while _next_ordinal_to_read < 3 {
827 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
828 _next_ordinal_to_read += 1;
829 next_offset += envelope_size;
830 }
831
832 let next_out_of_line = decoder.next_out_of_line();
833 let handles_before = decoder.remaining_handles();
834 if let Some((inlined, num_bytes, num_handles)) =
835 fidl::encoding::decode_envelope_header(decoder, next_offset)?
836 {
837 let member_inline_size =
838 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
839 if inlined != (member_inline_size <= 4) {
840 return Err(fidl::Error::InvalidInlineBitInEnvelope);
841 }
842 let inner_offset;
843 let mut inner_depth = depth.clone();
844 if inlined {
845 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
846 inner_offset = next_offset;
847 } else {
848 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
849 inner_depth.increment()?;
850 }
851 let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
852 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
853 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
854 {
855 return Err(fidl::Error::InvalidNumBytesInEnvelope);
856 }
857 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
858 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
859 }
860 }
861
862 next_offset += envelope_size;
863 _next_ordinal_to_read += 1;
864 if next_offset >= end_offset {
865 return Ok(());
866 }
867
868 while _next_ordinal_to_read < 4 {
870 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
871 _next_ordinal_to_read += 1;
872 next_offset += envelope_size;
873 }
874
875 let next_out_of_line = decoder.next_out_of_line();
876 let handles_before = decoder.remaining_handles();
877 if let Some((inlined, num_bytes, num_handles)) =
878 fidl::encoding::decode_envelope_header(decoder, next_offset)?
879 {
880 let member_inline_size = <fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
881 if inlined != (member_inline_size <= 4) {
882 return Err(fidl::Error::InvalidInlineBitInEnvelope);
883 }
884 let inner_offset;
885 let mut inner_depth = depth.clone();
886 if inlined {
887 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
888 inner_offset = next_offset;
889 } else {
890 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
891 inner_depth.increment()?;
892 }
893 let val_ref = self.extents.get_or_insert_with(
894 || fidl::new_empty!(fidl::encoding::Vector<PagerExtent, 1024>, D),
895 );
896 fidl::decode!(fidl::encoding::Vector<PagerExtent, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
897 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
898 {
899 return Err(fidl::Error::InvalidNumBytesInEnvelope);
900 }
901 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
902 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
903 }
904 }
905
906 next_offset += envelope_size;
907
908 while next_offset < end_offset {
910 _next_ordinal_to_read += 1;
911 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
912 next_offset += envelope_size;
913 }
914
915 Ok(())
916 }
917 }
918}