fidl_fidl_test_imported_common/
fidl_fidl_test_imported_common.rs

Help
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(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12#[repr(u32)]
13pub enum WantResponse {
14    Success = 1,
15    Err = 2,
16}
17
18impl WantResponse {
19    #[inline]
20    pub fn from_primitive(prim: u32) -> Option<Self> {
21        match prim {
22            1 => Some(Self::Success),
23            2 => Some(Self::Err),
24            _ => None,
25        }
26    }
27
28    #[inline]
29    pub const fn into_primitive(self) -> u32 {
30        self as u32
31    }
32
33    #[deprecated = "Strict enums should not use `is_unknown`"]
34    #[inline]
35    pub fn is_unknown(&self) -> bool {
36        false
37    }
38}
39
40#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
41pub struct ComposedEchoUnionResponseWithErrorComposedRequest {
42    pub value: i64,
43    pub want_absolute_value: bool,
44    pub forward_to_server: String,
45    pub result_err: u32,
46    pub result_variant: WantResponse,
47}
48
49impl fidl::Persistable for ComposedEchoUnionResponseWithErrorComposedRequest {}
50
51#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
52pub struct ErrorableRequestStruct {
53    pub value: SimpleStruct,
54    pub result_err: u32,
55    pub forward_to_server: String,
56    pub result_variant: WantResponse,
57}
58
59impl fidl::Persistable for ErrorableRequestStruct {}
60
61#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
62pub struct EventTriggeringRequestStruct {
63    pub value: SimpleStruct,
64    pub forward_to_server: String,
65}
66
67impl fidl::Persistable for EventTriggeringRequestStruct {}
68
69#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70pub struct RequestStruct {
71    pub value: SimpleStruct,
72    pub forward_to_server: String,
73}
74
75impl fidl::Persistable for RequestStruct {}
76
77#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
78pub struct ResponseStruct {
79    pub value: SimpleStruct,
80}
81
82impl fidl::Persistable for ResponseStruct {}
83
84#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
85pub struct SimpleStruct {
86    pub f1: bool,
87    pub f2: u64,
88}
89
90impl fidl::Persistable for SimpleStruct {}
91
92#[derive(Clone, Debug, Default, PartialEq)]
93pub struct ComposedEchoTableRequestComposedRequest {
94    pub value: Option<u64>,
95    pub forward_to_server: Option<String>,
96    #[doc(hidden)]
97    pub __source_breaking: fidl::marker::SourceBreaking,
98}
99
100impl fidl::Persistable for ComposedEchoTableRequestComposedRequest {}
101
102#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
103pub enum ComposedEchoUnionResponseWithErrorComposedResponse {
104    Unsigned(u64),
105    Signed(i64),
106}
107
108impl ComposedEchoUnionResponseWithErrorComposedResponse {
109    #[inline]
110    pub fn ordinal(&self) -> u64 {
111        match *self {
112            Self::Unsigned(_) => 1,
113            Self::Signed(_) => 2,
114        }
115    }
116
117    #[deprecated = "Strict unions should not use `is_unknown`"]
118    #[inline]
119    pub fn is_unknown(&self) -> bool {
120        false
121    }
122}
123
124impl fidl::Persistable for ComposedEchoUnionResponseWithErrorComposedResponse {}
125
126mod internal {
127    use super::*;
128    unsafe impl fidl::encoding::TypeMarker for WantResponse {
129        type Owned = Self;
130
131        #[inline(always)]
132        fn inline_align(_context: fidl::encoding::Context) -> usize {
133            std::mem::align_of::<u32>()
134        }
135
136        #[inline(always)]
137        fn inline_size(_context: fidl::encoding::Context) -> usize {
138            std::mem::size_of::<u32>()
139        }
140
141        #[inline(always)]
142        fn encode_is_copy() -> bool {
143            true
144        }
145
146        #[inline(always)]
147        fn decode_is_copy() -> bool {
148            false
149        }
150    }
151
152    impl fidl::encoding::ValueTypeMarker for WantResponse {
153        type Borrowed<'a> = Self;
154        #[inline(always)]
155        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
156            *value
157        }
158    }
159
160    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WantResponse {
161        #[inline]
162        unsafe fn encode(
163            self,
164            encoder: &mut fidl::encoding::Encoder<'_, D>,
165            offset: usize,
166            _depth: fidl::encoding::Depth,
167        ) -> fidl::Result<()> {
168            encoder.debug_check_bounds::<Self>(offset);
169            encoder.write_num(self.into_primitive(), offset);
170            Ok(())
171        }
172    }
173
174    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WantResponse {
175        #[inline(always)]
176        fn new_empty() -> Self {
177            Self::Success
178        }
179
180        #[inline]
181        unsafe fn decode(
182            &mut self,
183            decoder: &mut fidl::encoding::Decoder<'_, D>,
184            offset: usize,
185            _depth: fidl::encoding::Depth,
186        ) -> fidl::Result<()> {
187            decoder.debug_check_bounds::<Self>(offset);
188            let prim = decoder.read_num::<u32>(offset);
189
190            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
191            Ok(())
192        }
193    }
194
195    impl fidl::encoding::ValueTypeMarker for ComposedEchoUnionResponseWithErrorComposedRequest {
196        type Borrowed<'a> = &'a Self;
197        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
198            value
199        }
200    }
201
202    unsafe impl fidl::encoding::TypeMarker for ComposedEchoUnionResponseWithErrorComposedRequest {
203        type Owned = Self;
204
205        #[inline(always)]
206        fn inline_align(_context: fidl::encoding::Context) -> usize {
207            8
208        }
209
210        #[inline(always)]
211        fn inline_size(_context: fidl::encoding::Context) -> usize {
212            40
213        }
214    }
215
216    unsafe impl<D: fidl::encoding::ResourceDialect>
217        fidl::encoding::Encode<ComposedEchoUnionResponseWithErrorComposedRequest, D>
218        for &ComposedEchoUnionResponseWithErrorComposedRequest
219    {
220        #[inline]
221        unsafe fn encode(
222            self,
223            encoder: &mut fidl::encoding::Encoder<'_, D>,
224            offset: usize,
225            _depth: fidl::encoding::Depth,
226        ) -> fidl::Result<()> {
227            encoder.debug_check_bounds::<ComposedEchoUnionResponseWithErrorComposedRequest>(offset);
228            // Delegate to tuple encoding.
229            fidl::encoding::Encode::<ComposedEchoUnionResponseWithErrorComposedRequest, D>::encode(
230                (
231                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
232                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.want_absolute_value),
233                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
234                        &self.forward_to_server,
235                    ),
236                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
237                    <WantResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
238                ),
239                encoder,
240                offset,
241                _depth,
242            )
243        }
244    }
245    unsafe impl<
246            D: fidl::encoding::ResourceDialect,
247            T0: fidl::encoding::Encode<i64, D>,
248            T1: fidl::encoding::Encode<bool, D>,
249            T2: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
250            T3: fidl::encoding::Encode<u32, D>,
251            T4: fidl::encoding::Encode<WantResponse, D>,
252        > fidl::encoding::Encode<ComposedEchoUnionResponseWithErrorComposedRequest, D>
253        for (T0, T1, T2, T3, T4)
254    {
255        #[inline]
256        unsafe fn encode(
257            self,
258            encoder: &mut fidl::encoding::Encoder<'_, D>,
259            offset: usize,
260            depth: fidl::encoding::Depth,
261        ) -> fidl::Result<()> {
262            encoder.debug_check_bounds::<ComposedEchoUnionResponseWithErrorComposedRequest>(offset);
263            // Zero out padding regions. There's no need to apply masks
264            // because the unmasked parts will be overwritten by fields.
265            unsafe {
266                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
267                (ptr as *mut u64).write_unaligned(0);
268            }
269            // Write the fields.
270            self.0.encode(encoder, offset + 0, depth)?;
271            self.1.encode(encoder, offset + 8, depth)?;
272            self.2.encode(encoder, offset + 16, depth)?;
273            self.3.encode(encoder, offset + 32, depth)?;
274            self.4.encode(encoder, offset + 36, depth)?;
275            Ok(())
276        }
277    }
278
279    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
280        for ComposedEchoUnionResponseWithErrorComposedRequest
281    {
282        #[inline(always)]
283        fn new_empty() -> Self {
284            Self {
285                value: fidl::new_empty!(i64, D),
286                want_absolute_value: fidl::new_empty!(bool, D),
287                forward_to_server: fidl::new_empty!(fidl::encoding::UnboundedString, D),
288                result_err: fidl::new_empty!(u32, D),
289                result_variant: fidl::new_empty!(WantResponse, D),
290            }
291        }
292
293        #[inline]
294        unsafe fn decode(
295            &mut self,
296            decoder: &mut fidl::encoding::Decoder<'_, D>,
297            offset: usize,
298            _depth: fidl::encoding::Depth,
299        ) -> fidl::Result<()> {
300            decoder.debug_check_bounds::<Self>(offset);
301            // Verify that padding bytes are zero.
302            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
303            let padval = unsafe { (ptr as *const u64).read_unaligned() };
304            let mask = 0xffffffffffffff00u64;
305            let maskedval = padval & mask;
306            if maskedval != 0 {
307                return Err(fidl::Error::NonZeroPadding {
308                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
309                });
310            }
311            fidl::decode!(i64, D, &mut self.value, decoder, offset + 0, _depth)?;
312            fidl::decode!(bool, D, &mut self.want_absolute_value, decoder, offset + 8, _depth)?;
313            fidl::decode!(
314                fidl::encoding::UnboundedString,
315                D,
316                &mut self.forward_to_server,
317                decoder,
318                offset + 16,
319                _depth
320            )?;
321            fidl::decode!(u32, D, &mut self.result_err, decoder, offset + 32, _depth)?;
322            fidl::decode!(WantResponse, D, &mut self.result_variant, decoder, offset + 36, _depth)?;
323            Ok(())
324        }
325    }
326
327    impl fidl::encoding::ValueTypeMarker for ErrorableRequestStruct {
328        type Borrowed<'a> = &'a Self;
329        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
330            value
331        }
332    }
333
334    unsafe impl fidl::encoding::TypeMarker for ErrorableRequestStruct {
335        type Owned = Self;
336
337        #[inline(always)]
338        fn inline_align(_context: fidl::encoding::Context) -> usize {
339            8
340        }
341
342        #[inline(always)]
343        fn inline_size(_context: fidl::encoding::Context) -> usize {
344            48
345        }
346    }
347
348    unsafe impl<D: fidl::encoding::ResourceDialect>
349        fidl::encoding::Encode<ErrorableRequestStruct, D> for &ErrorableRequestStruct
350    {
351        #[inline]
352        unsafe fn encode(
353            self,
354            encoder: &mut fidl::encoding::Encoder<'_, D>,
355            offset: usize,
356            _depth: fidl::encoding::Depth,
357        ) -> fidl::Result<()> {
358            encoder.debug_check_bounds::<ErrorableRequestStruct>(offset);
359            // Delegate to tuple encoding.
360            fidl::encoding::Encode::<ErrorableRequestStruct, D>::encode(
361                (
362                    <SimpleStruct as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
363                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
364                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
365                        &self.forward_to_server,
366                    ),
367                    <WantResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
368                ),
369                encoder,
370                offset,
371                _depth,
372            )
373        }
374    }
375    unsafe impl<
376            D: fidl::encoding::ResourceDialect,
377            T0: fidl::encoding::Encode<SimpleStruct, D>,
378            T1: fidl::encoding::Encode<u32, D>,
379            T2: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
380            T3: fidl::encoding::Encode<WantResponse, D>,
381        > fidl::encoding::Encode<ErrorableRequestStruct, D> for (T0, T1, T2, T3)
382    {
383        #[inline]
384        unsafe fn encode(
385            self,
386            encoder: &mut fidl::encoding::Encoder<'_, D>,
387            offset: usize,
388            depth: fidl::encoding::Depth,
389        ) -> fidl::Result<()> {
390            encoder.debug_check_bounds::<ErrorableRequestStruct>(offset);
391            // Zero out padding regions. There's no need to apply masks
392            // because the unmasked parts will be overwritten by fields.
393            unsafe {
394                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
395                (ptr as *mut u64).write_unaligned(0);
396            }
397            unsafe {
398                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
399                (ptr as *mut u64).write_unaligned(0);
400            }
401            // Write the fields.
402            self.0.encode(encoder, offset + 0, depth)?;
403            self.1.encode(encoder, offset + 16, depth)?;
404            self.2.encode(encoder, offset + 24, depth)?;
405            self.3.encode(encoder, offset + 40, depth)?;
406            Ok(())
407        }
408    }
409
410    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
411        for ErrorableRequestStruct
412    {
413        #[inline(always)]
414        fn new_empty() -> Self {
415            Self {
416                value: fidl::new_empty!(SimpleStruct, D),
417                result_err: fidl::new_empty!(u32, D),
418                forward_to_server: fidl::new_empty!(fidl::encoding::UnboundedString, D),
419                result_variant: fidl::new_empty!(WantResponse, D),
420            }
421        }
422
423        #[inline]
424        unsafe fn decode(
425            &mut self,
426            decoder: &mut fidl::encoding::Decoder<'_, D>,
427            offset: usize,
428            _depth: fidl::encoding::Depth,
429        ) -> fidl::Result<()> {
430            decoder.debug_check_bounds::<Self>(offset);
431            // Verify that padding bytes are zero.
432            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
433            let padval = unsafe { (ptr as *const u64).read_unaligned() };
434            let mask = 0xffffffff00000000u64;
435            let maskedval = padval & mask;
436            if maskedval != 0 {
437                return Err(fidl::Error::NonZeroPadding {
438                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
439                });
440            }
441            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
442            let padval = unsafe { (ptr as *const u64).read_unaligned() };
443            let mask = 0xffffffff00000000u64;
444            let maskedval = padval & mask;
445            if maskedval != 0 {
446                return Err(fidl::Error::NonZeroPadding {
447                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
448                });
449            }
450            fidl::decode!(SimpleStruct, D, &mut self.value, decoder, offset + 0, _depth)?;
451            fidl::decode!(u32, D, &mut self.result_err, decoder, offset + 16, _depth)?;
452            fidl::decode!(
453                fidl::encoding::UnboundedString,
454                D,
455                &mut self.forward_to_server,
456                decoder,
457                offset + 24,
458                _depth
459            )?;
460            fidl::decode!(WantResponse, D, &mut self.result_variant, decoder, offset + 40, _depth)?;
461            Ok(())
462        }
463    }
464
465    impl fidl::encoding::ValueTypeMarker for EventTriggeringRequestStruct {
466        type Borrowed<'a> = &'a Self;
467        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
468            value
469        }
470    }
471
472    unsafe impl fidl::encoding::TypeMarker for EventTriggeringRequestStruct {
473        type Owned = Self;
474
475        #[inline(always)]
476        fn inline_align(_context: fidl::encoding::Context) -> usize {
477            8
478        }
479
480        #[inline(always)]
481        fn inline_size(_context: fidl::encoding::Context) -> usize {
482            32
483        }
484    }
485
486    unsafe impl<D: fidl::encoding::ResourceDialect>
487        fidl::encoding::Encode<EventTriggeringRequestStruct, D> for &EventTriggeringRequestStruct
488    {
489        #[inline]
490        unsafe fn encode(
491            self,
492            encoder: &mut fidl::encoding::Encoder<'_, D>,
493            offset: usize,
494            _depth: fidl::encoding::Depth,
495        ) -> fidl::Result<()> {
496            encoder.debug_check_bounds::<EventTriggeringRequestStruct>(offset);
497            // Delegate to tuple encoding.
498            fidl::encoding::Encode::<EventTriggeringRequestStruct, D>::encode(
499                (
500                    <SimpleStruct as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
501                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
502                        &self.forward_to_server,
503                    ),
504                ),
505                encoder,
506                offset,
507                _depth,
508            )
509        }
510    }
511    unsafe impl<
512            D: fidl::encoding::ResourceDialect,
513            T0: fidl::encoding::Encode<SimpleStruct, D>,
514            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
515        > fidl::encoding::Encode<EventTriggeringRequestStruct, D> for (T0, T1)
516    {
517        #[inline]
518        unsafe fn encode(
519            self,
520            encoder: &mut fidl::encoding::Encoder<'_, D>,
521            offset: usize,
522            depth: fidl::encoding::Depth,
523        ) -> fidl::Result<()> {
524            encoder.debug_check_bounds::<EventTriggeringRequestStruct>(offset);
525            // Zero out padding regions. There's no need to apply masks
526            // because the unmasked parts will be overwritten by fields.
527            // Write the fields.
528            self.0.encode(encoder, offset + 0, depth)?;
529            self.1.encode(encoder, offset + 16, depth)?;
530            Ok(())
531        }
532    }
533
534    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
535        for EventTriggeringRequestStruct
536    {
537        #[inline(always)]
538        fn new_empty() -> Self {
539            Self {
540                value: fidl::new_empty!(SimpleStruct, D),
541                forward_to_server: fidl::new_empty!(fidl::encoding::UnboundedString, D),
542            }
543        }
544
545        #[inline]
546        unsafe fn decode(
547            &mut self,
548            decoder: &mut fidl::encoding::Decoder<'_, D>,
549            offset: usize,
550            _depth: fidl::encoding::Depth,
551        ) -> fidl::Result<()> {
552            decoder.debug_check_bounds::<Self>(offset);
553            // Verify that padding bytes are zero.
554            fidl::decode!(SimpleStruct, D, &mut self.value, decoder, offset + 0, _depth)?;
555            fidl::decode!(
556                fidl::encoding::UnboundedString,
557                D,
558                &mut self.forward_to_server,
559                decoder,
560                offset + 16,
561                _depth
562            )?;
563            Ok(())
564        }
565    }
566
567    impl fidl::encoding::ValueTypeMarker for RequestStruct {
568        type Borrowed<'a> = &'a Self;
569        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
570            value
571        }
572    }
573
574    unsafe impl fidl::encoding::TypeMarker for RequestStruct {
575        type Owned = Self;
576
577        #[inline(always)]
578        fn inline_align(_context: fidl::encoding::Context) -> usize {
579            8
580        }
581
582        #[inline(always)]
583        fn inline_size(_context: fidl::encoding::Context) -> usize {
584            32
585        }
586    }
587
588    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RequestStruct, D>
589        for &RequestStruct
590    {
591        #[inline]
592        unsafe fn encode(
593            self,
594            encoder: &mut fidl::encoding::Encoder<'_, D>,
595            offset: usize,
596            _depth: fidl::encoding::Depth,
597        ) -> fidl::Result<()> {
598            encoder.debug_check_bounds::<RequestStruct>(offset);
599            // Delegate to tuple encoding.
600            fidl::encoding::Encode::<RequestStruct, D>::encode(
601                (
602                    <SimpleStruct as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
603                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
604                        &self.forward_to_server,
605                    ),
606                ),
607                encoder,
608                offset,
609                _depth,
610            )
611        }
612    }
613    unsafe impl<
614            D: fidl::encoding::ResourceDialect,
615            T0: fidl::encoding::Encode<SimpleStruct, D>,
616            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
617        > fidl::encoding::Encode<RequestStruct, D> for (T0, T1)
618    {
619        #[inline]
620        unsafe fn encode(
621            self,
622            encoder: &mut fidl::encoding::Encoder<'_, D>,
623            offset: usize,
624            depth: fidl::encoding::Depth,
625        ) -> fidl::Result<()> {
626            encoder.debug_check_bounds::<RequestStruct>(offset);
627            // Zero out padding regions. There's no need to apply masks
628            // because the unmasked parts will be overwritten by fields.
629            // Write the fields.
630            self.0.encode(encoder, offset + 0, depth)?;
631            self.1.encode(encoder, offset + 16, depth)?;
632            Ok(())
633        }
634    }
635
636    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RequestStruct {
637        #[inline(always)]
638        fn new_empty() -> Self {
639            Self {
640                value: fidl::new_empty!(SimpleStruct, D),
641                forward_to_server: fidl::new_empty!(fidl::encoding::UnboundedString, D),
642            }
643        }
644
645        #[inline]
646        unsafe fn decode(
647            &mut self,
648            decoder: &mut fidl::encoding::Decoder<'_, D>,
649            offset: usize,
650            _depth: fidl::encoding::Depth,
651        ) -> fidl::Result<()> {
652            decoder.debug_check_bounds::<Self>(offset);
653            // Verify that padding bytes are zero.
654            fidl::decode!(SimpleStruct, D, &mut self.value, decoder, offset + 0, _depth)?;
655            fidl::decode!(
656                fidl::encoding::UnboundedString,
657                D,
658                &mut self.forward_to_server,
659                decoder,
660                offset + 16,
661                _depth
662            )?;
663            Ok(())
664        }
665    }
666
667    impl fidl::encoding::ValueTypeMarker for ResponseStruct {
668        type Borrowed<'a> = &'a Self;
669        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
670            value
671        }
672    }
673
674    unsafe impl fidl::encoding::TypeMarker for ResponseStruct {
675        type Owned = Self;
676
677        #[inline(always)]
678        fn inline_align(_context: fidl::encoding::Context) -> usize {
679            8
680        }
681
682        #[inline(always)]
683        fn inline_size(_context: fidl::encoding::Context) -> usize {
684            16
685        }
686    }
687
688    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResponseStruct, D>
689        for &ResponseStruct
690    {
691        #[inline]
692        unsafe fn encode(
693            self,
694            encoder: &mut fidl::encoding::Encoder<'_, D>,
695            offset: usize,
696            _depth: fidl::encoding::Depth,
697        ) -> fidl::Result<()> {
698            encoder.debug_check_bounds::<ResponseStruct>(offset);
699            // Delegate to tuple encoding.
700            fidl::encoding::Encode::<ResponseStruct, D>::encode(
701                (<SimpleStruct as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
702                encoder,
703                offset,
704                _depth,
705            )
706        }
707    }
708    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SimpleStruct, D>>
709        fidl::encoding::Encode<ResponseStruct, D> for (T0,)
710    {
711        #[inline]
712        unsafe fn encode(
713            self,
714            encoder: &mut fidl::encoding::Encoder<'_, D>,
715            offset: usize,
716            depth: fidl::encoding::Depth,
717        ) -> fidl::Result<()> {
718            encoder.debug_check_bounds::<ResponseStruct>(offset);
719            // Zero out padding regions. There's no need to apply masks
720            // because the unmasked parts will be overwritten by fields.
721            // Write the fields.
722            self.0.encode(encoder, offset + 0, depth)?;
723            Ok(())
724        }
725    }
726
727    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResponseStruct {
728        #[inline(always)]
729        fn new_empty() -> Self {
730            Self { value: fidl::new_empty!(SimpleStruct, D) }
731        }
732
733        #[inline]
734        unsafe fn decode(
735            &mut self,
736            decoder: &mut fidl::encoding::Decoder<'_, D>,
737            offset: usize,
738            _depth: fidl::encoding::Depth,
739        ) -> fidl::Result<()> {
740            decoder.debug_check_bounds::<Self>(offset);
741            // Verify that padding bytes are zero.
742            fidl::decode!(SimpleStruct, D, &mut self.value, decoder, offset + 0, _depth)?;
743            Ok(())
744        }
745    }
746
747    impl fidl::encoding::ValueTypeMarker for SimpleStruct {
748        type Borrowed<'a> = &'a Self;
749        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
750            value
751        }
752    }
753
754    unsafe impl fidl::encoding::TypeMarker for SimpleStruct {
755        type Owned = Self;
756
757        #[inline(always)]
758        fn inline_align(_context: fidl::encoding::Context) -> usize {
759            8
760        }
761
762        #[inline(always)]
763        fn inline_size(_context: fidl::encoding::Context) -> usize {
764            16
765        }
766    }
767
768    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SimpleStruct, D>
769        for &SimpleStruct
770    {
771        #[inline]
772        unsafe fn encode(
773            self,
774            encoder: &mut fidl::encoding::Encoder<'_, D>,
775            offset: usize,
776            _depth: fidl::encoding::Depth,
777        ) -> fidl::Result<()> {
778            encoder.debug_check_bounds::<SimpleStruct>(offset);
779            // Delegate to tuple encoding.
780            fidl::encoding::Encode::<SimpleStruct, D>::encode(
781                (
782                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.f1),
783                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.f2),
784                ),
785                encoder,
786                offset,
787                _depth,
788            )
789        }
790    }
791    unsafe impl<
792            D: fidl::encoding::ResourceDialect,
793            T0: fidl::encoding::Encode<bool, D>,
794            T1: fidl::encoding::Encode<u64, D>,
795        > fidl::encoding::Encode<SimpleStruct, D> for (T0, T1)
796    {
797        #[inline]
798        unsafe fn encode(
799            self,
800            encoder: &mut fidl::encoding::Encoder<'_, D>,
801            offset: usize,
802            depth: fidl::encoding::Depth,
803        ) -> fidl::Result<()> {
804            encoder.debug_check_bounds::<SimpleStruct>(offset);
805            // Zero out padding regions. There's no need to apply masks
806            // because the unmasked parts will be overwritten by fields.
807            unsafe {
808                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
809                (ptr as *mut u64).write_unaligned(0);
810            }
811            // Write the fields.
812            self.0.encode(encoder, offset + 0, depth)?;
813            self.1.encode(encoder, offset + 8, depth)?;
814            Ok(())
815        }
816    }
817
818    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SimpleStruct {
819        #[inline(always)]
820        fn new_empty() -> Self {
821            Self { f1: fidl::new_empty!(bool, D), f2: fidl::new_empty!(u64, D) }
822        }
823
824        #[inline]
825        unsafe fn decode(
826            &mut self,
827            decoder: &mut fidl::encoding::Decoder<'_, D>,
828            offset: usize,
829            _depth: fidl::encoding::Depth,
830        ) -> fidl::Result<()> {
831            decoder.debug_check_bounds::<Self>(offset);
832            // Verify that padding bytes are zero.
833            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
834            let padval = unsafe { (ptr as *const u64).read_unaligned() };
835            let mask = 0xffffffffffffff00u64;
836            let maskedval = padval & mask;
837            if maskedval != 0 {
838                return Err(fidl::Error::NonZeroPadding {
839                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
840                });
841            }
842            fidl::decode!(bool, D, &mut self.f1, decoder, offset + 0, _depth)?;
843            fidl::decode!(u64, D, &mut self.f2, decoder, offset + 8, _depth)?;
844            Ok(())
845        }
846    }
847
848    impl ComposedEchoTableRequestComposedRequest {
849        #[inline(always)]
850        fn max_ordinal_present(&self) -> u64 {
851            if let Some(_) = self.forward_to_server {
852                return 2;
853            }
854            if let Some(_) = self.value {
855                return 1;
856            }
857            0
858        }
859    }
860
861    impl fidl::encoding::ValueTypeMarker for ComposedEchoTableRequestComposedRequest {
862        type Borrowed<'a> = &'a Self;
863        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
864            value
865        }
866    }
867
868    unsafe impl fidl::encoding::TypeMarker for ComposedEchoTableRequestComposedRequest {
869        type Owned = Self;
870
871        #[inline(always)]
872        fn inline_align(_context: fidl::encoding::Context) -> usize {
873            8
874        }
875
876        #[inline(always)]
877        fn inline_size(_context: fidl::encoding::Context) -> usize {
878            16
879        }
880    }
881
882    unsafe impl<D: fidl::encoding::ResourceDialect>
883        fidl::encoding::Encode<ComposedEchoTableRequestComposedRequest, D>
884        for &ComposedEchoTableRequestComposedRequest
885    {
886        unsafe fn encode(
887            self,
888            encoder: &mut fidl::encoding::Encoder<'_, D>,
889            offset: usize,
890            mut depth: fidl::encoding::Depth,
891        ) -> fidl::Result<()> {
892            encoder.debug_check_bounds::<ComposedEchoTableRequestComposedRequest>(offset);
893            // Vector header
894            let max_ordinal: u64 = self.max_ordinal_present();
895            encoder.write_num(max_ordinal, offset);
896            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
897            // Calling encoder.out_of_line_offset(0) is not allowed.
898            if max_ordinal == 0 {
899                return Ok(());
900            }
901            depth.increment()?;
902            let envelope_size = 8;
903            let bytes_len = max_ordinal as usize * envelope_size;
904            #[allow(unused_variables)]
905            let offset = encoder.out_of_line_offset(bytes_len);
906            let mut _prev_end_offset: usize = 0;
907            if 1 > max_ordinal {
908                return Ok(());
909            }
910
911            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
912            // are envelope_size bytes.
913            let cur_offset: usize = (1 - 1) * envelope_size;
914
915            // Zero reserved fields.
916            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
917
918            // Safety:
919            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
920            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
921            //   envelope_size bytes, there is always sufficient room.
922            fidl::encoding::encode_in_envelope_optional::<u64, D>(
923                self.value.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
924                encoder,
925                offset + cur_offset,
926                depth,
927            )?;
928
929            _prev_end_offset = cur_offset + envelope_size;
930            if 2 > max_ordinal {
931                return Ok(());
932            }
933
934            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
935            // are envelope_size bytes.
936            let cur_offset: usize = (2 - 1) * envelope_size;
937
938            // Zero reserved fields.
939            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
940
941            // Safety:
942            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
943            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
944            //   envelope_size bytes, there is always sufficient room.
945            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
946                self.forward_to_server.as_ref().map(
947                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
948                ),
949                encoder,
950                offset + cur_offset,
951                depth,
952            )?;
953
954            _prev_end_offset = cur_offset + envelope_size;
955
956            Ok(())
957        }
958    }
959
960    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
961        for ComposedEchoTableRequestComposedRequest
962    {
963        #[inline(always)]
964        fn new_empty() -> Self {
965            Self::default()
966        }
967
968        unsafe fn decode(
969            &mut self,
970            decoder: &mut fidl::encoding::Decoder<'_, D>,
971            offset: usize,
972            mut depth: fidl::encoding::Depth,
973        ) -> fidl::Result<()> {
974            decoder.debug_check_bounds::<Self>(offset);
975            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
976                None => return Err(fidl::Error::NotNullable),
977                Some(len) => len,
978            };
979            // Calling decoder.out_of_line_offset(0) is not allowed.
980            if len == 0 {
981                return Ok(());
982            };
983            depth.increment()?;
984            let envelope_size = 8;
985            let bytes_len = len * envelope_size;
986            let offset = decoder.out_of_line_offset(bytes_len)?;
987            // Decode the envelope for each type.
988            let mut _next_ordinal_to_read = 0;
989            let mut next_offset = offset;
990            let end_offset = offset + bytes_len;
991            _next_ordinal_to_read += 1;
992            if next_offset >= end_offset {
993                return Ok(());
994            }
995
996            // Decode unknown envelopes for gaps in ordinals.
997            while _next_ordinal_to_read < 1 {
998                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
999                _next_ordinal_to_read += 1;
1000                next_offset += envelope_size;
1001            }
1002
1003            let next_out_of_line = decoder.next_out_of_line();
1004            let handles_before = decoder.remaining_handles();
1005            if let Some((inlined, num_bytes, num_handles)) =
1006                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1007            {
1008                let member_inline_size =
1009                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1010                if inlined != (member_inline_size <= 4) {
1011                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1012                }
1013                let inner_offset;
1014                let mut inner_depth = depth.clone();
1015                if inlined {
1016                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1017                    inner_offset = next_offset;
1018                } else {
1019                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1020                    inner_depth.increment()?;
1021                }
1022                let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(u64, D));
1023                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1024                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1025                {
1026                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1027                }
1028                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1029                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1030                }
1031            }
1032
1033            next_offset += envelope_size;
1034            _next_ordinal_to_read += 1;
1035            if next_offset >= end_offset {
1036                return Ok(());
1037            }
1038
1039            // Decode unknown envelopes for gaps in ordinals.
1040            while _next_ordinal_to_read < 2 {
1041                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1042                _next_ordinal_to_read += 1;
1043                next_offset += envelope_size;
1044            }
1045
1046            let next_out_of_line = decoder.next_out_of_line();
1047            let handles_before = decoder.remaining_handles();
1048            if let Some((inlined, num_bytes, num_handles)) =
1049                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1050            {
1051                let member_inline_size =
1052                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1053                        decoder.context,
1054                    );
1055                if inlined != (member_inline_size <= 4) {
1056                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1057                }
1058                let inner_offset;
1059                let mut inner_depth = depth.clone();
1060                if inlined {
1061                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1062                    inner_offset = next_offset;
1063                } else {
1064                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1065                    inner_depth.increment()?;
1066                }
1067                let val_ref = self
1068                    .forward_to_server
1069                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1070                fidl::decode!(
1071                    fidl::encoding::UnboundedString,
1072                    D,
1073                    val_ref,
1074                    decoder,
1075                    inner_offset,
1076                    inner_depth
1077                )?;
1078                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1079                {
1080                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1081                }
1082                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1083                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1084                }
1085            }
1086
1087            next_offset += envelope_size;
1088
1089            // Decode the remaining unknown envelopes.
1090            while next_offset < end_offset {
1091                _next_ordinal_to_read += 1;
1092                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1093                next_offset += envelope_size;
1094            }
1095
1096            Ok(())
1097        }
1098    }
1099
1100    impl fidl::encoding::ValueTypeMarker for ComposedEchoUnionResponseWithErrorComposedResponse {
1101        type Borrowed<'a> = &'a Self;
1102        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1103            value
1104        }
1105    }
1106
1107    unsafe impl fidl::encoding::TypeMarker for ComposedEchoUnionResponseWithErrorComposedResponse {
1108        type Owned = Self;
1109
1110        #[inline(always)]
1111        fn inline_align(_context: fidl::encoding::Context) -> usize {
1112            8
1113        }
1114
1115        #[inline(always)]
1116        fn inline_size(_context: fidl::encoding::Context) -> usize {
1117            16
1118        }
1119    }
1120
1121    unsafe impl<D: fidl::encoding::ResourceDialect>
1122        fidl::encoding::Encode<ComposedEchoUnionResponseWithErrorComposedResponse, D>
1123        for &ComposedEchoUnionResponseWithErrorComposedResponse
1124    {
1125        #[inline]
1126        unsafe fn encode(
1127            self,
1128            encoder: &mut fidl::encoding::Encoder<'_, D>,
1129            offset: usize,
1130            _depth: fidl::encoding::Depth,
1131        ) -> fidl::Result<()> {
1132            encoder
1133                .debug_check_bounds::<ComposedEchoUnionResponseWithErrorComposedResponse>(offset);
1134            encoder.write_num::<u64>(self.ordinal(), offset);
1135            match self {
1136                ComposedEchoUnionResponseWithErrorComposedResponse::Unsigned(ref val) => {
1137                    fidl::encoding::encode_in_envelope::<u64, D>(
1138                        <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1139                        encoder,
1140                        offset + 8,
1141                        _depth,
1142                    )
1143                }
1144                ComposedEchoUnionResponseWithErrorComposedResponse::Signed(ref val) => {
1145                    fidl::encoding::encode_in_envelope::<i64, D>(
1146                        <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1147                        encoder,
1148                        offset + 8,
1149                        _depth,
1150                    )
1151                }
1152            }
1153        }
1154    }
1155
1156    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1157        for ComposedEchoUnionResponseWithErrorComposedResponse
1158    {
1159        #[inline(always)]
1160        fn new_empty() -> Self {
1161            Self::Unsigned(fidl::new_empty!(u64, D))
1162        }
1163
1164        #[inline]
1165        unsafe fn decode(
1166            &mut self,
1167            decoder: &mut fidl::encoding::Decoder<'_, D>,
1168            offset: usize,
1169            mut depth: fidl::encoding::Depth,
1170        ) -> fidl::Result<()> {
1171            decoder.debug_check_bounds::<Self>(offset);
1172            #[allow(unused_variables)]
1173            let next_out_of_line = decoder.next_out_of_line();
1174            let handles_before = decoder.remaining_handles();
1175            let (ordinal, inlined, num_bytes, num_handles) =
1176                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1177
1178            let member_inline_size = match ordinal {
1179                1 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1180                2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1181                _ => return Err(fidl::Error::UnknownUnionTag),
1182            };
1183
1184            if inlined != (member_inline_size <= 4) {
1185                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1186            }
1187            let _inner_offset;
1188            if inlined {
1189                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1190                _inner_offset = offset + 8;
1191            } else {
1192                depth.increment()?;
1193                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1194            }
1195            match ordinal {
1196                1 => {
1197                    #[allow(irrefutable_let_patterns)]
1198                    if let ComposedEchoUnionResponseWithErrorComposedResponse::Unsigned(_) = self {
1199                        // Do nothing, read the value into the object
1200                    } else {
1201                        // Initialize `self` to the right variant
1202                        *self = ComposedEchoUnionResponseWithErrorComposedResponse::Unsigned(
1203                            fidl::new_empty!(u64, D),
1204                        );
1205                    }
1206                    #[allow(irrefutable_let_patterns)]
1207                    if let ComposedEchoUnionResponseWithErrorComposedResponse::Unsigned(
1208                        ref mut val,
1209                    ) = self
1210                    {
1211                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
1212                    } else {
1213                        unreachable!()
1214                    }
1215                }
1216                2 => {
1217                    #[allow(irrefutable_let_patterns)]
1218                    if let ComposedEchoUnionResponseWithErrorComposedResponse::Signed(_) = self {
1219                        // Do nothing, read the value into the object
1220                    } else {
1221                        // Initialize `self` to the right variant
1222                        *self = ComposedEchoUnionResponseWithErrorComposedResponse::Signed(
1223                            fidl::new_empty!(i64, D),
1224                        );
1225                    }
1226                    #[allow(irrefutable_let_patterns)]
1227                    if let ComposedEchoUnionResponseWithErrorComposedResponse::Signed(ref mut val) =
1228                        self
1229                    {
1230                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
1231                    } else {
1232                        unreachable!()
1233                    }
1234                }
1235                ordinal => panic!("unexpected ordinal {:?}", ordinal),
1236            }
1237            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1238                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1239            }
1240            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1241                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1242            }
1243            Ok(())
1244        }
1245    }
1246}
fidl_fidl_test_imported_common/fidl_fidl_test_imported_common.rs

fidl_fidl_test_imported_common/
fidl_fidl_test_imported_common.rs
