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