1#![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
11pub const MAX_NAME_LENGTH: i32 = 2048;
12
13pub const MAX_PARAMETER_COUNT: i32 = 512;
14
15pub const MAX_PARAMETER_KEY_LENGTH: i32 = 512;
16
17pub const MAX_PARAMETER_VALUE_LENGTH: i32 = 2048;
18
19#[derive(Clone, Debug, PartialEq)]
20pub struct Parameter {
21 pub key: String,
22 pub value: ParameterValue,
23}
24
25impl fidl::Persistable for Parameter {}
26
27#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
28pub struct RoleName {
29 pub role: String,
30}
31
32impl fidl::Persistable for RoleName {}
33impl fidl::Serializable for RoleName {
34 const SERIALIZABLE_NAME: &'static str = "fuchsia.scheduler.RoleName";
35}
36
37#[derive(Clone, Debug)]
38pub enum ParameterValue {
39 FloatValue(f64),
40 IntValue(i64),
41 StringValue(String),
42 #[doc(hidden)]
43 __SourceBreaking {
44 unknown_ordinal: u64,
45 },
46}
47
48#[macro_export]
50macro_rules! ParameterValueUnknown {
51 () => {
52 _
53 };
54}
55
56impl PartialEq for ParameterValue {
58 fn eq(&self, other: &Self) -> bool {
59 match (self, other) {
60 (Self::FloatValue(x), Self::FloatValue(y)) => *x == *y,
61 (Self::IntValue(x), Self::IntValue(y)) => *x == *y,
62 (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
63 _ => false,
64 }
65 }
66}
67
68impl ParameterValue {
69 #[inline]
70 pub fn ordinal(&self) -> u64 {
71 match *self {
72 Self::FloatValue(_) => 1,
73 Self::IntValue(_) => 2,
74 Self::StringValue(_) => 3,
75 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
76 }
77 }
78
79 #[inline]
80 pub fn unknown_variant_for_testing() -> Self {
81 Self::__SourceBreaking { unknown_ordinal: 0 }
82 }
83
84 #[inline]
85 pub fn is_unknown(&self) -> bool {
86 match self {
87 Self::__SourceBreaking { .. } => true,
88 _ => false,
89 }
90 }
91}
92
93impl fidl::Persistable for ParameterValue {}
94
95pub mod role_manager_ordinals {
96 pub const SET_ROLE: u64 = 0x617dd765af923edc;
97}
98
99mod internal {
100 use super::*;
101
102 impl fidl::encoding::ValueTypeMarker for Parameter {
103 type Borrowed<'a> = &'a Self;
104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
105 value
106 }
107 }
108
109 unsafe impl fidl::encoding::TypeMarker for Parameter {
110 type Owned = Self;
111
112 #[inline(always)]
113 fn inline_align(_context: fidl::encoding::Context) -> usize {
114 8
115 }
116
117 #[inline(always)]
118 fn inline_size(_context: fidl::encoding::Context) -> usize {
119 32
120 }
121 }
122
123 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
124 for &Parameter
125 {
126 #[inline]
127 unsafe fn encode(
128 self,
129 encoder: &mut fidl::encoding::Encoder<'_, D>,
130 offset: usize,
131 _depth: fidl::encoding::Depth,
132 ) -> fidl::Result<()> {
133 encoder.debug_check_bounds::<Parameter>(offset);
134 fidl::encoding::Encode::<Parameter, D>::encode(
136 (
137 <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow(
138 &self.key,
139 ),
140 <ParameterValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
141 ),
142 encoder,
143 offset,
144 _depth,
145 )
146 }
147 }
148 unsafe impl<
149 D: fidl::encoding::ResourceDialect,
150 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<512>, D>,
151 T1: fidl::encoding::Encode<ParameterValue, D>,
152 > fidl::encoding::Encode<Parameter, D> for (T0, T1)
153 {
154 #[inline]
155 unsafe fn encode(
156 self,
157 encoder: &mut fidl::encoding::Encoder<'_, D>,
158 offset: usize,
159 depth: fidl::encoding::Depth,
160 ) -> fidl::Result<()> {
161 encoder.debug_check_bounds::<Parameter>(offset);
162 self.0.encode(encoder, offset + 0, depth)?;
166 self.1.encode(encoder, offset + 16, depth)?;
167 Ok(())
168 }
169 }
170
171 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
172 #[inline(always)]
173 fn new_empty() -> Self {
174 Self {
175 key: fidl::new_empty!(fidl::encoding::BoundedString<512>, D),
176 value: fidl::new_empty!(ParameterValue, D),
177 }
178 }
179
180 #[inline]
181 unsafe fn decode(
182 &mut self,
183 decoder: &mut fidl::encoding::Decoder<'_, D>,
184 offset: usize,
185 _depth: fidl::encoding::Depth,
186 ) -> fidl::Result<()> {
187 decoder.debug_check_bounds::<Self>(offset);
188 fidl::decode!(
190 fidl::encoding::BoundedString<512>,
191 D,
192 &mut self.key,
193 decoder,
194 offset + 0,
195 _depth
196 )?;
197 fidl::decode!(ParameterValue, D, &mut self.value, decoder, offset + 16, _depth)?;
198 Ok(())
199 }
200 }
201
202 impl fidl::encoding::ValueTypeMarker for RoleName {
203 type Borrowed<'a> = &'a Self;
204 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
205 value
206 }
207 }
208
209 unsafe impl fidl::encoding::TypeMarker for RoleName {
210 type Owned = Self;
211
212 #[inline(always)]
213 fn inline_align(_context: fidl::encoding::Context) -> usize {
214 8
215 }
216
217 #[inline(always)]
218 fn inline_size(_context: fidl::encoding::Context) -> usize {
219 16
220 }
221 }
222
223 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoleName, D> for &RoleName {
224 #[inline]
225 unsafe fn encode(
226 self,
227 encoder: &mut fidl::encoding::Encoder<'_, D>,
228 offset: usize,
229 _depth: fidl::encoding::Depth,
230 ) -> fidl::Result<()> {
231 encoder.debug_check_bounds::<RoleName>(offset);
232 fidl::encoding::Encode::<RoleName, D>::encode(
234 (<fidl::encoding::BoundedString<2048> as fidl::encoding::ValueTypeMarker>::borrow(
235 &self.role,
236 ),),
237 encoder,
238 offset,
239 _depth,
240 )
241 }
242 }
243 unsafe impl<
244 D: fidl::encoding::ResourceDialect,
245 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<2048>, D>,
246 > fidl::encoding::Encode<RoleName, D> for (T0,)
247 {
248 #[inline]
249 unsafe fn encode(
250 self,
251 encoder: &mut fidl::encoding::Encoder<'_, D>,
252 offset: usize,
253 depth: fidl::encoding::Depth,
254 ) -> fidl::Result<()> {
255 encoder.debug_check_bounds::<RoleName>(offset);
256 self.0.encode(encoder, offset + 0, depth)?;
260 Ok(())
261 }
262 }
263
264 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoleName {
265 #[inline(always)]
266 fn new_empty() -> Self {
267 Self { role: fidl::new_empty!(fidl::encoding::BoundedString<2048>, D) }
268 }
269
270 #[inline]
271 unsafe fn decode(
272 &mut self,
273 decoder: &mut fidl::encoding::Decoder<'_, D>,
274 offset: usize,
275 _depth: fidl::encoding::Depth,
276 ) -> fidl::Result<()> {
277 decoder.debug_check_bounds::<Self>(offset);
278 fidl::decode!(
280 fidl::encoding::BoundedString<2048>,
281 D,
282 &mut self.role,
283 decoder,
284 offset + 0,
285 _depth
286 )?;
287 Ok(())
288 }
289 }
290
291 impl fidl::encoding::ValueTypeMarker for ParameterValue {
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 ParameterValue {
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> fidl::encoding::Encode<ParameterValue, D>
313 for &ParameterValue
314 {
315 #[inline]
316 unsafe fn encode(
317 self,
318 encoder: &mut fidl::encoding::Encoder<'_, D>,
319 offset: usize,
320 _depth: fidl::encoding::Depth,
321 ) -> fidl::Result<()> {
322 encoder.debug_check_bounds::<ParameterValue>(offset);
323 encoder.write_num::<u64>(self.ordinal(), offset);
324 match self {
325 ParameterValue::FloatValue(ref val) => {
326 fidl::encoding::encode_in_envelope::<f64, D>(
327 <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
328 encoder, offset + 8, _depth
329 )
330 }
331 ParameterValue::IntValue(ref val) => {
332 fidl::encoding::encode_in_envelope::<i64, D>(
333 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
334 encoder, offset + 8, _depth
335 )
336 }
337 ParameterValue::StringValue(ref val) => {
338 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<2048>, D>(
339 <fidl::encoding::BoundedString<2048> as fidl::encoding::ValueTypeMarker>::borrow(val),
340 encoder, offset + 8, _depth
341 )
342 }
343 ParameterValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
344 }
345 }
346 }
347
348 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParameterValue {
349 #[inline(always)]
350 fn new_empty() -> Self {
351 Self::__SourceBreaking { unknown_ordinal: 0 }
352 }
353
354 #[inline]
355 unsafe fn decode(
356 &mut self,
357 decoder: &mut fidl::encoding::Decoder<'_, D>,
358 offset: usize,
359 mut depth: fidl::encoding::Depth,
360 ) -> fidl::Result<()> {
361 decoder.debug_check_bounds::<Self>(offset);
362 #[allow(unused_variables)]
363 let next_out_of_line = decoder.next_out_of_line();
364 let handles_before = decoder.remaining_handles();
365 let (ordinal, inlined, num_bytes, num_handles) =
366 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
367
368 let member_inline_size = match ordinal {
369 1 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
370 2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
371 3 => {
372 <fidl::encoding::BoundedString<2048> as fidl::encoding::TypeMarker>::inline_size(
373 decoder.context,
374 )
375 }
376 0 => return Err(fidl::Error::UnknownUnionTag),
377 _ => num_bytes as usize,
378 };
379
380 if inlined != (member_inline_size <= 4) {
381 return Err(fidl::Error::InvalidInlineBitInEnvelope);
382 }
383 let _inner_offset;
384 if inlined {
385 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
386 _inner_offset = offset + 8;
387 } else {
388 depth.increment()?;
389 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
390 }
391 match ordinal {
392 1 => {
393 #[allow(irrefutable_let_patterns)]
394 if let ParameterValue::FloatValue(_) = self {
395 } else {
397 *self = ParameterValue::FloatValue(fidl::new_empty!(f64, D));
399 }
400 #[allow(irrefutable_let_patterns)]
401 if let ParameterValue::FloatValue(ref mut val) = self {
402 fidl::decode!(f64, D, val, decoder, _inner_offset, depth)?;
403 } else {
404 unreachable!()
405 }
406 }
407 2 => {
408 #[allow(irrefutable_let_patterns)]
409 if let ParameterValue::IntValue(_) = self {
410 } else {
412 *self = ParameterValue::IntValue(fidl::new_empty!(i64, D));
414 }
415 #[allow(irrefutable_let_patterns)]
416 if let ParameterValue::IntValue(ref mut val) = self {
417 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
418 } else {
419 unreachable!()
420 }
421 }
422 3 => {
423 #[allow(irrefutable_let_patterns)]
424 if let ParameterValue::StringValue(_) = self {
425 } else {
427 *self = ParameterValue::StringValue(fidl::new_empty!(
429 fidl::encoding::BoundedString<2048>,
430 D
431 ));
432 }
433 #[allow(irrefutable_let_patterns)]
434 if let ParameterValue::StringValue(ref mut val) = self {
435 fidl::decode!(
436 fidl::encoding::BoundedString<2048>,
437 D,
438 val,
439 decoder,
440 _inner_offset,
441 depth
442 )?;
443 } else {
444 unreachable!()
445 }
446 }
447 #[allow(deprecated)]
448 ordinal => {
449 for _ in 0..num_handles {
450 decoder.drop_next_handle()?;
451 }
452 *self = ParameterValue::__SourceBreaking { unknown_ordinal: ordinal };
453 }
454 }
455 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
456 return Err(fidl::Error::InvalidNumBytesInEnvelope);
457 }
458 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
459 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
460 }
461 Ok(())
462 }
463 }
464}