fidl_fuchsia_power_suspend__common/
fidl_fuchsia_power_suspend__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(Clone, Debug, Default, PartialEq)]
13pub struct SuspendStats {
14 pub success_count: Option<u64>,
16 pub fail_count: Option<u64>,
18 pub last_failed_error: Option<i32>,
20 pub last_time_in_suspend: Option<i64>,
23 pub last_time_in_suspend_operations: Option<i64>,
28 #[doc(hidden)]
29 pub __source_breaking: fidl::marker::SourceBreaking,
30}
31
32impl fidl::Persistable for SuspendStats {}
33
34pub mod stats_ordinals {
35 pub const WATCH: u64 = 0x1c90507c87636a84;
36}
37
38mod internal {
39 use super::*;
40
41 impl SuspendStats {
42 #[inline(always)]
43 fn max_ordinal_present(&self) -> u64 {
44 if let Some(_) = self.last_time_in_suspend_operations {
45 return 5;
46 }
47 if let Some(_) = self.last_time_in_suspend {
48 return 4;
49 }
50 if let Some(_) = self.last_failed_error {
51 return 3;
52 }
53 if let Some(_) = self.fail_count {
54 return 2;
55 }
56 if let Some(_) = self.success_count {
57 return 1;
58 }
59 0
60 }
61 }
62
63 impl fidl::encoding::ValueTypeMarker for SuspendStats {
64 type Borrowed<'a> = &'a Self;
65 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
66 value
67 }
68 }
69
70 unsafe impl fidl::encoding::TypeMarker for SuspendStats {
71 type Owned = Self;
72
73 #[inline(always)]
74 fn inline_align(_context: fidl::encoding::Context) -> usize {
75 8
76 }
77
78 #[inline(always)]
79 fn inline_size(_context: fidl::encoding::Context) -> usize {
80 16
81 }
82 }
83
84 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SuspendStats, D>
85 for &SuspendStats
86 {
87 unsafe fn encode(
88 self,
89 encoder: &mut fidl::encoding::Encoder<'_, D>,
90 offset: usize,
91 mut depth: fidl::encoding::Depth,
92 ) -> fidl::Result<()> {
93 encoder.debug_check_bounds::<SuspendStats>(offset);
94 let max_ordinal: u64 = self.max_ordinal_present();
96 encoder.write_num(max_ordinal, offset);
97 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
98 if max_ordinal == 0 {
100 return Ok(());
101 }
102 depth.increment()?;
103 let envelope_size = 8;
104 let bytes_len = max_ordinal as usize * envelope_size;
105 #[allow(unused_variables)]
106 let offset = encoder.out_of_line_offset(bytes_len);
107 let mut _prev_end_offset: usize = 0;
108 if 1 > max_ordinal {
109 return Ok(());
110 }
111
112 let cur_offset: usize = (1 - 1) * envelope_size;
115
116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
118
119 fidl::encoding::encode_in_envelope_optional::<u64, D>(
124 self.success_count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
125 encoder,
126 offset + cur_offset,
127 depth,
128 )?;
129
130 _prev_end_offset = cur_offset + envelope_size;
131 if 2 > max_ordinal {
132 return Ok(());
133 }
134
135 let cur_offset: usize = (2 - 1) * envelope_size;
138
139 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
141
142 fidl::encoding::encode_in_envelope_optional::<u64, D>(
147 self.fail_count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
148 encoder,
149 offset + cur_offset,
150 depth,
151 )?;
152
153 _prev_end_offset = cur_offset + envelope_size;
154 if 3 > max_ordinal {
155 return Ok(());
156 }
157
158 let cur_offset: usize = (3 - 1) * envelope_size;
161
162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
164
165 fidl::encoding::encode_in_envelope_optional::<i32, D>(
170 self.last_failed_error
171 .as_ref()
172 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
173 encoder,
174 offset + cur_offset,
175 depth,
176 )?;
177
178 _prev_end_offset = cur_offset + envelope_size;
179 if 4 > max_ordinal {
180 return Ok(());
181 }
182
183 let cur_offset: usize = (4 - 1) * envelope_size;
186
187 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
189
190 fidl::encoding::encode_in_envelope_optional::<i64, D>(
195 self.last_time_in_suspend
196 .as_ref()
197 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
198 encoder,
199 offset + cur_offset,
200 depth,
201 )?;
202
203 _prev_end_offset = cur_offset + envelope_size;
204 if 5 > max_ordinal {
205 return Ok(());
206 }
207
208 let cur_offset: usize = (5 - 1) * envelope_size;
211
212 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
214
215 fidl::encoding::encode_in_envelope_optional::<i64, D>(
220 self.last_time_in_suspend_operations
221 .as_ref()
222 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
223 encoder,
224 offset + cur_offset,
225 depth,
226 )?;
227
228 _prev_end_offset = cur_offset + envelope_size;
229
230 Ok(())
231 }
232 }
233
234 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendStats {
235 #[inline(always)]
236 fn new_empty() -> Self {
237 Self::default()
238 }
239
240 unsafe fn decode(
241 &mut self,
242 decoder: &mut fidl::encoding::Decoder<'_, D>,
243 offset: usize,
244 mut depth: fidl::encoding::Depth,
245 ) -> fidl::Result<()> {
246 decoder.debug_check_bounds::<Self>(offset);
247 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
248 None => return Err(fidl::Error::NotNullable),
249 Some(len) => len,
250 };
251 if len == 0 {
253 return Ok(());
254 };
255 depth.increment()?;
256 let envelope_size = 8;
257 let bytes_len = len * envelope_size;
258 let offset = decoder.out_of_line_offset(bytes_len)?;
259 let mut _next_ordinal_to_read = 0;
261 let mut next_offset = offset;
262 let end_offset = offset + bytes_len;
263 _next_ordinal_to_read += 1;
264 if next_offset >= end_offset {
265 return Ok(());
266 }
267
268 while _next_ordinal_to_read < 1 {
270 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
271 _next_ordinal_to_read += 1;
272 next_offset += envelope_size;
273 }
274
275 let next_out_of_line = decoder.next_out_of_line();
276 let handles_before = decoder.remaining_handles();
277 if let Some((inlined, num_bytes, num_handles)) =
278 fidl::encoding::decode_envelope_header(decoder, next_offset)?
279 {
280 let member_inline_size =
281 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
282 if inlined != (member_inline_size <= 4) {
283 return Err(fidl::Error::InvalidInlineBitInEnvelope);
284 }
285 let inner_offset;
286 let mut inner_depth = depth.clone();
287 if inlined {
288 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
289 inner_offset = next_offset;
290 } else {
291 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
292 inner_depth.increment()?;
293 }
294 let val_ref = self.success_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
295 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
296 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
297 {
298 return Err(fidl::Error::InvalidNumBytesInEnvelope);
299 }
300 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
301 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
302 }
303 }
304
305 next_offset += envelope_size;
306 _next_ordinal_to_read += 1;
307 if next_offset >= end_offset {
308 return Ok(());
309 }
310
311 while _next_ordinal_to_read < 2 {
313 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
314 _next_ordinal_to_read += 1;
315 next_offset += envelope_size;
316 }
317
318 let next_out_of_line = decoder.next_out_of_line();
319 let handles_before = decoder.remaining_handles();
320 if let Some((inlined, num_bytes, num_handles)) =
321 fidl::encoding::decode_envelope_header(decoder, next_offset)?
322 {
323 let member_inline_size =
324 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
325 if inlined != (member_inline_size <= 4) {
326 return Err(fidl::Error::InvalidInlineBitInEnvelope);
327 }
328 let inner_offset;
329 let mut inner_depth = depth.clone();
330 if inlined {
331 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
332 inner_offset = next_offset;
333 } else {
334 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
335 inner_depth.increment()?;
336 }
337 let val_ref = self.fail_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
338 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
339 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
340 {
341 return Err(fidl::Error::InvalidNumBytesInEnvelope);
342 }
343 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
344 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
345 }
346 }
347
348 next_offset += envelope_size;
349 _next_ordinal_to_read += 1;
350 if next_offset >= end_offset {
351 return Ok(());
352 }
353
354 while _next_ordinal_to_read < 3 {
356 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
357 _next_ordinal_to_read += 1;
358 next_offset += envelope_size;
359 }
360
361 let next_out_of_line = decoder.next_out_of_line();
362 let handles_before = decoder.remaining_handles();
363 if let Some((inlined, num_bytes, num_handles)) =
364 fidl::encoding::decode_envelope_header(decoder, next_offset)?
365 {
366 let member_inline_size =
367 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
368 if inlined != (member_inline_size <= 4) {
369 return Err(fidl::Error::InvalidInlineBitInEnvelope);
370 }
371 let inner_offset;
372 let mut inner_depth = depth.clone();
373 if inlined {
374 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
375 inner_offset = next_offset;
376 } else {
377 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
378 inner_depth.increment()?;
379 }
380 let val_ref =
381 self.last_failed_error.get_or_insert_with(|| fidl::new_empty!(i32, D));
382 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
383 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
384 {
385 return Err(fidl::Error::InvalidNumBytesInEnvelope);
386 }
387 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
388 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
389 }
390 }
391
392 next_offset += envelope_size;
393 _next_ordinal_to_read += 1;
394 if next_offset >= end_offset {
395 return Ok(());
396 }
397
398 while _next_ordinal_to_read < 4 {
400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
401 _next_ordinal_to_read += 1;
402 next_offset += envelope_size;
403 }
404
405 let next_out_of_line = decoder.next_out_of_line();
406 let handles_before = decoder.remaining_handles();
407 if let Some((inlined, num_bytes, num_handles)) =
408 fidl::encoding::decode_envelope_header(decoder, next_offset)?
409 {
410 let member_inline_size =
411 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
412 if inlined != (member_inline_size <= 4) {
413 return Err(fidl::Error::InvalidInlineBitInEnvelope);
414 }
415 let inner_offset;
416 let mut inner_depth = depth.clone();
417 if inlined {
418 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
419 inner_offset = next_offset;
420 } else {
421 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
422 inner_depth.increment()?;
423 }
424 let val_ref =
425 self.last_time_in_suspend.get_or_insert_with(|| fidl::new_empty!(i64, D));
426 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
427 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
428 {
429 return Err(fidl::Error::InvalidNumBytesInEnvelope);
430 }
431 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
432 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
433 }
434 }
435
436 next_offset += envelope_size;
437 _next_ordinal_to_read += 1;
438 if next_offset >= end_offset {
439 return Ok(());
440 }
441
442 while _next_ordinal_to_read < 5 {
444 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
445 _next_ordinal_to_read += 1;
446 next_offset += envelope_size;
447 }
448
449 let next_out_of_line = decoder.next_out_of_line();
450 let handles_before = decoder.remaining_handles();
451 if let Some((inlined, num_bytes, num_handles)) =
452 fidl::encoding::decode_envelope_header(decoder, next_offset)?
453 {
454 let member_inline_size =
455 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
456 if inlined != (member_inline_size <= 4) {
457 return Err(fidl::Error::InvalidInlineBitInEnvelope);
458 }
459 let inner_offset;
460 let mut inner_depth = depth.clone();
461 if inlined {
462 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
463 inner_offset = next_offset;
464 } else {
465 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
466 inner_depth.increment()?;
467 }
468 let val_ref = self
469 .last_time_in_suspend_operations
470 .get_or_insert_with(|| fidl::new_empty!(i64, D));
471 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
472 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
473 {
474 return Err(fidl::Error::InvalidNumBytesInEnvelope);
475 }
476 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
477 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
478 }
479 }
480
481 next_offset += envelope_size;
482
483 while next_offset < end_offset {
485 _next_ordinal_to_read += 1;
486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
487 next_offset += envelope_size;
488 }
489
490 Ok(())
491 }
492 }
493}