fidl_fuchsia_starnix_runner__common/
fidl_fuchsia_starnix_runner__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
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/// Pattern that matches an unknown `SuspendError` member.
24#[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    /// The amount of time spent in the suspend state.
86    ///
87    /// It is used for tracking suspend stats in the Starnix kernel.
88    pub suspend_time: Option<i64>,
89    /// The name of the event that woke the container.
90    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    /// The name of the file vmo.
100    pub name: Option<String>,
101    /// The inode name to use for the file.
102    pub inode_num: Option<u32>,
103    /// The size of the file.
104    pub size: Option<u64>,
105    /// The extents associated with the file, required to be sorted.
106    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                // Copy the object into the buffer.
225                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
226                (buf_ptr as *mut PagerExtent).write_unaligned((self as *const PagerExtent).read());
227                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
228                // done second because the memcpy will write garbage to these bytes.
229            }
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            // Zero out padding regions. There's no need to apply masks
249            // because the unmasked parts will be overwritten by fields.
250            // Write the fields.
251            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            // Verify that padding bytes are zero.
278            // Copy from the buffer into the object.
279            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            // Vector header
332            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            // Calling encoder.out_of_line_offset(0) is not allowed.
336            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
350            // are envelope_size bytes.
351            let cur_offset: usize = (1 - 1) * envelope_size;
352
353            // Zero reserved fields.
354            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
355
356            // Safety:
357            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
358            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
359            //   envelope_size bytes, there is always sufficient room.
360            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
373            // are envelope_size bytes.
374            let cur_offset: usize = (2 - 1) * envelope_size;
375
376            // Zero reserved fields.
377            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
378
379            // Safety:
380            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
381            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
382            //   envelope_size bytes, there is always sufficient room.
383            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            // Calling decoder.out_of_line_offset(0) is not allowed.
414            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            // Decode the envelope for each type.
422            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            // Decode unknown envelopes for gaps in ordinals.
431            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            // Decode unknown envelopes for gaps in ordinals.
474            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            // Decode the remaining unknown envelopes.
521            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            // Vector header
582            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            // Calling encoder.out_of_line_offset(0) is not allowed.
586            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
600            // are envelope_size bytes.
601            let cur_offset: usize = (1 - 1) * envelope_size;
602
603            // Zero reserved fields.
604            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
605
606            // Safety:
607            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
608            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
609            //   envelope_size bytes, there is always sufficient room.
610            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
625            // are envelope_size bytes.
626            let cur_offset: usize = (2 - 1) * envelope_size;
627
628            // Zero reserved fields.
629            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
630
631            // Safety:
632            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
633            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
634            //   envelope_size bytes, there is always sufficient room.
635            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
648            // are envelope_size bytes.
649            let cur_offset: usize = (3 - 1) * envelope_size;
650
651            // Zero reserved fields.
652            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
653
654            // Safety:
655            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
656            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
657            //   envelope_size bytes, there is always sufficient room.
658            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
671            // are envelope_size bytes.
672            let cur_offset: usize = (4 - 1) * envelope_size;
673
674            // Zero reserved fields.
675            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
676
677            // Safety:
678            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
679            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
680            //   envelope_size bytes, there is always sufficient room.
681            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            // Calling decoder.out_of_line_offset(0) is not allowed.
712            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            // Decode the envelope for each type.
720            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            // Decode unknown envelopes for gaps in ordinals.
729            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            // Decode unknown envelopes for gaps in ordinals.
783            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            // Decode unknown envelopes for gaps in ordinals.
826            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            // Decode unknown envelopes for gaps in ordinals.
869            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            // Decode the remaining unknown envelopes.
909            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}