fidl_fuchsia_power_suspend__common/
fidl_fuchsia_power_suspend__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
11/// A collection of statistics related to suspend/resume of the device.
12#[derive(Clone, Debug, Default, PartialEq)]
13pub struct SuspendStats {
14    /// The number of times the device has successfully suspended.
15    pub success_count: Option<u64>,
16    /// The number of times the device has failed to suspend.
17    pub fail_count: Option<u64>,
18    /// The error code logged after the last failed suspend attempt.
19    pub last_failed_error: Option<i32>,
20    /// The amount of time spent in the previous suspend state.
21    /// May not be available on all platforms.
22    pub last_time_in_suspend: Option<i64>,
23    /// The amount of time spent performing suspend and resume operations for
24    /// the previous suspend state.
25    /// Suspend and resume operations are those actions taken by the platform in
26    /// order to enter and exit, respectively, a suspended state.
27    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            // Vector header
95            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            // Calling encoder.out_of_line_offset(0) is not allowed.
99            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
113            // are envelope_size bytes.
114            let cur_offset: usize = (1 - 1) * envelope_size;
115
116            // Zero reserved fields.
117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
118
119            // Safety:
120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
122            //   envelope_size bytes, there is always sufficient room.
123            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
136            // are envelope_size bytes.
137            let cur_offset: usize = (2 - 1) * envelope_size;
138
139            // Zero reserved fields.
140            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
141
142            // Safety:
143            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
144            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
145            //   envelope_size bytes, there is always sufficient room.
146            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
159            // are envelope_size bytes.
160            let cur_offset: usize = (3 - 1) * envelope_size;
161
162            // Zero reserved fields.
163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
164
165            // Safety:
166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
168            //   envelope_size bytes, there is always sufficient room.
169            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
184            // are envelope_size bytes.
185            let cur_offset: usize = (4 - 1) * envelope_size;
186
187            // Zero reserved fields.
188            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
189
190            // Safety:
191            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
192            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
193            //   envelope_size bytes, there is always sufficient room.
194            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
209            // are envelope_size bytes.
210            let cur_offset: usize = (5 - 1) * envelope_size;
211
212            // Zero reserved fields.
213            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
214
215            // Safety:
216            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
217            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
218            //   envelope_size bytes, there is always sufficient room.
219            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            // Calling decoder.out_of_line_offset(0) is not allowed.
252            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            // Decode the envelope for each type.
260            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            // Decode unknown envelopes for gaps in ordinals.
269            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            // Decode unknown envelopes for gaps in ordinals.
312            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            // Decode unknown envelopes for gaps in ordinals.
355            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            // Decode unknown envelopes for gaps in ordinals.
399            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            // Decode unknown envelopes for gaps in ordinals.
443            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            // Decode the remaining unknown envelopes.
484            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}