fidl_fuchsia_starnix_gralloc__common/
fidl_fuchsia_starnix_gralloc__common.rs1#![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)]
12pub enum VulkanMode {
13 NotYetSet,
14 Swiftshader,
15 Magma,
16 #[doc(hidden)]
17 __SourceBreaking {
18 unknown_ordinal: u32,
19 },
20}
21
22#[macro_export]
24macro_rules! VulkanModeUnknown {
25 () => {
26 _
27 };
28}
29
30impl VulkanMode {
31 #[inline]
32 pub fn from_primitive(prim: u32) -> Option<Self> {
33 match prim {
34 0 => Some(Self::NotYetSet),
35 1 => Some(Self::Swiftshader),
36 2 => Some(Self::Magma),
37 _ => None,
38 }
39 }
40
41 #[inline]
42 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43 match prim {
44 0 => Self::NotYetSet,
45 1 => Self::Swiftshader,
46 2 => Self::Magma,
47 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
48 }
49 }
50
51 #[inline]
52 pub fn unknown() -> Self {
53 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
54 }
55
56 #[inline]
57 pub const fn into_primitive(self) -> u32 {
58 match self {
59 Self::NotYetSet => 0,
60 Self::Swiftshader => 1,
61 Self::Magma => 2,
62 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
63 }
64 }
65
66 #[inline]
67 pub fn is_unknown(&self) -> bool {
68 match self {
69 Self::__SourceBreaking { unknown_ordinal: _ } => true,
70 _ => false,
71 }
72 }
73}
74
75#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
76pub enum VulkanModeSetterError {
77 InvalidArgs,
78 #[doc(hidden)]
79 __SourceBreaking {
80 unknown_ordinal: u32,
81 },
82}
83
84#[macro_export]
86macro_rules! VulkanModeSetterErrorUnknown {
87 () => {
88 _
89 };
90}
91
92impl VulkanModeSetterError {
93 #[inline]
94 pub fn from_primitive(prim: u32) -> Option<Self> {
95 match prim {
96 1 => Some(Self::InvalidArgs),
97 _ => None,
98 }
99 }
100
101 #[inline]
102 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
103 match prim {
104 1 => Self::InvalidArgs,
105 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
106 }
107 }
108
109 #[inline]
110 pub fn unknown() -> Self {
111 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
112 }
113
114 #[inline]
115 pub const fn into_primitive(self) -> u32 {
116 match self {
117 Self::InvalidArgs => 1,
118 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
119 }
120 }
121
122 #[inline]
123 pub fn is_unknown(&self) -> bool {
124 match self {
125 Self::__SourceBreaking { unknown_ordinal: _ } => true,
126 _ => false,
127 }
128 }
129}
130
131#[derive(Clone, Debug, Default, PartialEq)]
132pub struct VulkanModeSetterSetVulkanModeRequest {
133 pub vulkan_mode: Option<VulkanMode>,
134 #[doc(hidden)]
135 pub __source_breaking: fidl::marker::SourceBreaking,
136}
137
138impl fidl::Persistable for VulkanModeSetterSetVulkanModeRequest {}
139
140pub mod vulkan_mode_setter_ordinals {
141 pub const SET_VULKAN_MODE: u64 = 0x71ffe16858e9e7eb;
142}
143
144mod internal {
145 use super::*;
146 unsafe impl fidl::encoding::TypeMarker for VulkanMode {
147 type Owned = Self;
148
149 #[inline(always)]
150 fn inline_align(_context: fidl::encoding::Context) -> usize {
151 std::mem::align_of::<u32>()
152 }
153
154 #[inline(always)]
155 fn inline_size(_context: fidl::encoding::Context) -> usize {
156 std::mem::size_of::<u32>()
157 }
158
159 #[inline(always)]
160 fn encode_is_copy() -> bool {
161 false
162 }
163
164 #[inline(always)]
165 fn decode_is_copy() -> bool {
166 false
167 }
168 }
169
170 impl fidl::encoding::ValueTypeMarker for VulkanMode {
171 type Borrowed<'a> = Self;
172 #[inline(always)]
173 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
174 *value
175 }
176 }
177
178 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VulkanMode {
179 #[inline]
180 unsafe fn encode(
181 self,
182 encoder: &mut fidl::encoding::Encoder<'_, D>,
183 offset: usize,
184 _depth: fidl::encoding::Depth,
185 ) -> fidl::Result<()> {
186 encoder.debug_check_bounds::<Self>(offset);
187 encoder.write_num(self.into_primitive(), offset);
188 Ok(())
189 }
190 }
191
192 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VulkanMode {
193 #[inline(always)]
194 fn new_empty() -> Self {
195 Self::unknown()
196 }
197
198 #[inline]
199 unsafe fn decode(
200 &mut self,
201 decoder: &mut fidl::encoding::Decoder<'_, D>,
202 offset: usize,
203 _depth: fidl::encoding::Depth,
204 ) -> fidl::Result<()> {
205 decoder.debug_check_bounds::<Self>(offset);
206 let prim = decoder.read_num::<u32>(offset);
207
208 *self = Self::from_primitive_allow_unknown(prim);
209 Ok(())
210 }
211 }
212 unsafe impl fidl::encoding::TypeMarker for VulkanModeSetterError {
213 type Owned = Self;
214
215 #[inline(always)]
216 fn inline_align(_context: fidl::encoding::Context) -> usize {
217 std::mem::align_of::<u32>()
218 }
219
220 #[inline(always)]
221 fn inline_size(_context: fidl::encoding::Context) -> usize {
222 std::mem::size_of::<u32>()
223 }
224
225 #[inline(always)]
226 fn encode_is_copy() -> bool {
227 false
228 }
229
230 #[inline(always)]
231 fn decode_is_copy() -> bool {
232 false
233 }
234 }
235
236 impl fidl::encoding::ValueTypeMarker for VulkanModeSetterError {
237 type Borrowed<'a> = Self;
238 #[inline(always)]
239 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
240 *value
241 }
242 }
243
244 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
245 for VulkanModeSetterError
246 {
247 #[inline]
248 unsafe fn encode(
249 self,
250 encoder: &mut fidl::encoding::Encoder<'_, D>,
251 offset: usize,
252 _depth: fidl::encoding::Depth,
253 ) -> fidl::Result<()> {
254 encoder.debug_check_bounds::<Self>(offset);
255 encoder.write_num(self.into_primitive(), offset);
256 Ok(())
257 }
258 }
259
260 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VulkanModeSetterError {
261 #[inline(always)]
262 fn new_empty() -> Self {
263 Self::unknown()
264 }
265
266 #[inline]
267 unsafe fn decode(
268 &mut self,
269 decoder: &mut fidl::encoding::Decoder<'_, D>,
270 offset: usize,
271 _depth: fidl::encoding::Depth,
272 ) -> fidl::Result<()> {
273 decoder.debug_check_bounds::<Self>(offset);
274 let prim = decoder.read_num::<u32>(offset);
275
276 *self = Self::from_primitive_allow_unknown(prim);
277 Ok(())
278 }
279 }
280
281 impl VulkanModeSetterSetVulkanModeRequest {
282 #[inline(always)]
283 fn max_ordinal_present(&self) -> u64 {
284 if let Some(_) = self.vulkan_mode {
285 return 1;
286 }
287 0
288 }
289 }
290
291 impl fidl::encoding::ValueTypeMarker for VulkanModeSetterSetVulkanModeRequest {
292 type Borrowed<'a> = &'a Self;
293 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
294 value
295 }
296 }
297
298 unsafe impl fidl::encoding::TypeMarker for VulkanModeSetterSetVulkanModeRequest {
299 type Owned = Self;
300
301 #[inline(always)]
302 fn inline_align(_context: fidl::encoding::Context) -> usize {
303 8
304 }
305
306 #[inline(always)]
307 fn inline_size(_context: fidl::encoding::Context) -> usize {
308 16
309 }
310 }
311
312 unsafe impl<D: fidl::encoding::ResourceDialect>
313 fidl::encoding::Encode<VulkanModeSetterSetVulkanModeRequest, D>
314 for &VulkanModeSetterSetVulkanModeRequest
315 {
316 unsafe fn encode(
317 self,
318 encoder: &mut fidl::encoding::Encoder<'_, D>,
319 offset: usize,
320 mut depth: fidl::encoding::Depth,
321 ) -> fidl::Result<()> {
322 encoder.debug_check_bounds::<VulkanModeSetterSetVulkanModeRequest>(offset);
323 let max_ordinal: u64 = self.max_ordinal_present();
325 encoder.write_num(max_ordinal, offset);
326 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
327 if max_ordinal == 0 {
329 return Ok(());
330 }
331 depth.increment()?;
332 let envelope_size = 8;
333 let bytes_len = max_ordinal as usize * envelope_size;
334 #[allow(unused_variables)]
335 let offset = encoder.out_of_line_offset(bytes_len);
336 let mut _prev_end_offset: usize = 0;
337 if 1 > max_ordinal {
338 return Ok(());
339 }
340
341 let cur_offset: usize = (1 - 1) * envelope_size;
344
345 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
347
348 fidl::encoding::encode_in_envelope_optional::<VulkanMode, D>(
353 self.vulkan_mode
354 .as_ref()
355 .map(<VulkanMode as fidl::encoding::ValueTypeMarker>::borrow),
356 encoder,
357 offset + cur_offset,
358 depth,
359 )?;
360
361 _prev_end_offset = cur_offset + envelope_size;
362
363 Ok(())
364 }
365 }
366
367 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
368 for VulkanModeSetterSetVulkanModeRequest
369 {
370 #[inline(always)]
371 fn new_empty() -> Self {
372 Self::default()
373 }
374
375 unsafe fn decode(
376 &mut self,
377 decoder: &mut fidl::encoding::Decoder<'_, D>,
378 offset: usize,
379 mut depth: fidl::encoding::Depth,
380 ) -> fidl::Result<()> {
381 decoder.debug_check_bounds::<Self>(offset);
382 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
383 None => return Err(fidl::Error::NotNullable),
384 Some(len) => len,
385 };
386 if len == 0 {
388 return Ok(());
389 };
390 depth.increment()?;
391 let envelope_size = 8;
392 let bytes_len = len * envelope_size;
393 let offset = decoder.out_of_line_offset(bytes_len)?;
394 let mut _next_ordinal_to_read = 0;
396 let mut next_offset = offset;
397 let end_offset = offset + bytes_len;
398 _next_ordinal_to_read += 1;
399 if next_offset >= end_offset {
400 return Ok(());
401 }
402
403 while _next_ordinal_to_read < 1 {
405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
406 _next_ordinal_to_read += 1;
407 next_offset += envelope_size;
408 }
409
410 let next_out_of_line = decoder.next_out_of_line();
411 let handles_before = decoder.remaining_handles();
412 if let Some((inlined, num_bytes, num_handles)) =
413 fidl::encoding::decode_envelope_header(decoder, next_offset)?
414 {
415 let member_inline_size =
416 <VulkanMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
417 if inlined != (member_inline_size <= 4) {
418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
419 }
420 let inner_offset;
421 let mut inner_depth = depth.clone();
422 if inlined {
423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
424 inner_offset = next_offset;
425 } else {
426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
427 inner_depth.increment()?;
428 }
429 let val_ref =
430 self.vulkan_mode.get_or_insert_with(|| fidl::new_empty!(VulkanMode, D));
431 fidl::decode!(VulkanMode, D, val_ref, decoder, inner_offset, inner_depth)?;
432 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
433 {
434 return Err(fidl::Error::InvalidNumBytesInEnvelope);
435 }
436 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
437 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
438 }
439 }
440
441 next_offset += envelope_size;
442
443 while next_offset < end_offset {
445 _next_ordinal_to_read += 1;
446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
447 next_offset += envelope_size;
448 }
449
450 Ok(())
451 }
452 }
453}