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

fidl_fidl_test_imported__common/
fidl_fidl_test_imported__common.rs
