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

fidl_fuchsia_driver_loader__common/
fidl_fuchsia_driver_loader__common.rs
