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 {}
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#[macro_export]
47macro_rules! ParameterValueUnknown {
48 () => {
49 _
50 };
51}
52
53impl 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 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 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 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 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 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 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 } else {
394 *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 } else {
409 *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 } else {
424 *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}