fidl_test_metadata__common/
fidl_test_metadata__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 IntMetadata {
13    pub test_field: Option<i32>,
14    #[doc(hidden)]
15    pub __source_breaking: fidl::marker::SourceBreaking,
16}
17
18impl fidl::Persistable for IntMetadata {}
19impl fidl::Serializable for IntMetadata {
20    const SERIALIZABLE_NAME: &'static str = "test.metadata.IntMetadata";
21}
22
23#[derive(Clone, Debug, Default, PartialEq)]
24pub struct Metadata {
25    pub test_field: Option<String>,
26    #[doc(hidden)]
27    pub __source_breaking: fidl::marker::SourceBreaking,
28}
29
30impl fidl::Persistable for Metadata {}
31impl fidl::Serializable for Metadata {
32    const SERIALIZABLE_NAME: &'static str = "test.metadata.Metadata";
33}
34
35mod internal {
36    use super::*;
37
38    impl IntMetadata {
39        #[inline(always)]
40        fn max_ordinal_present(&self) -> u64 {
41            if let Some(_) = self.test_field {
42                return 1;
43            }
44            0
45        }
46    }
47
48    impl fidl::encoding::ValueTypeMarker for IntMetadata {
49        type Borrowed<'a> = &'a Self;
50        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
51            value
52        }
53    }
54
55    unsafe impl fidl::encoding::TypeMarker for IntMetadata {
56        type Owned = Self;
57
58        #[inline(always)]
59        fn inline_align(_context: fidl::encoding::Context) -> usize {
60            8
61        }
62
63        #[inline(always)]
64        fn inline_size(_context: fidl::encoding::Context) -> usize {
65            16
66        }
67    }
68
69    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IntMetadata, D>
70        for &IntMetadata
71    {
72        unsafe fn encode(
73            self,
74            encoder: &mut fidl::encoding::Encoder<'_, D>,
75            offset: usize,
76            mut depth: fidl::encoding::Depth,
77        ) -> fidl::Result<()> {
78            encoder.debug_check_bounds::<IntMetadata>(offset);
79            // Vector header
80            let max_ordinal: u64 = self.max_ordinal_present();
81            encoder.write_num(max_ordinal, offset);
82            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83            // Calling encoder.out_of_line_offset(0) is not allowed.
84            if max_ordinal == 0 {
85                return Ok(());
86            }
87            depth.increment()?;
88            let envelope_size = 8;
89            let bytes_len = max_ordinal as usize * envelope_size;
90            #[allow(unused_variables)]
91            let offset = encoder.out_of_line_offset(bytes_len);
92            let mut _prev_end_offset: usize = 0;
93            if 1 > max_ordinal {
94                return Ok(());
95            }
96
97            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
98            // are envelope_size bytes.
99            let cur_offset: usize = (1 - 1) * envelope_size;
100
101            // Zero reserved fields.
102            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
103
104            // Safety:
105            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
106            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
107            //   envelope_size bytes, there is always sufficient room.
108            fidl::encoding::encode_in_envelope_optional::<i32, D>(
109                self.test_field.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
110                encoder,
111                offset + cur_offset,
112                depth,
113            )?;
114
115            _prev_end_offset = cur_offset + envelope_size;
116
117            Ok(())
118        }
119    }
120
121    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IntMetadata {
122        #[inline(always)]
123        fn new_empty() -> Self {
124            Self::default()
125        }
126
127        unsafe fn decode(
128            &mut self,
129            decoder: &mut fidl::encoding::Decoder<'_, D>,
130            offset: usize,
131            mut depth: fidl::encoding::Depth,
132        ) -> fidl::Result<()> {
133            decoder.debug_check_bounds::<Self>(offset);
134            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
135                None => return Err(fidl::Error::NotNullable),
136                Some(len) => len,
137            };
138            // Calling decoder.out_of_line_offset(0) is not allowed.
139            if len == 0 {
140                return Ok(());
141            };
142            depth.increment()?;
143            let envelope_size = 8;
144            let bytes_len = len * envelope_size;
145            let offset = decoder.out_of_line_offset(bytes_len)?;
146            // Decode the envelope for each type.
147            let mut _next_ordinal_to_read = 0;
148            let mut next_offset = offset;
149            let end_offset = offset + bytes_len;
150            _next_ordinal_to_read += 1;
151            if next_offset >= end_offset {
152                return Ok(());
153            }
154
155            // Decode unknown envelopes for gaps in ordinals.
156            while _next_ordinal_to_read < 1 {
157                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
158                _next_ordinal_to_read += 1;
159                next_offset += envelope_size;
160            }
161
162            let next_out_of_line = decoder.next_out_of_line();
163            let handles_before = decoder.remaining_handles();
164            if let Some((inlined, num_bytes, num_handles)) =
165                fidl::encoding::decode_envelope_header(decoder, next_offset)?
166            {
167                let member_inline_size =
168                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
169                if inlined != (member_inline_size <= 4) {
170                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
171                }
172                let inner_offset;
173                let mut inner_depth = depth.clone();
174                if inlined {
175                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
176                    inner_offset = next_offset;
177                } else {
178                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
179                    inner_depth.increment()?;
180                }
181                let val_ref = self.test_field.get_or_insert_with(|| fidl::new_empty!(i32, D));
182                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
183                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
184                {
185                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
186                }
187                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
188                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
189                }
190            }
191
192            next_offset += envelope_size;
193
194            // Decode the remaining unknown envelopes.
195            while next_offset < end_offset {
196                _next_ordinal_to_read += 1;
197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
198                next_offset += envelope_size;
199            }
200
201            Ok(())
202        }
203    }
204
205    impl Metadata {
206        #[inline(always)]
207        fn max_ordinal_present(&self) -> u64 {
208            if let Some(_) = self.test_field {
209                return 1;
210            }
211            0
212        }
213    }
214
215    impl fidl::encoding::ValueTypeMarker for Metadata {
216        type Borrowed<'a> = &'a Self;
217        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
218            value
219        }
220    }
221
222    unsafe impl fidl::encoding::TypeMarker for Metadata {
223        type Owned = Self;
224
225        #[inline(always)]
226        fn inline_align(_context: fidl::encoding::Context) -> usize {
227            8
228        }
229
230        #[inline(always)]
231        fn inline_size(_context: fidl::encoding::Context) -> usize {
232            16
233        }
234    }
235
236    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metadata, D> for &Metadata {
237        unsafe fn encode(
238            self,
239            encoder: &mut fidl::encoding::Encoder<'_, D>,
240            offset: usize,
241            mut depth: fidl::encoding::Depth,
242        ) -> fidl::Result<()> {
243            encoder.debug_check_bounds::<Metadata>(offset);
244            // Vector header
245            let max_ordinal: u64 = self.max_ordinal_present();
246            encoder.write_num(max_ordinal, offset);
247            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
248            // Calling encoder.out_of_line_offset(0) is not allowed.
249            if max_ordinal == 0 {
250                return Ok(());
251            }
252            depth.increment()?;
253            let envelope_size = 8;
254            let bytes_len = max_ordinal as usize * envelope_size;
255            #[allow(unused_variables)]
256            let offset = encoder.out_of_line_offset(bytes_len);
257            let mut _prev_end_offset: usize = 0;
258            if 1 > max_ordinal {
259                return Ok(());
260            }
261
262            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
263            // are envelope_size bytes.
264            let cur_offset: usize = (1 - 1) * envelope_size;
265
266            // Zero reserved fields.
267            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
268
269            // Safety:
270            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
271            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
272            //   envelope_size bytes, there is always sufficient room.
273            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
274                self.test_field.as_ref().map(
275                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
276                ),
277                encoder,
278                offset + cur_offset,
279                depth,
280            )?;
281
282            _prev_end_offset = cur_offset + envelope_size;
283
284            Ok(())
285        }
286    }
287
288    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metadata {
289        #[inline(always)]
290        fn new_empty() -> Self {
291            Self::default()
292        }
293
294        unsafe fn decode(
295            &mut self,
296            decoder: &mut fidl::encoding::Decoder<'_, D>,
297            offset: usize,
298            mut depth: fidl::encoding::Depth,
299        ) -> fidl::Result<()> {
300            decoder.debug_check_bounds::<Self>(offset);
301            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
302                None => return Err(fidl::Error::NotNullable),
303                Some(len) => len,
304            };
305            // Calling decoder.out_of_line_offset(0) is not allowed.
306            if len == 0 {
307                return Ok(());
308            };
309            depth.increment()?;
310            let envelope_size = 8;
311            let bytes_len = len * envelope_size;
312            let offset = decoder.out_of_line_offset(bytes_len)?;
313            // Decode the envelope for each type.
314            let mut _next_ordinal_to_read = 0;
315            let mut next_offset = offset;
316            let end_offset = offset + bytes_len;
317            _next_ordinal_to_read += 1;
318            if next_offset >= end_offset {
319                return Ok(());
320            }
321
322            // Decode unknown envelopes for gaps in ordinals.
323            while _next_ordinal_to_read < 1 {
324                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
325                _next_ordinal_to_read += 1;
326                next_offset += envelope_size;
327            }
328
329            let next_out_of_line = decoder.next_out_of_line();
330            let handles_before = decoder.remaining_handles();
331            if let Some((inlined, num_bytes, num_handles)) =
332                fidl::encoding::decode_envelope_header(decoder, next_offset)?
333            {
334                let member_inline_size =
335                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
336                        decoder.context,
337                    );
338                if inlined != (member_inline_size <= 4) {
339                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
340                }
341                let inner_offset;
342                let mut inner_depth = depth.clone();
343                if inlined {
344                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
345                    inner_offset = next_offset;
346                } else {
347                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
348                    inner_depth.increment()?;
349                }
350                let val_ref = self
351                    .test_field
352                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
353                fidl::decode!(
354                    fidl::encoding::UnboundedString,
355                    D,
356                    val_ref,
357                    decoder,
358                    inner_offset,
359                    inner_depth
360                )?;
361                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
362                {
363                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
364                }
365                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
366                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
367                }
368            }
369
370            next_offset += envelope_size;
371
372            // Decode the remaining unknown envelopes.
373            while next_offset < end_offset {
374                _next_ordinal_to_read += 1;
375                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
376                next_offset += envelope_size;
377            }
378
379            Ok(())
380        }
381    }
382}
fidl_test_metadata__common/fidl_test_metadata__common.rs

fidl_test_metadata__common/
fidl_test_metadata__common.rs
