fidl_fuchsia_hardware_block_encrypted__common/
fidl_fuchsia_hardware_block_encrypted__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
11/// We require simple layout to use the simple C bindings, and simple layout
12/// requires that we have non-maximal length bounds, so give some excessively
13/// large key length here so we can use the simple layout.
14pub const MAX_KEY_SIZE: u32 = 256;
15
16#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
17pub struct DeviceManagerFormatRequest {
18    pub key: Vec<u8>,
19    pub slot: u8,
20}
21
22impl fidl::Persistable for DeviceManagerFormatRequest {}
23
24#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25#[repr(C)]
26pub struct DeviceManagerFormatResponse {
27    pub status: i32,
28}
29
30impl fidl::Persistable for DeviceManagerFormatResponse {}
31
32#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
33#[repr(C)]
34pub struct DeviceManagerSealResponse {
35    pub status: i32,
36}
37
38impl fidl::Persistable for DeviceManagerSealResponse {}
39
40#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
41#[repr(C)]
42pub struct DeviceManagerShredResponse {
43    pub status: i32,
44}
45
46impl fidl::Persistable for DeviceManagerShredResponse {}
47
48#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
49pub struct DeviceManagerUnsealRequest {
50    pub key: Vec<u8>,
51    pub slot: u8,
52}
53
54impl fidl::Persistable for DeviceManagerUnsealRequest {}
55
56#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
57#[repr(C)]
58pub struct DeviceManagerUnsealResponse {
59    pub status: i32,
60}
61
62impl fidl::Persistable for DeviceManagerUnsealResponse {}
63
64pub mod device_manager_ordinals {
65    pub const FORMAT: u64 = 0x5d10415465425f82;
66    pub const UNSEAL: u64 = 0x170f834d39ed94fb;
67    pub const SEAL: u64 = 0xe63c7aa7840fbf4;
68    pub const SHRED: u64 = 0x1fbff042770086c;
69}
70
71mod internal {
72    use super::*;
73
74    impl fidl::encoding::ValueTypeMarker for DeviceManagerFormatRequest {
75        type Borrowed<'a> = &'a Self;
76        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
77            value
78        }
79    }
80
81    unsafe impl fidl::encoding::TypeMarker for DeviceManagerFormatRequest {
82        type Owned = Self;
83
84        #[inline(always)]
85        fn inline_align(_context: fidl::encoding::Context) -> usize {
86            8
87        }
88
89        #[inline(always)]
90        fn inline_size(_context: fidl::encoding::Context) -> usize {
91            24
92        }
93    }
94
95    unsafe impl<D: fidl::encoding::ResourceDialect>
96        fidl::encoding::Encode<DeviceManagerFormatRequest, D> for &DeviceManagerFormatRequest
97    {
98        #[inline]
99        unsafe fn encode(
100            self,
101            encoder: &mut fidl::encoding::Encoder<'_, D>,
102            offset: usize,
103            _depth: fidl::encoding::Depth,
104        ) -> fidl::Result<()> {
105            encoder.debug_check_bounds::<DeviceManagerFormatRequest>(offset);
106            // Delegate to tuple encoding.
107            fidl::encoding::Encode::<DeviceManagerFormatRequest, D>::encode(
108                (
109                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(
110                        &self.key,
111                    ),
112                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.slot),
113                ),
114                encoder,
115                offset,
116                _depth,
117            )
118        }
119    }
120    unsafe impl<
121            D: fidl::encoding::ResourceDialect,
122            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
123            T1: fidl::encoding::Encode<u8, D>,
124        > fidl::encoding::Encode<DeviceManagerFormatRequest, D> for (T0, T1)
125    {
126        #[inline]
127        unsafe fn encode(
128            self,
129            encoder: &mut fidl::encoding::Encoder<'_, D>,
130            offset: usize,
131            depth: fidl::encoding::Depth,
132        ) -> fidl::Result<()> {
133            encoder.debug_check_bounds::<DeviceManagerFormatRequest>(offset);
134            // Zero out padding regions. There's no need to apply masks
135            // because the unmasked parts will be overwritten by fields.
136            unsafe {
137                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
138                (ptr as *mut u64).write_unaligned(0);
139            }
140            // Write the fields.
141            self.0.encode(encoder, offset + 0, depth)?;
142            self.1.encode(encoder, offset + 16, depth)?;
143            Ok(())
144        }
145    }
146
147    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
148        for DeviceManagerFormatRequest
149    {
150        #[inline(always)]
151        fn new_empty() -> Self {
152            Self {
153                key: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
154                slot: fidl::new_empty!(u8, D),
155            }
156        }
157
158        #[inline]
159        unsafe fn decode(
160            &mut self,
161            decoder: &mut fidl::encoding::Decoder<'_, D>,
162            offset: usize,
163            _depth: fidl::encoding::Depth,
164        ) -> fidl::Result<()> {
165            decoder.debug_check_bounds::<Self>(offset);
166            // Verify that padding bytes are zero.
167            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
168            let padval = unsafe { (ptr as *const u64).read_unaligned() };
169            let mask = 0xffffffffffffff00u64;
170            let maskedval = padval & mask;
171            if maskedval != 0 {
172                return Err(fidl::Error::NonZeroPadding {
173                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
174                });
175            }
176            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.key, decoder, offset + 0, _depth)?;
177            fidl::decode!(u8, D, &mut self.slot, decoder, offset + 16, _depth)?;
178            Ok(())
179        }
180    }
181
182    impl fidl::encoding::ValueTypeMarker for DeviceManagerFormatResponse {
183        type Borrowed<'a> = &'a Self;
184        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
185            value
186        }
187    }
188
189    unsafe impl fidl::encoding::TypeMarker for DeviceManagerFormatResponse {
190        type Owned = Self;
191
192        #[inline(always)]
193        fn inline_align(_context: fidl::encoding::Context) -> usize {
194            4
195        }
196
197        #[inline(always)]
198        fn inline_size(_context: fidl::encoding::Context) -> usize {
199            4
200        }
201        #[inline(always)]
202        fn encode_is_copy() -> bool {
203            true
204        }
205
206        #[inline(always)]
207        fn decode_is_copy() -> bool {
208            true
209        }
210    }
211
212    unsafe impl<D: fidl::encoding::ResourceDialect>
213        fidl::encoding::Encode<DeviceManagerFormatResponse, D> for &DeviceManagerFormatResponse
214    {
215        #[inline]
216        unsafe fn encode(
217            self,
218            encoder: &mut fidl::encoding::Encoder<'_, D>,
219            offset: usize,
220            _depth: fidl::encoding::Depth,
221        ) -> fidl::Result<()> {
222            encoder.debug_check_bounds::<DeviceManagerFormatResponse>(offset);
223            unsafe {
224                // Copy the object into the buffer.
225                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
226                (buf_ptr as *mut DeviceManagerFormatResponse)
227                    .write_unaligned((self as *const DeviceManagerFormatResponse).read());
228                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
229                // done second because the memcpy will write garbage to these bytes.
230            }
231            Ok(())
232        }
233    }
234    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
235        fidl::encoding::Encode<DeviceManagerFormatResponse, D> for (T0,)
236    {
237        #[inline]
238        unsafe fn encode(
239            self,
240            encoder: &mut fidl::encoding::Encoder<'_, D>,
241            offset: usize,
242            depth: fidl::encoding::Depth,
243        ) -> fidl::Result<()> {
244            encoder.debug_check_bounds::<DeviceManagerFormatResponse>(offset);
245            // Zero out padding regions. There's no need to apply masks
246            // because the unmasked parts will be overwritten by fields.
247            // Write the fields.
248            self.0.encode(encoder, offset + 0, depth)?;
249            Ok(())
250        }
251    }
252
253    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
254        for DeviceManagerFormatResponse
255    {
256        #[inline(always)]
257        fn new_empty() -> Self {
258            Self { status: fidl::new_empty!(i32, D) }
259        }
260
261        #[inline]
262        unsafe fn decode(
263            &mut self,
264            decoder: &mut fidl::encoding::Decoder<'_, D>,
265            offset: usize,
266            _depth: fidl::encoding::Depth,
267        ) -> fidl::Result<()> {
268            decoder.debug_check_bounds::<Self>(offset);
269            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
270            // Verify that padding bytes are zero.
271            // Copy from the buffer into the object.
272            unsafe {
273                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
274            }
275            Ok(())
276        }
277    }
278
279    impl fidl::encoding::ValueTypeMarker for DeviceManagerSealResponse {
280        type Borrowed<'a> = &'a Self;
281        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
282            value
283        }
284    }
285
286    unsafe impl fidl::encoding::TypeMarker for DeviceManagerSealResponse {
287        type Owned = Self;
288
289        #[inline(always)]
290        fn inline_align(_context: fidl::encoding::Context) -> usize {
291            4
292        }
293
294        #[inline(always)]
295        fn inline_size(_context: fidl::encoding::Context) -> usize {
296            4
297        }
298        #[inline(always)]
299        fn encode_is_copy() -> bool {
300            true
301        }
302
303        #[inline(always)]
304        fn decode_is_copy() -> bool {
305            true
306        }
307    }
308
309    unsafe impl<D: fidl::encoding::ResourceDialect>
310        fidl::encoding::Encode<DeviceManagerSealResponse, D> for &DeviceManagerSealResponse
311    {
312        #[inline]
313        unsafe fn encode(
314            self,
315            encoder: &mut fidl::encoding::Encoder<'_, D>,
316            offset: usize,
317            _depth: fidl::encoding::Depth,
318        ) -> fidl::Result<()> {
319            encoder.debug_check_bounds::<DeviceManagerSealResponse>(offset);
320            unsafe {
321                // Copy the object into the buffer.
322                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
323                (buf_ptr as *mut DeviceManagerSealResponse)
324                    .write_unaligned((self as *const DeviceManagerSealResponse).read());
325                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
326                // done second because the memcpy will write garbage to these bytes.
327            }
328            Ok(())
329        }
330    }
331    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
332        fidl::encoding::Encode<DeviceManagerSealResponse, D> for (T0,)
333    {
334        #[inline]
335        unsafe fn encode(
336            self,
337            encoder: &mut fidl::encoding::Encoder<'_, D>,
338            offset: usize,
339            depth: fidl::encoding::Depth,
340        ) -> fidl::Result<()> {
341            encoder.debug_check_bounds::<DeviceManagerSealResponse>(offset);
342            // Zero out padding regions. There's no need to apply masks
343            // because the unmasked parts will be overwritten by fields.
344            // Write the fields.
345            self.0.encode(encoder, offset + 0, depth)?;
346            Ok(())
347        }
348    }
349
350    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
351        for DeviceManagerSealResponse
352    {
353        #[inline(always)]
354        fn new_empty() -> Self {
355            Self { status: fidl::new_empty!(i32, D) }
356        }
357
358        #[inline]
359        unsafe fn decode(
360            &mut self,
361            decoder: &mut fidl::encoding::Decoder<'_, D>,
362            offset: usize,
363            _depth: fidl::encoding::Depth,
364        ) -> fidl::Result<()> {
365            decoder.debug_check_bounds::<Self>(offset);
366            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
367            // Verify that padding bytes are zero.
368            // Copy from the buffer into the object.
369            unsafe {
370                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
371            }
372            Ok(())
373        }
374    }
375
376    impl fidl::encoding::ValueTypeMarker for DeviceManagerShredResponse {
377        type Borrowed<'a> = &'a Self;
378        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
379            value
380        }
381    }
382
383    unsafe impl fidl::encoding::TypeMarker for DeviceManagerShredResponse {
384        type Owned = Self;
385
386        #[inline(always)]
387        fn inline_align(_context: fidl::encoding::Context) -> usize {
388            4
389        }
390
391        #[inline(always)]
392        fn inline_size(_context: fidl::encoding::Context) -> usize {
393            4
394        }
395        #[inline(always)]
396        fn encode_is_copy() -> bool {
397            true
398        }
399
400        #[inline(always)]
401        fn decode_is_copy() -> bool {
402            true
403        }
404    }
405
406    unsafe impl<D: fidl::encoding::ResourceDialect>
407        fidl::encoding::Encode<DeviceManagerShredResponse, D> for &DeviceManagerShredResponse
408    {
409        #[inline]
410        unsafe fn encode(
411            self,
412            encoder: &mut fidl::encoding::Encoder<'_, D>,
413            offset: usize,
414            _depth: fidl::encoding::Depth,
415        ) -> fidl::Result<()> {
416            encoder.debug_check_bounds::<DeviceManagerShredResponse>(offset);
417            unsafe {
418                // Copy the object into the buffer.
419                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
420                (buf_ptr as *mut DeviceManagerShredResponse)
421                    .write_unaligned((self as *const DeviceManagerShredResponse).read());
422                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
423                // done second because the memcpy will write garbage to these bytes.
424            }
425            Ok(())
426        }
427    }
428    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
429        fidl::encoding::Encode<DeviceManagerShredResponse, D> for (T0,)
430    {
431        #[inline]
432        unsafe fn encode(
433            self,
434            encoder: &mut fidl::encoding::Encoder<'_, D>,
435            offset: usize,
436            depth: fidl::encoding::Depth,
437        ) -> fidl::Result<()> {
438            encoder.debug_check_bounds::<DeviceManagerShredResponse>(offset);
439            // Zero out padding regions. There's no need to apply masks
440            // because the unmasked parts will be overwritten by fields.
441            // Write the fields.
442            self.0.encode(encoder, offset + 0, depth)?;
443            Ok(())
444        }
445    }
446
447    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
448        for DeviceManagerShredResponse
449    {
450        #[inline(always)]
451        fn new_empty() -> Self {
452            Self { status: fidl::new_empty!(i32, D) }
453        }
454
455        #[inline]
456        unsafe fn decode(
457            &mut self,
458            decoder: &mut fidl::encoding::Decoder<'_, D>,
459            offset: usize,
460            _depth: fidl::encoding::Depth,
461        ) -> fidl::Result<()> {
462            decoder.debug_check_bounds::<Self>(offset);
463            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
464            // Verify that padding bytes are zero.
465            // Copy from the buffer into the object.
466            unsafe {
467                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
468            }
469            Ok(())
470        }
471    }
472
473    impl fidl::encoding::ValueTypeMarker for DeviceManagerUnsealRequest {
474        type Borrowed<'a> = &'a Self;
475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
476            value
477        }
478    }
479
480    unsafe impl fidl::encoding::TypeMarker for DeviceManagerUnsealRequest {
481        type Owned = Self;
482
483        #[inline(always)]
484        fn inline_align(_context: fidl::encoding::Context) -> usize {
485            8
486        }
487
488        #[inline(always)]
489        fn inline_size(_context: fidl::encoding::Context) -> usize {
490            24
491        }
492    }
493
494    unsafe impl<D: fidl::encoding::ResourceDialect>
495        fidl::encoding::Encode<DeviceManagerUnsealRequest, D> for &DeviceManagerUnsealRequest
496    {
497        #[inline]
498        unsafe fn encode(
499            self,
500            encoder: &mut fidl::encoding::Encoder<'_, D>,
501            offset: usize,
502            _depth: fidl::encoding::Depth,
503        ) -> fidl::Result<()> {
504            encoder.debug_check_bounds::<DeviceManagerUnsealRequest>(offset);
505            // Delegate to tuple encoding.
506            fidl::encoding::Encode::<DeviceManagerUnsealRequest, D>::encode(
507                (
508                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(
509                        &self.key,
510                    ),
511                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.slot),
512                ),
513                encoder,
514                offset,
515                _depth,
516            )
517        }
518    }
519    unsafe impl<
520            D: fidl::encoding::ResourceDialect,
521            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
522            T1: fidl::encoding::Encode<u8, D>,
523        > fidl::encoding::Encode<DeviceManagerUnsealRequest, D> for (T0, T1)
524    {
525        #[inline]
526        unsafe fn encode(
527            self,
528            encoder: &mut fidl::encoding::Encoder<'_, D>,
529            offset: usize,
530            depth: fidl::encoding::Depth,
531        ) -> fidl::Result<()> {
532            encoder.debug_check_bounds::<DeviceManagerUnsealRequest>(offset);
533            // Zero out padding regions. There's no need to apply masks
534            // because the unmasked parts will be overwritten by fields.
535            unsafe {
536                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
537                (ptr as *mut u64).write_unaligned(0);
538            }
539            // Write the fields.
540            self.0.encode(encoder, offset + 0, depth)?;
541            self.1.encode(encoder, offset + 16, depth)?;
542            Ok(())
543        }
544    }
545
546    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
547        for DeviceManagerUnsealRequest
548    {
549        #[inline(always)]
550        fn new_empty() -> Self {
551            Self {
552                key: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
553                slot: fidl::new_empty!(u8, D),
554            }
555        }
556
557        #[inline]
558        unsafe fn decode(
559            &mut self,
560            decoder: &mut fidl::encoding::Decoder<'_, D>,
561            offset: usize,
562            _depth: fidl::encoding::Depth,
563        ) -> fidl::Result<()> {
564            decoder.debug_check_bounds::<Self>(offset);
565            // Verify that padding bytes are zero.
566            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
567            let padval = unsafe { (ptr as *const u64).read_unaligned() };
568            let mask = 0xffffffffffffff00u64;
569            let maskedval = padval & mask;
570            if maskedval != 0 {
571                return Err(fidl::Error::NonZeroPadding {
572                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
573                });
574            }
575            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.key, decoder, offset + 0, _depth)?;
576            fidl::decode!(u8, D, &mut self.slot, decoder, offset + 16, _depth)?;
577            Ok(())
578        }
579    }
580
581    impl fidl::encoding::ValueTypeMarker for DeviceManagerUnsealResponse {
582        type Borrowed<'a> = &'a Self;
583        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
584            value
585        }
586    }
587
588    unsafe impl fidl::encoding::TypeMarker for DeviceManagerUnsealResponse {
589        type Owned = Self;
590
591        #[inline(always)]
592        fn inline_align(_context: fidl::encoding::Context) -> usize {
593            4
594        }
595
596        #[inline(always)]
597        fn inline_size(_context: fidl::encoding::Context) -> usize {
598            4
599        }
600        #[inline(always)]
601        fn encode_is_copy() -> bool {
602            true
603        }
604
605        #[inline(always)]
606        fn decode_is_copy() -> bool {
607            true
608        }
609    }
610
611    unsafe impl<D: fidl::encoding::ResourceDialect>
612        fidl::encoding::Encode<DeviceManagerUnsealResponse, D> for &DeviceManagerUnsealResponse
613    {
614        #[inline]
615        unsafe fn encode(
616            self,
617            encoder: &mut fidl::encoding::Encoder<'_, D>,
618            offset: usize,
619            _depth: fidl::encoding::Depth,
620        ) -> fidl::Result<()> {
621            encoder.debug_check_bounds::<DeviceManagerUnsealResponse>(offset);
622            unsafe {
623                // Copy the object into the buffer.
624                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
625                (buf_ptr as *mut DeviceManagerUnsealResponse)
626                    .write_unaligned((self as *const DeviceManagerUnsealResponse).read());
627                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
628                // done second because the memcpy will write garbage to these bytes.
629            }
630            Ok(())
631        }
632    }
633    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
634        fidl::encoding::Encode<DeviceManagerUnsealResponse, D> for (T0,)
635    {
636        #[inline]
637        unsafe fn encode(
638            self,
639            encoder: &mut fidl::encoding::Encoder<'_, D>,
640            offset: usize,
641            depth: fidl::encoding::Depth,
642        ) -> fidl::Result<()> {
643            encoder.debug_check_bounds::<DeviceManagerUnsealResponse>(offset);
644            // Zero out padding regions. There's no need to apply masks
645            // because the unmasked parts will be overwritten by fields.
646            // Write the fields.
647            self.0.encode(encoder, offset + 0, depth)?;
648            Ok(())
649        }
650    }
651
652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
653        for DeviceManagerUnsealResponse
654    {
655        #[inline(always)]
656        fn new_empty() -> Self {
657            Self { status: fidl::new_empty!(i32, D) }
658        }
659
660        #[inline]
661        unsafe fn decode(
662            &mut self,
663            decoder: &mut fidl::encoding::Decoder<'_, D>,
664            offset: usize,
665            _depth: fidl::encoding::Depth,
666        ) -> fidl::Result<()> {
667            decoder.debug_check_bounds::<Self>(offset);
668            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
669            // Verify that padding bytes are zero.
670            // Copy from the buffer into the object.
671            unsafe {
672                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
673            }
674            Ok(())
675        }
676    }
677}
fidl_fuchsia_hardware_block_encrypted__common/fidl_fuchsia_hardware_block_encrypted__common.rs

fidl_fuchsia_hardware_block_encrypted__common/
fidl_fuchsia_hardware_block_encrypted__common.rs
