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
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13pub enum CompressionAlgorithm {
14 ZstdChunked,
15 Uncompressed,
16 #[doc(hidden)]
17 __SourceBreaking {
18 unknown_ordinal: u32,
19 },
20}
21
22#[macro_export]
24macro_rules! CompressionAlgorithmUnknown {
25 () => {
26 _
27 };
28}
29
30impl CompressionAlgorithm {
31 #[inline]
32 pub fn from_primitive(prim: u32) -> Option<Self> {
33 match prim {
34 0 => Some(Self::ZstdChunked),
35 1 => Some(Self::Uncompressed),
36 _ => None,
37 }
38 }
39
40 #[inline]
41 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
42 match prim {
43 0 => Self::ZstdChunked,
44 1 => Self::Uncompressed,
45 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
46 }
47 }
48
49 #[inline]
50 pub fn unknown() -> Self {
51 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
52 }
53
54 #[inline]
55 pub const fn into_primitive(self) -> u32 {
56 match self {
57 Self::ZstdChunked => 0,
58 Self::Uncompressed => 1,
59 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
60 }
61 }
62
63 #[inline]
64 pub fn is_unknown(&self) -> bool {
65 match self {
66 Self::__SourceBreaking { unknown_ordinal: _ } => true,
67 _ => false,
68 }
69 }
70}
71
72#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
74pub enum EvictionPolicyOverride {
75 None,
77 NeverEvict,
79 EvictImmediately,
81 #[doc(hidden)]
82 __SourceBreaking { unknown_ordinal: u32 },
83}
84
85#[macro_export]
87macro_rules! EvictionPolicyOverrideUnknown {
88 () => {
89 _
90 };
91}
92
93impl EvictionPolicyOverride {
94 #[inline]
95 pub fn from_primitive(prim: u32) -> Option<Self> {
96 match prim {
97 0 => Some(Self::None),
98 1 => Some(Self::NeverEvict),
99 2 => Some(Self::EvictImmediately),
100 _ => None,
101 }
102 }
103
104 #[inline]
105 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
106 match prim {
107 0 => Self::None,
108 1 => Self::NeverEvict,
109 2 => Self::EvictImmediately,
110 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
111 }
112 }
113
114 #[inline]
115 pub fn unknown() -> Self {
116 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
117 }
118
119 #[inline]
120 pub const fn into_primitive(self) -> u32 {
121 match self {
122 Self::None => 0,
123 Self::NeverEvict => 1,
124 Self::EvictImmediately => 2,
125 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
126 }
127 }
128
129 #[inline]
130 pub fn is_unknown(&self) -> bool {
131 match self {
132 Self::__SourceBreaking { unknown_ordinal: _ } => true,
133 _ => false,
134 }
135 }
136}
137
138#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
139#[repr(C)]
140pub struct VolumeSetLimitRequest {
141 pub bytes: u64,
142}
143
144impl fidl::Persistable for VolumeSetLimitRequest {}
145
146#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
147#[repr(C)]
148pub struct VolumeGetLimitResponse {
149 pub bytes: u64,
150}
151
152impl fidl::Persistable for VolumeGetLimitResponse {}
153
154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155pub struct VolumesRemoveRequest {
156 pub name: String,
157}
158
159impl fidl::Persistable for VolumesRemoveRequest {}
160
161#[derive(Clone, Debug, Default, PartialEq)]
163pub struct FormatOptions {
164 pub verbose: Option<bool>,
166 pub deprecated_padded_blobfs_format: Option<bool>,
168 pub num_inodes: Option<u64>,
171 pub fvm_data_slices: Option<u32>,
173 pub sectors_per_cluster: Option<u16>,
175 #[doc(hidden)]
176 pub __source_breaking: fidl::marker::SourceBreaking,
177}
178
179impl fidl::Persistable for FormatOptions {}
180
181pub mod startup_ordinals {
182 pub const START: u64 = 0x317aa9458d3190c8;
183 pub const FORMAT: u64 = 0x3124676dd91933de;
184 pub const CHECK: u64 = 0x81e85b3190e7db3;
185}
186
187pub mod volume_ordinals {
188 pub const MOUNT: u64 = 0x3470ab56d455af0;
189 pub const CHECK: u64 = 0x5b638348f5e0418c;
190 pub const SET_LIMIT: u64 = 0x19286d83eb3cd137;
191 pub const GET_LIMIT: u64 = 0xb14e4950939f16;
192}
193
194pub mod volumes_ordinals {
195 pub const CREATE: u64 = 0x11a55097834b38e8;
196 pub const REMOVE: u64 = 0x70983b9344dc2292;
197}
198
199mod internal {
200 use super::*;
201 unsafe impl fidl::encoding::TypeMarker for CompressionAlgorithm {
202 type Owned = Self;
203
204 #[inline(always)]
205 fn inline_align(_context: fidl::encoding::Context) -> usize {
206 std::mem::align_of::<u32>()
207 }
208
209 #[inline(always)]
210 fn inline_size(_context: fidl::encoding::Context) -> usize {
211 std::mem::size_of::<u32>()
212 }
213
214 #[inline(always)]
215 fn encode_is_copy() -> bool {
216 false
217 }
218
219 #[inline(always)]
220 fn decode_is_copy() -> bool {
221 false
222 }
223 }
224
225 impl fidl::encoding::ValueTypeMarker for CompressionAlgorithm {
226 type Borrowed<'a> = Self;
227 #[inline(always)]
228 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
229 *value
230 }
231 }
232
233 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
234 for CompressionAlgorithm
235 {
236 #[inline]
237 unsafe fn encode(
238 self,
239 encoder: &mut fidl::encoding::Encoder<'_, D>,
240 offset: usize,
241 _depth: fidl::encoding::Depth,
242 ) -> fidl::Result<()> {
243 encoder.debug_check_bounds::<Self>(offset);
244 encoder.write_num(self.into_primitive(), offset);
245 Ok(())
246 }
247 }
248
249 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompressionAlgorithm {
250 #[inline(always)]
251 fn new_empty() -> Self {
252 Self::unknown()
253 }
254
255 #[inline]
256 unsafe fn decode(
257 &mut self,
258 decoder: &mut fidl::encoding::Decoder<'_, D>,
259 offset: usize,
260 _depth: fidl::encoding::Depth,
261 ) -> fidl::Result<()> {
262 decoder.debug_check_bounds::<Self>(offset);
263 let prim = decoder.read_num::<u32>(offset);
264
265 *self = Self::from_primitive_allow_unknown(prim);
266 Ok(())
267 }
268 }
269 unsafe impl fidl::encoding::TypeMarker for EvictionPolicyOverride {
270 type Owned = Self;
271
272 #[inline(always)]
273 fn inline_align(_context: fidl::encoding::Context) -> usize {
274 std::mem::align_of::<u32>()
275 }
276
277 #[inline(always)]
278 fn inline_size(_context: fidl::encoding::Context) -> usize {
279 std::mem::size_of::<u32>()
280 }
281
282 #[inline(always)]
283 fn encode_is_copy() -> bool {
284 false
285 }
286
287 #[inline(always)]
288 fn decode_is_copy() -> bool {
289 false
290 }
291 }
292
293 impl fidl::encoding::ValueTypeMarker for EvictionPolicyOverride {
294 type Borrowed<'a> = Self;
295 #[inline(always)]
296 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297 *value
298 }
299 }
300
301 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
302 for EvictionPolicyOverride
303 {
304 #[inline]
305 unsafe fn encode(
306 self,
307 encoder: &mut fidl::encoding::Encoder<'_, D>,
308 offset: usize,
309 _depth: fidl::encoding::Depth,
310 ) -> fidl::Result<()> {
311 encoder.debug_check_bounds::<Self>(offset);
312 encoder.write_num(self.into_primitive(), offset);
313 Ok(())
314 }
315 }
316
317 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
318 for EvictionPolicyOverride
319 {
320 #[inline(always)]
321 fn new_empty() -> Self {
322 Self::unknown()
323 }
324
325 #[inline]
326 unsafe fn decode(
327 &mut self,
328 decoder: &mut fidl::encoding::Decoder<'_, D>,
329 offset: usize,
330 _depth: fidl::encoding::Depth,
331 ) -> fidl::Result<()> {
332 decoder.debug_check_bounds::<Self>(offset);
333 let prim = decoder.read_num::<u32>(offset);
334
335 *self = Self::from_primitive_allow_unknown(prim);
336 Ok(())
337 }
338 }
339
340 impl fidl::encoding::ValueTypeMarker for VolumeSetLimitRequest {
341 type Borrowed<'a> = &'a Self;
342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
343 value
344 }
345 }
346
347 unsafe impl fidl::encoding::TypeMarker for VolumeSetLimitRequest {
348 type Owned = Self;
349
350 #[inline(always)]
351 fn inline_align(_context: fidl::encoding::Context) -> usize {
352 8
353 }
354
355 #[inline(always)]
356 fn inline_size(_context: fidl::encoding::Context) -> usize {
357 8
358 }
359 #[inline(always)]
360 fn encode_is_copy() -> bool {
361 true
362 }
363
364 #[inline(always)]
365 fn decode_is_copy() -> bool {
366 true
367 }
368 }
369
370 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumeSetLimitRequest, D>
371 for &VolumeSetLimitRequest
372 {
373 #[inline]
374 unsafe fn encode(
375 self,
376 encoder: &mut fidl::encoding::Encoder<'_, D>,
377 offset: usize,
378 _depth: fidl::encoding::Depth,
379 ) -> fidl::Result<()> {
380 encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
381 unsafe {
382 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
384 (buf_ptr as *mut VolumeSetLimitRequest)
385 .write_unaligned((self as *const VolumeSetLimitRequest).read());
386 }
389 Ok(())
390 }
391 }
392 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
393 fidl::encoding::Encode<VolumeSetLimitRequest, D> for (T0,)
394 {
395 #[inline]
396 unsafe fn encode(
397 self,
398 encoder: &mut fidl::encoding::Encoder<'_, D>,
399 offset: usize,
400 depth: fidl::encoding::Depth,
401 ) -> fidl::Result<()> {
402 encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
403 self.0.encode(encoder, offset + 0, depth)?;
407 Ok(())
408 }
409 }
410
411 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumeSetLimitRequest {
412 #[inline(always)]
413 fn new_empty() -> Self {
414 Self { bytes: fidl::new_empty!(u64, D) }
415 }
416
417 #[inline]
418 unsafe fn decode(
419 &mut self,
420 decoder: &mut fidl::encoding::Decoder<'_, D>,
421 offset: usize,
422 _depth: fidl::encoding::Depth,
423 ) -> fidl::Result<()> {
424 decoder.debug_check_bounds::<Self>(offset);
425 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
426 unsafe {
429 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
430 }
431 Ok(())
432 }
433 }
434
435 impl fidl::encoding::ValueTypeMarker for VolumeGetLimitResponse {
436 type Borrowed<'a> = &'a Self;
437 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
438 value
439 }
440 }
441
442 unsafe impl fidl::encoding::TypeMarker for VolumeGetLimitResponse {
443 type Owned = Self;
444
445 #[inline(always)]
446 fn inline_align(_context: fidl::encoding::Context) -> usize {
447 8
448 }
449
450 #[inline(always)]
451 fn inline_size(_context: fidl::encoding::Context) -> usize {
452 8
453 }
454 #[inline(always)]
455 fn encode_is_copy() -> bool {
456 true
457 }
458
459 #[inline(always)]
460 fn decode_is_copy() -> bool {
461 true
462 }
463 }
464
465 unsafe impl<D: fidl::encoding::ResourceDialect>
466 fidl::encoding::Encode<VolumeGetLimitResponse, D> for &VolumeGetLimitResponse
467 {
468 #[inline]
469 unsafe fn encode(
470 self,
471 encoder: &mut fidl::encoding::Encoder<'_, D>,
472 offset: usize,
473 _depth: fidl::encoding::Depth,
474 ) -> fidl::Result<()> {
475 encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
476 unsafe {
477 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
479 (buf_ptr as *mut VolumeGetLimitResponse)
480 .write_unaligned((self as *const VolumeGetLimitResponse).read());
481 }
484 Ok(())
485 }
486 }
487 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
488 fidl::encoding::Encode<VolumeGetLimitResponse, D> for (T0,)
489 {
490 #[inline]
491 unsafe fn encode(
492 self,
493 encoder: &mut fidl::encoding::Encoder<'_, D>,
494 offset: usize,
495 depth: fidl::encoding::Depth,
496 ) -> fidl::Result<()> {
497 encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
498 self.0.encode(encoder, offset + 0, depth)?;
502 Ok(())
503 }
504 }
505
506 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
507 for VolumeGetLimitResponse
508 {
509 #[inline(always)]
510 fn new_empty() -> Self {
511 Self { bytes: fidl::new_empty!(u64, D) }
512 }
513
514 #[inline]
515 unsafe fn decode(
516 &mut self,
517 decoder: &mut fidl::encoding::Decoder<'_, D>,
518 offset: usize,
519 _depth: fidl::encoding::Depth,
520 ) -> fidl::Result<()> {
521 decoder.debug_check_bounds::<Self>(offset);
522 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
523 unsafe {
526 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
527 }
528 Ok(())
529 }
530 }
531
532 impl fidl::encoding::ValueTypeMarker for VolumesRemoveRequest {
533 type Borrowed<'a> = &'a Self;
534 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
535 value
536 }
537 }
538
539 unsafe impl fidl::encoding::TypeMarker for VolumesRemoveRequest {
540 type Owned = Self;
541
542 #[inline(always)]
543 fn inline_align(_context: fidl::encoding::Context) -> usize {
544 8
545 }
546
547 #[inline(always)]
548 fn inline_size(_context: fidl::encoding::Context) -> usize {
549 16
550 }
551 }
552
553 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumesRemoveRequest, D>
554 for &VolumesRemoveRequest
555 {
556 #[inline]
557 unsafe fn encode(
558 self,
559 encoder: &mut fidl::encoding::Encoder<'_, D>,
560 offset: usize,
561 _depth: fidl::encoding::Depth,
562 ) -> fidl::Result<()> {
563 encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
564 fidl::encoding::Encode::<VolumesRemoveRequest, D>::encode(
566 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
567 &self.name,
568 ),),
569 encoder,
570 offset,
571 _depth,
572 )
573 }
574 }
575 unsafe impl<
576 D: fidl::encoding::ResourceDialect,
577 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
578 > fidl::encoding::Encode<VolumesRemoveRequest, D> for (T0,)
579 {
580 #[inline]
581 unsafe fn encode(
582 self,
583 encoder: &mut fidl::encoding::Encoder<'_, D>,
584 offset: usize,
585 depth: fidl::encoding::Depth,
586 ) -> fidl::Result<()> {
587 encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
588 self.0.encode(encoder, offset + 0, depth)?;
592 Ok(())
593 }
594 }
595
596 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumesRemoveRequest {
597 #[inline(always)]
598 fn new_empty() -> Self {
599 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
600 }
601
602 #[inline]
603 unsafe fn decode(
604 &mut self,
605 decoder: &mut fidl::encoding::Decoder<'_, D>,
606 offset: usize,
607 _depth: fidl::encoding::Depth,
608 ) -> fidl::Result<()> {
609 decoder.debug_check_bounds::<Self>(offset);
610 fidl::decode!(
612 fidl::encoding::BoundedString<255>,
613 D,
614 &mut self.name,
615 decoder,
616 offset + 0,
617 _depth
618 )?;
619 Ok(())
620 }
621 }
622
623 impl FormatOptions {
624 #[inline(always)]
625 fn max_ordinal_present(&self) -> u64 {
626 if let Some(_) = self.sectors_per_cluster {
627 return 5;
628 }
629 if let Some(_) = self.fvm_data_slices {
630 return 4;
631 }
632 if let Some(_) = self.num_inodes {
633 return 3;
634 }
635 if let Some(_) = self.deprecated_padded_blobfs_format {
636 return 2;
637 }
638 if let Some(_) = self.verbose {
639 return 1;
640 }
641 0
642 }
643 }
644
645 impl fidl::encoding::ValueTypeMarker for FormatOptions {
646 type Borrowed<'a> = &'a Self;
647 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
648 value
649 }
650 }
651
652 unsafe impl fidl::encoding::TypeMarker for FormatOptions {
653 type Owned = Self;
654
655 #[inline(always)]
656 fn inline_align(_context: fidl::encoding::Context) -> usize {
657 8
658 }
659
660 #[inline(always)]
661 fn inline_size(_context: fidl::encoding::Context) -> usize {
662 16
663 }
664 }
665
666 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatOptions, D>
667 for &FormatOptions
668 {
669 unsafe fn encode(
670 self,
671 encoder: &mut fidl::encoding::Encoder<'_, D>,
672 offset: usize,
673 mut depth: fidl::encoding::Depth,
674 ) -> fidl::Result<()> {
675 encoder.debug_check_bounds::<FormatOptions>(offset);
676 let max_ordinal: u64 = self.max_ordinal_present();
678 encoder.write_num(max_ordinal, offset);
679 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
680 if max_ordinal == 0 {
682 return Ok(());
683 }
684 depth.increment()?;
685 let envelope_size = 8;
686 let bytes_len = max_ordinal as usize * envelope_size;
687 #[allow(unused_variables)]
688 let offset = encoder.out_of_line_offset(bytes_len);
689 let mut _prev_end_offset: usize = 0;
690 if 1 > max_ordinal {
691 return Ok(());
692 }
693
694 let cur_offset: usize = (1 - 1) * envelope_size;
697
698 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
700
701 fidl::encoding::encode_in_envelope_optional::<bool, D>(
706 self.verbose.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
707 encoder,
708 offset + cur_offset,
709 depth,
710 )?;
711
712 _prev_end_offset = cur_offset + envelope_size;
713 if 2 > max_ordinal {
714 return Ok(());
715 }
716
717 let cur_offset: usize = (2 - 1) * envelope_size;
720
721 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
723
724 fidl::encoding::encode_in_envelope_optional::<bool, D>(
729 self.deprecated_padded_blobfs_format
730 .as_ref()
731 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
732 encoder,
733 offset + cur_offset,
734 depth,
735 )?;
736
737 _prev_end_offset = cur_offset + envelope_size;
738 if 3 > max_ordinal {
739 return Ok(());
740 }
741
742 let cur_offset: usize = (3 - 1) * envelope_size;
745
746 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
748
749 fidl::encoding::encode_in_envelope_optional::<u64, D>(
754 self.num_inodes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
755 encoder,
756 offset + cur_offset,
757 depth,
758 )?;
759
760 _prev_end_offset = cur_offset + envelope_size;
761 if 4 > max_ordinal {
762 return Ok(());
763 }
764
765 let cur_offset: usize = (4 - 1) * envelope_size;
768
769 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
771
772 fidl::encoding::encode_in_envelope_optional::<u32, D>(
777 self.fvm_data_slices.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
778 encoder,
779 offset + cur_offset,
780 depth,
781 )?;
782
783 _prev_end_offset = cur_offset + envelope_size;
784 if 5 > max_ordinal {
785 return Ok(());
786 }
787
788 let cur_offset: usize = (5 - 1) * envelope_size;
791
792 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
794
795 fidl::encoding::encode_in_envelope_optional::<u16, D>(
800 self.sectors_per_cluster
801 .as_ref()
802 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
803 encoder,
804 offset + cur_offset,
805 depth,
806 )?;
807
808 _prev_end_offset = cur_offset + envelope_size;
809
810 Ok(())
811 }
812 }
813
814 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatOptions {
815 #[inline(always)]
816 fn new_empty() -> Self {
817 Self::default()
818 }
819
820 unsafe fn decode(
821 &mut self,
822 decoder: &mut fidl::encoding::Decoder<'_, D>,
823 offset: usize,
824 mut depth: fidl::encoding::Depth,
825 ) -> fidl::Result<()> {
826 decoder.debug_check_bounds::<Self>(offset);
827 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
828 None => return Err(fidl::Error::NotNullable),
829 Some(len) => len,
830 };
831 if len == 0 {
833 return Ok(());
834 };
835 depth.increment()?;
836 let envelope_size = 8;
837 let bytes_len = len * envelope_size;
838 let offset = decoder.out_of_line_offset(bytes_len)?;
839 let mut _next_ordinal_to_read = 0;
841 let mut next_offset = offset;
842 let end_offset = offset + bytes_len;
843 _next_ordinal_to_read += 1;
844 if next_offset >= end_offset {
845 return Ok(());
846 }
847
848 while _next_ordinal_to_read < 1 {
850 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
851 _next_ordinal_to_read += 1;
852 next_offset += envelope_size;
853 }
854
855 let next_out_of_line = decoder.next_out_of_line();
856 let handles_before = decoder.remaining_handles();
857 if let Some((inlined, num_bytes, num_handles)) =
858 fidl::encoding::decode_envelope_header(decoder, next_offset)?
859 {
860 let member_inline_size =
861 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
862 if inlined != (member_inline_size <= 4) {
863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
864 }
865 let inner_offset;
866 let mut inner_depth = depth.clone();
867 if inlined {
868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
869 inner_offset = next_offset;
870 } else {
871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
872 inner_depth.increment()?;
873 }
874 let val_ref = self.verbose.get_or_insert_with(|| fidl::new_empty!(bool, D));
875 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
876 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
877 {
878 return Err(fidl::Error::InvalidNumBytesInEnvelope);
879 }
880 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
881 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
882 }
883 }
884
885 next_offset += envelope_size;
886 _next_ordinal_to_read += 1;
887 if next_offset >= end_offset {
888 return Ok(());
889 }
890
891 while _next_ordinal_to_read < 2 {
893 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
894 _next_ordinal_to_read += 1;
895 next_offset += envelope_size;
896 }
897
898 let next_out_of_line = decoder.next_out_of_line();
899 let handles_before = decoder.remaining_handles();
900 if let Some((inlined, num_bytes, num_handles)) =
901 fidl::encoding::decode_envelope_header(decoder, next_offset)?
902 {
903 let member_inline_size =
904 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
905 if inlined != (member_inline_size <= 4) {
906 return Err(fidl::Error::InvalidInlineBitInEnvelope);
907 }
908 let inner_offset;
909 let mut inner_depth = depth.clone();
910 if inlined {
911 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
912 inner_offset = next_offset;
913 } else {
914 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
915 inner_depth.increment()?;
916 }
917 let val_ref = self
918 .deprecated_padded_blobfs_format
919 .get_or_insert_with(|| fidl::new_empty!(bool, D));
920 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
921 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
922 {
923 return Err(fidl::Error::InvalidNumBytesInEnvelope);
924 }
925 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
926 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
927 }
928 }
929
930 next_offset += envelope_size;
931 _next_ordinal_to_read += 1;
932 if next_offset >= end_offset {
933 return Ok(());
934 }
935
936 while _next_ordinal_to_read < 3 {
938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
939 _next_ordinal_to_read += 1;
940 next_offset += envelope_size;
941 }
942
943 let next_out_of_line = decoder.next_out_of_line();
944 let handles_before = decoder.remaining_handles();
945 if let Some((inlined, num_bytes, num_handles)) =
946 fidl::encoding::decode_envelope_header(decoder, next_offset)?
947 {
948 let member_inline_size =
949 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
950 if inlined != (member_inline_size <= 4) {
951 return Err(fidl::Error::InvalidInlineBitInEnvelope);
952 }
953 let inner_offset;
954 let mut inner_depth = depth.clone();
955 if inlined {
956 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
957 inner_offset = next_offset;
958 } else {
959 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
960 inner_depth.increment()?;
961 }
962 let val_ref = self.num_inodes.get_or_insert_with(|| fidl::new_empty!(u64, D));
963 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
964 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
965 {
966 return Err(fidl::Error::InvalidNumBytesInEnvelope);
967 }
968 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
969 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
970 }
971 }
972
973 next_offset += envelope_size;
974 _next_ordinal_to_read += 1;
975 if next_offset >= end_offset {
976 return Ok(());
977 }
978
979 while _next_ordinal_to_read < 4 {
981 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
982 _next_ordinal_to_read += 1;
983 next_offset += envelope_size;
984 }
985
986 let next_out_of_line = decoder.next_out_of_line();
987 let handles_before = decoder.remaining_handles();
988 if let Some((inlined, num_bytes, num_handles)) =
989 fidl::encoding::decode_envelope_header(decoder, next_offset)?
990 {
991 let member_inline_size =
992 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
993 if inlined != (member_inline_size <= 4) {
994 return Err(fidl::Error::InvalidInlineBitInEnvelope);
995 }
996 let inner_offset;
997 let mut inner_depth = depth.clone();
998 if inlined {
999 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1000 inner_offset = next_offset;
1001 } else {
1002 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1003 inner_depth.increment()?;
1004 }
1005 let val_ref = self.fvm_data_slices.get_or_insert_with(|| fidl::new_empty!(u32, D));
1006 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1007 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1008 {
1009 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1010 }
1011 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1012 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1013 }
1014 }
1015
1016 next_offset += envelope_size;
1017 _next_ordinal_to_read += 1;
1018 if next_offset >= end_offset {
1019 return Ok(());
1020 }
1021
1022 while _next_ordinal_to_read < 5 {
1024 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1025 _next_ordinal_to_read += 1;
1026 next_offset += envelope_size;
1027 }
1028
1029 let next_out_of_line = decoder.next_out_of_line();
1030 let handles_before = decoder.remaining_handles();
1031 if let Some((inlined, num_bytes, num_handles)) =
1032 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1033 {
1034 let member_inline_size =
1035 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1036 if inlined != (member_inline_size <= 4) {
1037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1038 }
1039 let inner_offset;
1040 let mut inner_depth = depth.clone();
1041 if inlined {
1042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1043 inner_offset = next_offset;
1044 } else {
1045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1046 inner_depth.increment()?;
1047 }
1048 let val_ref =
1049 self.sectors_per_cluster.get_or_insert_with(|| fidl::new_empty!(u16, D));
1050 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
1051 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1052 {
1053 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1054 }
1055 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1056 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1057 }
1058 }
1059
1060 next_offset += envelope_size;
1061
1062 while next_offset < end_offset {
1064 _next_ordinal_to_read += 1;
1065 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1066 next_offset += envelope_size;
1067 }
1068
1069 Ok(())
1070 }
1071 }
1072}