fidl_fuchsia_runtime_test__common/
fidl_fuchsia_runtime_test__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Clone, Debug, Default, PartialEq)]
12pub struct WrappedValue {
13    pub value: Option<u32>,
14    #[doc(hidden)]
15    pub __source_breaking: fidl::marker::SourceBreaking,
16}
17
18impl fidl::Persistable for WrappedValue {}
19
20pub mod waiter_ordinals {
21    pub const ACK: u64 = 0x1c4dde6651760354;
22}
23
24mod internal {
25    use super::*;
26
27    impl WrappedValue {
28        #[inline(always)]
29        fn max_ordinal_present(&self) -> u64 {
30            if let Some(_) = self.value {
31                return 1;
32            }
33            0
34        }
35    }
36
37    impl fidl::encoding::ValueTypeMarker for WrappedValue {
38        type Borrowed<'a> = &'a Self;
39        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
40            value
41        }
42    }
43
44    unsafe impl fidl::encoding::TypeMarker for WrappedValue {
45        type Owned = Self;
46
47        #[inline(always)]
48        fn inline_align(_context: fidl::encoding::Context) -> usize {
49            8
50        }
51
52        #[inline(always)]
53        fn inline_size(_context: fidl::encoding::Context) -> usize {
54            16
55        }
56    }
57
58    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WrappedValue, D>
59        for &WrappedValue
60    {
61        unsafe fn encode(
62            self,
63            encoder: &mut fidl::encoding::Encoder<'_, D>,
64            offset: usize,
65            mut depth: fidl::encoding::Depth,
66        ) -> fidl::Result<()> {
67            encoder.debug_check_bounds::<WrappedValue>(offset);
68            // Vector header
69            let max_ordinal: u64 = self.max_ordinal_present();
70            encoder.write_num(max_ordinal, offset);
71            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
72            // Calling encoder.out_of_line_offset(0) is not allowed.
73            if max_ordinal == 0 {
74                return Ok(());
75            }
76            depth.increment()?;
77            let envelope_size = 8;
78            let bytes_len = max_ordinal as usize * envelope_size;
79            #[allow(unused_variables)]
80            let offset = encoder.out_of_line_offset(bytes_len);
81            let mut _prev_end_offset: usize = 0;
82            if 1 > max_ordinal {
83                return Ok(());
84            }
85
86            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
87            // are envelope_size bytes.
88            let cur_offset: usize = (1 - 1) * envelope_size;
89
90            // Zero reserved fields.
91            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
92
93            // Safety:
94            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
95            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
96            //   envelope_size bytes, there is always sufficient room.
97            fidl::encoding::encode_in_envelope_optional::<u32, D>(
98                self.value.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
99                encoder,
100                offset + cur_offset,
101                depth,
102            )?;
103
104            _prev_end_offset = cur_offset + envelope_size;
105
106            Ok(())
107        }
108    }
109
110    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WrappedValue {
111        #[inline(always)]
112        fn new_empty() -> Self {
113            Self::default()
114        }
115
116        unsafe fn decode(
117            &mut self,
118            decoder: &mut fidl::encoding::Decoder<'_, D>,
119            offset: usize,
120            mut depth: fidl::encoding::Depth,
121        ) -> fidl::Result<()> {
122            decoder.debug_check_bounds::<Self>(offset);
123            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
124                None => return Err(fidl::Error::NotNullable),
125                Some(len) => len,
126            };
127            // Calling decoder.out_of_line_offset(0) is not allowed.
128            if len == 0 {
129                return Ok(());
130            };
131            depth.increment()?;
132            let envelope_size = 8;
133            let bytes_len = len * envelope_size;
134            let offset = decoder.out_of_line_offset(bytes_len)?;
135            // Decode the envelope for each type.
136            let mut _next_ordinal_to_read = 0;
137            let mut next_offset = offset;
138            let end_offset = offset + bytes_len;
139            _next_ordinal_to_read += 1;
140            if next_offset >= end_offset {
141                return Ok(());
142            }
143
144            // Decode unknown envelopes for gaps in ordinals.
145            while _next_ordinal_to_read < 1 {
146                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
147                _next_ordinal_to_read += 1;
148                next_offset += envelope_size;
149            }
150
151            let next_out_of_line = decoder.next_out_of_line();
152            let handles_before = decoder.remaining_handles();
153            if let Some((inlined, num_bytes, num_handles)) =
154                fidl::encoding::decode_envelope_header(decoder, next_offset)?
155            {
156                let member_inline_size =
157                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
158                if inlined != (member_inline_size <= 4) {
159                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
160                }
161                let inner_offset;
162                let mut inner_depth = depth.clone();
163                if inlined {
164                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
165                    inner_offset = next_offset;
166                } else {
167                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
168                    inner_depth.increment()?;
169                }
170                let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(u32, D));
171                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
172                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
173                {
174                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
175                }
176                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
177                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
178                }
179            }
180
181            next_offset += envelope_size;
182
183            // Decode the remaining unknown envelopes.
184            while next_offset < end_offset {
185                _next_ordinal_to_read += 1;
186                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
187                next_offset += envelope_size;
188            }
189
190            Ok(())
191        }
192    }
193}
fidl_fuchsia_runtime_test__common/fidl_fuchsia_runtime_test__common.rs

fidl_fuchsia_runtime_test__common/
fidl_fuchsia_runtime_test__common.rs
