fidl_fuchsia_hardware_block_partition__common/
fidl_fuchsia_hardware_block_partition__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 GUID_LENGTH: u32 = 16;
12
13pub const NAME_LENGTH: u32 = 128;
14
15/// A Globally Unique IDentifier, which may be utilized to identify
16/// a partition.
17#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
18#[repr(C)]
19pub struct Guid {
20    pub value: [u8; 16],
21}
22
23impl fidl::Persistable for Guid {}
24
25#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
26pub struct PartitionGetInstanceGuidResponse {
27    pub status: i32,
28    pub guid: Option<Box<Guid>>,
29}
30
31impl fidl::Persistable for PartitionGetInstanceGuidResponse {}
32
33#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
34pub struct PartitionGetNameResponse {
35    pub status: i32,
36    pub name: Option<String>,
37}
38
39impl fidl::Persistable for PartitionGetNameResponse {}
40
41#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
42pub struct PartitionGetTypeGuidResponse {
43    pub status: i32,
44    pub guid: Option<Box<Guid>>,
45}
46
47impl fidl::Persistable for PartitionGetTypeGuidResponse {}
48
49#[derive(Clone, Debug, Default, PartialEq)]
50pub struct PartitionGetMetadataResponse {
51    pub name: Option<String>,
52    pub type_guid: Option<Guid>,
53    pub instance_guid: Option<Guid>,
54    /// start_block_offset will be absent if the partition is non-contiguous.
55    pub start_block_offset: Option<u64>,
56    /// num_blocks will be absent if the partition is a dynamic volume, in which case
57    /// fuchsia.hardware.block.volume.Volume/GetVolumeInfo should be called instead.
58    pub num_blocks: Option<u64>,
59    pub flags: Option<u64>,
60    #[doc(hidden)]
61    pub __source_breaking: fidl::marker::SourceBreaking,
62}
63
64impl fidl::Persistable for PartitionGetMetadataResponse {}
65
66pub mod partition_ordinals {
67    pub const GET_INFO: u64 = 0x79df1a5cdb6cc6a3;
68    pub const GET_STATS: u64 = 0x53d9542a778385ae;
69    pub const OPEN_SESSION: u64 = 0x7241c68d17614a31;
70    pub const OPEN_SESSION_WITH_OFFSET_MAP: u64 = 0x7a8d3ba3d8bfa10f;
71    pub const GET_TYPE_GUID: u64 = 0x111843d737a9b847;
72    pub const GET_INSTANCE_GUID: u64 = 0x14a5a573b275d435;
73    pub const GET_NAME: u64 = 0x7e3c6f0b0937fc02;
74    pub const GET_METADATA: u64 = 0x42d1464c96c3f3ff;
75}
76
77mod internal {
78    use super::*;
79
80    impl fidl::encoding::ValueTypeMarker for Guid {
81        type Borrowed<'a> = &'a Self;
82        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
83            value
84        }
85    }
86
87    unsafe impl fidl::encoding::TypeMarker for Guid {
88        type Owned = Self;
89
90        #[inline(always)]
91        fn inline_align(_context: fidl::encoding::Context) -> usize {
92            1
93        }
94
95        #[inline(always)]
96        fn inline_size(_context: fidl::encoding::Context) -> usize {
97            16
98        }
99        #[inline(always)]
100        fn encode_is_copy() -> bool {
101            true
102        }
103
104        #[inline(always)]
105        fn decode_is_copy() -> bool {
106            true
107        }
108    }
109
110    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Guid, D> for &Guid {
111        #[inline]
112        unsafe fn encode(
113            self,
114            encoder: &mut fidl::encoding::Encoder<'_, D>,
115            offset: usize,
116            _depth: fidl::encoding::Depth,
117        ) -> fidl::Result<()> {
118            encoder.debug_check_bounds::<Guid>(offset);
119            unsafe {
120                // Copy the object into the buffer.
121                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
122                (buf_ptr as *mut Guid).write_unaligned((self as *const Guid).read());
123                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
124                // done second because the memcpy will write garbage to these bytes.
125            }
126            Ok(())
127        }
128    }
129    unsafe impl<
130            D: fidl::encoding::ResourceDialect,
131            T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 16>, D>,
132        > fidl::encoding::Encode<Guid, D> for (T0,)
133    {
134        #[inline]
135        unsafe fn encode(
136            self,
137            encoder: &mut fidl::encoding::Encoder<'_, D>,
138            offset: usize,
139            depth: fidl::encoding::Depth,
140        ) -> fidl::Result<()> {
141            encoder.debug_check_bounds::<Guid>(offset);
142            // Zero out padding regions. There's no need to apply masks
143            // because the unmasked parts will be overwritten by fields.
144            // Write the fields.
145            self.0.encode(encoder, offset + 0, depth)?;
146            Ok(())
147        }
148    }
149
150    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Guid {
151        #[inline(always)]
152        fn new_empty() -> Self {
153            Self { value: fidl::new_empty!(fidl::encoding::Array<u8, 16>, D) }
154        }
155
156        #[inline]
157        unsafe fn decode(
158            &mut self,
159            decoder: &mut fidl::encoding::Decoder<'_, D>,
160            offset: usize,
161            _depth: fidl::encoding::Depth,
162        ) -> fidl::Result<()> {
163            decoder.debug_check_bounds::<Self>(offset);
164            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
165            // Verify that padding bytes are zero.
166            // Copy from the buffer into the object.
167            unsafe {
168                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
169            }
170            Ok(())
171        }
172    }
173
174    impl fidl::encoding::ValueTypeMarker for PartitionGetInstanceGuidResponse {
175        type Borrowed<'a> = &'a Self;
176        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
177            value
178        }
179    }
180
181    unsafe impl fidl::encoding::TypeMarker for PartitionGetInstanceGuidResponse {
182        type Owned = Self;
183
184        #[inline(always)]
185        fn inline_align(_context: fidl::encoding::Context) -> usize {
186            8
187        }
188
189        #[inline(always)]
190        fn inline_size(_context: fidl::encoding::Context) -> usize {
191            16
192        }
193    }
194
195    unsafe impl<D: fidl::encoding::ResourceDialect>
196        fidl::encoding::Encode<PartitionGetInstanceGuidResponse, D>
197        for &PartitionGetInstanceGuidResponse
198    {
199        #[inline]
200        unsafe fn encode(
201            self,
202            encoder: &mut fidl::encoding::Encoder<'_, D>,
203            offset: usize,
204            _depth: fidl::encoding::Depth,
205        ) -> fidl::Result<()> {
206            encoder.debug_check_bounds::<PartitionGetInstanceGuidResponse>(offset);
207            // Delegate to tuple encoding.
208            fidl::encoding::Encode::<PartitionGetInstanceGuidResponse, D>::encode(
209                (
210                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
211                    <fidl::encoding::Boxed<Guid> as fidl::encoding::ValueTypeMarker>::borrow(
212                        &self.guid,
213                    ),
214                ),
215                encoder,
216                offset,
217                _depth,
218            )
219        }
220    }
221    unsafe impl<
222            D: fidl::encoding::ResourceDialect,
223            T0: fidl::encoding::Encode<i32, D>,
224            T1: fidl::encoding::Encode<fidl::encoding::Boxed<Guid>, D>,
225        > fidl::encoding::Encode<PartitionGetInstanceGuidResponse, D> for (T0, T1)
226    {
227        #[inline]
228        unsafe fn encode(
229            self,
230            encoder: &mut fidl::encoding::Encoder<'_, D>,
231            offset: usize,
232            depth: fidl::encoding::Depth,
233        ) -> fidl::Result<()> {
234            encoder.debug_check_bounds::<PartitionGetInstanceGuidResponse>(offset);
235            // Zero out padding regions. There's no need to apply masks
236            // because the unmasked parts will be overwritten by fields.
237            unsafe {
238                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
239                (ptr as *mut u64).write_unaligned(0);
240            }
241            // Write the fields.
242            self.0.encode(encoder, offset + 0, depth)?;
243            self.1.encode(encoder, offset + 8, depth)?;
244            Ok(())
245        }
246    }
247
248    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
249        for PartitionGetInstanceGuidResponse
250    {
251        #[inline(always)]
252        fn new_empty() -> Self {
253            Self {
254                status: fidl::new_empty!(i32, D),
255                guid: fidl::new_empty!(fidl::encoding::Boxed<Guid>, D),
256            }
257        }
258
259        #[inline]
260        unsafe fn decode(
261            &mut self,
262            decoder: &mut fidl::encoding::Decoder<'_, D>,
263            offset: usize,
264            _depth: fidl::encoding::Depth,
265        ) -> fidl::Result<()> {
266            decoder.debug_check_bounds::<Self>(offset);
267            // Verify that padding bytes are zero.
268            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
269            let padval = unsafe { (ptr as *const u64).read_unaligned() };
270            let mask = 0xffffffff00000000u64;
271            let maskedval = padval & mask;
272            if maskedval != 0 {
273                return Err(fidl::Error::NonZeroPadding {
274                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
275                });
276            }
277            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
278            fidl::decode!(
279                fidl::encoding::Boxed<Guid>,
280                D,
281                &mut self.guid,
282                decoder,
283                offset + 8,
284                _depth
285            )?;
286            Ok(())
287        }
288    }
289
290    impl fidl::encoding::ValueTypeMarker for PartitionGetNameResponse {
291        type Borrowed<'a> = &'a Self;
292        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
293            value
294        }
295    }
296
297    unsafe impl fidl::encoding::TypeMarker for PartitionGetNameResponse {
298        type Owned = Self;
299
300        #[inline(always)]
301        fn inline_align(_context: fidl::encoding::Context) -> usize {
302            8
303        }
304
305        #[inline(always)]
306        fn inline_size(_context: fidl::encoding::Context) -> usize {
307            24
308        }
309    }
310
311    unsafe impl<D: fidl::encoding::ResourceDialect>
312        fidl::encoding::Encode<PartitionGetNameResponse, D> for &PartitionGetNameResponse
313    {
314        #[inline]
315        unsafe fn encode(
316            self,
317            encoder: &mut fidl::encoding::Encoder<'_, D>,
318            offset: usize,
319            _depth: fidl::encoding::Depth,
320        ) -> fidl::Result<()> {
321            encoder.debug_check_bounds::<PartitionGetNameResponse>(offset);
322            // Delegate to tuple encoding.
323            fidl::encoding::Encode::<PartitionGetNameResponse, D>::encode(
324                (
325                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
326                    <fidl::encoding::Optional<fidl::encoding::BoundedString<128>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
327                ),
328                encoder, offset, _depth
329            )
330        }
331    }
332    unsafe impl<
333            D: fidl::encoding::ResourceDialect,
334            T0: fidl::encoding::Encode<i32, D>,
335            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<128>>, D>,
336        > fidl::encoding::Encode<PartitionGetNameResponse, D> for (T0, T1)
337    {
338        #[inline]
339        unsafe fn encode(
340            self,
341            encoder: &mut fidl::encoding::Encoder<'_, D>,
342            offset: usize,
343            depth: fidl::encoding::Depth,
344        ) -> fidl::Result<()> {
345            encoder.debug_check_bounds::<PartitionGetNameResponse>(offset);
346            // Zero out padding regions. There's no need to apply masks
347            // because the unmasked parts will be overwritten by fields.
348            unsafe {
349                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
350                (ptr as *mut u64).write_unaligned(0);
351            }
352            // Write the fields.
353            self.0.encode(encoder, offset + 0, depth)?;
354            self.1.encode(encoder, offset + 8, depth)?;
355            Ok(())
356        }
357    }
358
359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
360        for PartitionGetNameResponse
361    {
362        #[inline(always)]
363        fn new_empty() -> Self {
364            Self {
365                status: fidl::new_empty!(i32, D),
366                name: fidl::new_empty!(
367                    fidl::encoding::Optional<fidl::encoding::BoundedString<128>>,
368                    D
369                ),
370            }
371        }
372
373        #[inline]
374        unsafe fn decode(
375            &mut self,
376            decoder: &mut fidl::encoding::Decoder<'_, D>,
377            offset: usize,
378            _depth: fidl::encoding::Depth,
379        ) -> fidl::Result<()> {
380            decoder.debug_check_bounds::<Self>(offset);
381            // Verify that padding bytes are zero.
382            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
383            let padval = unsafe { (ptr as *const u64).read_unaligned() };
384            let mask = 0xffffffff00000000u64;
385            let maskedval = padval & mask;
386            if maskedval != 0 {
387                return Err(fidl::Error::NonZeroPadding {
388                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
389                });
390            }
391            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
392            fidl::decode!(
393                fidl::encoding::Optional<fidl::encoding::BoundedString<128>>,
394                D,
395                &mut self.name,
396                decoder,
397                offset + 8,
398                _depth
399            )?;
400            Ok(())
401        }
402    }
403
404    impl fidl::encoding::ValueTypeMarker for PartitionGetTypeGuidResponse {
405        type Borrowed<'a> = &'a Self;
406        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
407            value
408        }
409    }
410
411    unsafe impl fidl::encoding::TypeMarker for PartitionGetTypeGuidResponse {
412        type Owned = Self;
413
414        #[inline(always)]
415        fn inline_align(_context: fidl::encoding::Context) -> usize {
416            8
417        }
418
419        #[inline(always)]
420        fn inline_size(_context: fidl::encoding::Context) -> usize {
421            16
422        }
423    }
424
425    unsafe impl<D: fidl::encoding::ResourceDialect>
426        fidl::encoding::Encode<PartitionGetTypeGuidResponse, D> for &PartitionGetTypeGuidResponse
427    {
428        #[inline]
429        unsafe fn encode(
430            self,
431            encoder: &mut fidl::encoding::Encoder<'_, D>,
432            offset: usize,
433            _depth: fidl::encoding::Depth,
434        ) -> fidl::Result<()> {
435            encoder.debug_check_bounds::<PartitionGetTypeGuidResponse>(offset);
436            // Delegate to tuple encoding.
437            fidl::encoding::Encode::<PartitionGetTypeGuidResponse, D>::encode(
438                (
439                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
440                    <fidl::encoding::Boxed<Guid> as fidl::encoding::ValueTypeMarker>::borrow(
441                        &self.guid,
442                    ),
443                ),
444                encoder,
445                offset,
446                _depth,
447            )
448        }
449    }
450    unsafe impl<
451            D: fidl::encoding::ResourceDialect,
452            T0: fidl::encoding::Encode<i32, D>,
453            T1: fidl::encoding::Encode<fidl::encoding::Boxed<Guid>, D>,
454        > fidl::encoding::Encode<PartitionGetTypeGuidResponse, D> for (T0, T1)
455    {
456        #[inline]
457        unsafe fn encode(
458            self,
459            encoder: &mut fidl::encoding::Encoder<'_, D>,
460            offset: usize,
461            depth: fidl::encoding::Depth,
462        ) -> fidl::Result<()> {
463            encoder.debug_check_bounds::<PartitionGetTypeGuidResponse>(offset);
464            // Zero out padding regions. There's no need to apply masks
465            // because the unmasked parts will be overwritten by fields.
466            unsafe {
467                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
468                (ptr as *mut u64).write_unaligned(0);
469            }
470            // Write the fields.
471            self.0.encode(encoder, offset + 0, depth)?;
472            self.1.encode(encoder, offset + 8, depth)?;
473            Ok(())
474        }
475    }
476
477    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
478        for PartitionGetTypeGuidResponse
479    {
480        #[inline(always)]
481        fn new_empty() -> Self {
482            Self {
483                status: fidl::new_empty!(i32, D),
484                guid: fidl::new_empty!(fidl::encoding::Boxed<Guid>, D),
485            }
486        }
487
488        #[inline]
489        unsafe fn decode(
490            &mut self,
491            decoder: &mut fidl::encoding::Decoder<'_, D>,
492            offset: usize,
493            _depth: fidl::encoding::Depth,
494        ) -> fidl::Result<()> {
495            decoder.debug_check_bounds::<Self>(offset);
496            // Verify that padding bytes are zero.
497            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
498            let padval = unsafe { (ptr as *const u64).read_unaligned() };
499            let mask = 0xffffffff00000000u64;
500            let maskedval = padval & mask;
501            if maskedval != 0 {
502                return Err(fidl::Error::NonZeroPadding {
503                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
504                });
505            }
506            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
507            fidl::decode!(
508                fidl::encoding::Boxed<Guid>,
509                D,
510                &mut self.guid,
511                decoder,
512                offset + 8,
513                _depth
514            )?;
515            Ok(())
516        }
517    }
518
519    impl PartitionGetMetadataResponse {
520        #[inline(always)]
521        fn max_ordinal_present(&self) -> u64 {
522            if let Some(_) = self.flags {
523                return 6;
524            }
525            if let Some(_) = self.num_blocks {
526                return 5;
527            }
528            if let Some(_) = self.start_block_offset {
529                return 4;
530            }
531            if let Some(_) = self.instance_guid {
532                return 3;
533            }
534            if let Some(_) = self.type_guid {
535                return 2;
536            }
537            if let Some(_) = self.name {
538                return 1;
539            }
540            0
541        }
542    }
543
544    impl fidl::encoding::ValueTypeMarker for PartitionGetMetadataResponse {
545        type Borrowed<'a> = &'a Self;
546        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
547            value
548        }
549    }
550
551    unsafe impl fidl::encoding::TypeMarker for PartitionGetMetadataResponse {
552        type Owned = Self;
553
554        #[inline(always)]
555        fn inline_align(_context: fidl::encoding::Context) -> usize {
556            8
557        }
558
559        #[inline(always)]
560        fn inline_size(_context: fidl::encoding::Context) -> usize {
561            16
562        }
563    }
564
565    unsafe impl<D: fidl::encoding::ResourceDialect>
566        fidl::encoding::Encode<PartitionGetMetadataResponse, D> for &PartitionGetMetadataResponse
567    {
568        unsafe fn encode(
569            self,
570            encoder: &mut fidl::encoding::Encoder<'_, D>,
571            offset: usize,
572            mut depth: fidl::encoding::Depth,
573        ) -> fidl::Result<()> {
574            encoder.debug_check_bounds::<PartitionGetMetadataResponse>(offset);
575            // Vector header
576            let max_ordinal: u64 = self.max_ordinal_present();
577            encoder.write_num(max_ordinal, offset);
578            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
579            // Calling encoder.out_of_line_offset(0) is not allowed.
580            if max_ordinal == 0 {
581                return Ok(());
582            }
583            depth.increment()?;
584            let envelope_size = 8;
585            let bytes_len = max_ordinal as usize * envelope_size;
586            #[allow(unused_variables)]
587            let offset = encoder.out_of_line_offset(bytes_len);
588            let mut _prev_end_offset: usize = 0;
589            if 1 > max_ordinal {
590                return Ok(());
591            }
592
593            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
594            // are envelope_size bytes.
595            let cur_offset: usize = (1 - 1) * envelope_size;
596
597            // Zero reserved fields.
598            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
599
600            // Safety:
601            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
602            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
603            //   envelope_size bytes, there is always sufficient room.
604            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
605                self.name.as_ref().map(
606                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
607                ),
608                encoder,
609                offset + cur_offset,
610                depth,
611            )?;
612
613            _prev_end_offset = cur_offset + envelope_size;
614            if 2 > max_ordinal {
615                return Ok(());
616            }
617
618            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
619            // are envelope_size bytes.
620            let cur_offset: usize = (2 - 1) * envelope_size;
621
622            // Zero reserved fields.
623            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
624
625            // Safety:
626            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
627            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
628            //   envelope_size bytes, there is always sufficient room.
629            fidl::encoding::encode_in_envelope_optional::<Guid, D>(
630                self.type_guid.as_ref().map(<Guid as fidl::encoding::ValueTypeMarker>::borrow),
631                encoder,
632                offset + cur_offset,
633                depth,
634            )?;
635
636            _prev_end_offset = cur_offset + envelope_size;
637            if 3 > max_ordinal {
638                return Ok(());
639            }
640
641            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
642            // are envelope_size bytes.
643            let cur_offset: usize = (3 - 1) * envelope_size;
644
645            // Zero reserved fields.
646            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
647
648            // Safety:
649            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
650            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
651            //   envelope_size bytes, there is always sufficient room.
652            fidl::encoding::encode_in_envelope_optional::<Guid, D>(
653                self.instance_guid.as_ref().map(<Guid as fidl::encoding::ValueTypeMarker>::borrow),
654                encoder,
655                offset + cur_offset,
656                depth,
657            )?;
658
659            _prev_end_offset = cur_offset + envelope_size;
660            if 4 > max_ordinal {
661                return Ok(());
662            }
663
664            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
665            // are envelope_size bytes.
666            let cur_offset: usize = (4 - 1) * envelope_size;
667
668            // Zero reserved fields.
669            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
670
671            // Safety:
672            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
673            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
674            //   envelope_size bytes, there is always sufficient room.
675            fidl::encoding::encode_in_envelope_optional::<u64, D>(
676                self.start_block_offset
677                    .as_ref()
678                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
679                encoder,
680                offset + cur_offset,
681                depth,
682            )?;
683
684            _prev_end_offset = cur_offset + envelope_size;
685            if 5 > max_ordinal {
686                return Ok(());
687            }
688
689            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
690            // are envelope_size bytes.
691            let cur_offset: usize = (5 - 1) * envelope_size;
692
693            // Zero reserved fields.
694            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
695
696            // Safety:
697            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
698            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
699            //   envelope_size bytes, there is always sufficient room.
700            fidl::encoding::encode_in_envelope_optional::<u64, D>(
701                self.num_blocks.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
702                encoder,
703                offset + cur_offset,
704                depth,
705            )?;
706
707            _prev_end_offset = cur_offset + envelope_size;
708            if 6 > max_ordinal {
709                return Ok(());
710            }
711
712            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
713            // are envelope_size bytes.
714            let cur_offset: usize = (6 - 1) * envelope_size;
715
716            // Zero reserved fields.
717            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
718
719            // Safety:
720            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
721            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
722            //   envelope_size bytes, there is always sufficient room.
723            fidl::encoding::encode_in_envelope_optional::<u64, D>(
724                self.flags.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
725                encoder,
726                offset + cur_offset,
727                depth,
728            )?;
729
730            _prev_end_offset = cur_offset + envelope_size;
731
732            Ok(())
733        }
734    }
735
736    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
737        for PartitionGetMetadataResponse
738    {
739        #[inline(always)]
740        fn new_empty() -> Self {
741            Self::default()
742        }
743
744        unsafe fn decode(
745            &mut self,
746            decoder: &mut fidl::encoding::Decoder<'_, D>,
747            offset: usize,
748            mut depth: fidl::encoding::Depth,
749        ) -> fidl::Result<()> {
750            decoder.debug_check_bounds::<Self>(offset);
751            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
752                None => return Err(fidl::Error::NotNullable),
753                Some(len) => len,
754            };
755            // Calling decoder.out_of_line_offset(0) is not allowed.
756            if len == 0 {
757                return Ok(());
758            };
759            depth.increment()?;
760            let envelope_size = 8;
761            let bytes_len = len * envelope_size;
762            let offset = decoder.out_of_line_offset(bytes_len)?;
763            // Decode the envelope for each type.
764            let mut _next_ordinal_to_read = 0;
765            let mut next_offset = offset;
766            let end_offset = offset + bytes_len;
767            _next_ordinal_to_read += 1;
768            if next_offset >= end_offset {
769                return Ok(());
770            }
771
772            // Decode unknown envelopes for gaps in ordinals.
773            while _next_ordinal_to_read < 1 {
774                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
775                _next_ordinal_to_read += 1;
776                next_offset += envelope_size;
777            }
778
779            let next_out_of_line = decoder.next_out_of_line();
780            let handles_before = decoder.remaining_handles();
781            if let Some((inlined, num_bytes, num_handles)) =
782                fidl::encoding::decode_envelope_header(decoder, next_offset)?
783            {
784                let member_inline_size =
785                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
786                        decoder.context,
787                    );
788                if inlined != (member_inline_size <= 4) {
789                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
790                }
791                let inner_offset;
792                let mut inner_depth = depth.clone();
793                if inlined {
794                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
795                    inner_offset = next_offset;
796                } else {
797                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
798                    inner_depth.increment()?;
799                }
800                let val_ref = self
801                    .name
802                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
803                fidl::decode!(
804                    fidl::encoding::BoundedString<128>,
805                    D,
806                    val_ref,
807                    decoder,
808                    inner_offset,
809                    inner_depth
810                )?;
811                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
812                {
813                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
814                }
815                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
816                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
817                }
818            }
819
820            next_offset += envelope_size;
821            _next_ordinal_to_read += 1;
822            if next_offset >= end_offset {
823                return Ok(());
824            }
825
826            // Decode unknown envelopes for gaps in ordinals.
827            while _next_ordinal_to_read < 2 {
828                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
829                _next_ordinal_to_read += 1;
830                next_offset += envelope_size;
831            }
832
833            let next_out_of_line = decoder.next_out_of_line();
834            let handles_before = decoder.remaining_handles();
835            if let Some((inlined, num_bytes, num_handles)) =
836                fidl::encoding::decode_envelope_header(decoder, next_offset)?
837            {
838                let member_inline_size =
839                    <Guid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
840                if inlined != (member_inline_size <= 4) {
841                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
842                }
843                let inner_offset;
844                let mut inner_depth = depth.clone();
845                if inlined {
846                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
847                    inner_offset = next_offset;
848                } else {
849                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
850                    inner_depth.increment()?;
851                }
852                let val_ref = self.type_guid.get_or_insert_with(|| fidl::new_empty!(Guid, D));
853                fidl::decode!(Guid, D, val_ref, decoder, inner_offset, inner_depth)?;
854                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
855                {
856                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
857                }
858                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
859                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
860                }
861            }
862
863            next_offset += envelope_size;
864            _next_ordinal_to_read += 1;
865            if next_offset >= end_offset {
866                return Ok(());
867            }
868
869            // Decode unknown envelopes for gaps in ordinals.
870            while _next_ordinal_to_read < 3 {
871                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
872                _next_ordinal_to_read += 1;
873                next_offset += envelope_size;
874            }
875
876            let next_out_of_line = decoder.next_out_of_line();
877            let handles_before = decoder.remaining_handles();
878            if let Some((inlined, num_bytes, num_handles)) =
879                fidl::encoding::decode_envelope_header(decoder, next_offset)?
880            {
881                let member_inline_size =
882                    <Guid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
883                if inlined != (member_inline_size <= 4) {
884                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
885                }
886                let inner_offset;
887                let mut inner_depth = depth.clone();
888                if inlined {
889                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
890                    inner_offset = next_offset;
891                } else {
892                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
893                    inner_depth.increment()?;
894                }
895                let val_ref = self.instance_guid.get_or_insert_with(|| fidl::new_empty!(Guid, D));
896                fidl::decode!(Guid, 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            _next_ordinal_to_read += 1;
908            if next_offset >= end_offset {
909                return Ok(());
910            }
911
912            // Decode unknown envelopes for gaps in ordinals.
913            while _next_ordinal_to_read < 4 {
914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
915                _next_ordinal_to_read += 1;
916                next_offset += envelope_size;
917            }
918
919            let next_out_of_line = decoder.next_out_of_line();
920            let handles_before = decoder.remaining_handles();
921            if let Some((inlined, num_bytes, num_handles)) =
922                fidl::encoding::decode_envelope_header(decoder, next_offset)?
923            {
924                let member_inline_size =
925                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
926                if inlined != (member_inline_size <= 4) {
927                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
928                }
929                let inner_offset;
930                let mut inner_depth = depth.clone();
931                if inlined {
932                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
933                    inner_offset = next_offset;
934                } else {
935                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
936                    inner_depth.increment()?;
937                }
938                let val_ref =
939                    self.start_block_offset.get_or_insert_with(|| fidl::new_empty!(u64, D));
940                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
941                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
942                {
943                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
944                }
945                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
946                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
947                }
948            }
949
950            next_offset += envelope_size;
951            _next_ordinal_to_read += 1;
952            if next_offset >= end_offset {
953                return Ok(());
954            }
955
956            // Decode unknown envelopes for gaps in ordinals.
957            while _next_ordinal_to_read < 5 {
958                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
959                _next_ordinal_to_read += 1;
960                next_offset += envelope_size;
961            }
962
963            let next_out_of_line = decoder.next_out_of_line();
964            let handles_before = decoder.remaining_handles();
965            if let Some((inlined, num_bytes, num_handles)) =
966                fidl::encoding::decode_envelope_header(decoder, next_offset)?
967            {
968                let member_inline_size =
969                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
970                if inlined != (member_inline_size <= 4) {
971                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
972                }
973                let inner_offset;
974                let mut inner_depth = depth.clone();
975                if inlined {
976                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
977                    inner_offset = next_offset;
978                } else {
979                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
980                    inner_depth.increment()?;
981                }
982                let val_ref = self.num_blocks.get_or_insert_with(|| fidl::new_empty!(u64, D));
983                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
984                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
985                {
986                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
987                }
988                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
989                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
990                }
991            }
992
993            next_offset += envelope_size;
994            _next_ordinal_to_read += 1;
995            if next_offset >= end_offset {
996                return Ok(());
997            }
998
999            // Decode unknown envelopes for gaps in ordinals.
1000            while _next_ordinal_to_read < 6 {
1001                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1002                _next_ordinal_to_read += 1;
1003                next_offset += envelope_size;
1004            }
1005
1006            let next_out_of_line = decoder.next_out_of_line();
1007            let handles_before = decoder.remaining_handles();
1008            if let Some((inlined, num_bytes, num_handles)) =
1009                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1010            {
1011                let member_inline_size =
1012                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1013                if inlined != (member_inline_size <= 4) {
1014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1015                }
1016                let inner_offset;
1017                let mut inner_depth = depth.clone();
1018                if inlined {
1019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1020                    inner_offset = next_offset;
1021                } else {
1022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1023                    inner_depth.increment()?;
1024                }
1025                let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(u64, D));
1026                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1027                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1028                {
1029                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1030                }
1031                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1032                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1033                }
1034            }
1035
1036            next_offset += envelope_size;
1037
1038            // Decode the remaining unknown envelopes.
1039            while next_offset < end_offset {
1040                _next_ordinal_to_read += 1;
1041                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1042                next_offset += envelope_size;
1043            }
1044
1045            Ok(())
1046        }
1047    }
1048}
fidl_fuchsia_hardware_block_partition__common/fidl_fuchsia_hardware_block_partition__common.rs

fidl_fuchsia_hardware_block_partition__common/
fidl_fuchsia_hardware_block_partition__common.rs
