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

fidl_test_unknown_interactions__common/
fidl_test_unknown_interactions__common.rs
