fidl_fuchsia_scheduler__common/
fidl_fuchsia_scheduler__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
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/// Pattern that matches an unknown `ParameterValue` member.
49#[macro_export]
50macro_rules! ParameterValueUnknown {
51    () => {
52        _
53    };
54}
55
56// Custom PartialEq so that unknown variants are not equal to themselves.
57impl 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            // Delegate to tuple encoding.
135            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            // Zero out padding regions. There's no need to apply masks
163            // because the unmasked parts will be overwritten by fields.
164            // Write the fields.
165            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            // Verify that padding bytes are zero.
189            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            // Delegate to tuple encoding.
233            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            // Zero out padding regions. There's no need to apply masks
257            // because the unmasked parts will be overwritten by fields.
258            // Write the fields.
259            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            // Verify that padding bytes are zero.
279            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                        // Do nothing, read the value into the object
396                    } else {
397                        // Initialize `self` to the right variant
398                        *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                        // Do nothing, read the value into the object
411                    } else {
412                        // Initialize `self` to the right variant
413                        *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                        // Do nothing, read the value into the object
426                    } else {
427                        // Initialize `self` to the right variant
428                        *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}