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