fidl_fuchsia_hardware_power_suspend__common/
fidl_fuchsia_hardware_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/// Maximum number of suspend states supported by the system.
12pub const MAX_SUSPEND_STATES: u32 = 256;
13
14#[derive(Clone, Debug, Default, PartialEq)]
15pub struct SuspendState {
16    /// The amount of time taken for the system to resume from this
17    /// suspend state.
18    pub resume_latency: Option<i64>,
19    #[doc(hidden)]
20    pub __source_breaking: fidl::marker::SourceBreaking,
21}
22
23impl fidl::Persistable for SuspendState {}
24
25#[derive(Clone, Debug, Default, PartialEq)]
26pub struct SuspenderSuspendRequest {
27    /// This index corresponds to an entry in the vector returned by
28    /// GetSuspendStates. Returns ZX_ERR_OUT_OF_RANGE if `state_index` is
29    /// greater than the number of supported suspend states. Returns
30    /// ZX_ERR_INVALID_ARGS if this field is unset.
31    pub state_index: Option<u64>,
32    #[doc(hidden)]
33    pub __source_breaking: fidl::marker::SourceBreaking,
34}
35
36impl fidl::Persistable for SuspenderSuspendRequest {}
37
38#[derive(Clone, Debug, Default, PartialEq)]
39pub struct SuspenderGetSuspendStatesResponse {
40    pub suspend_states: Option<Vec<SuspendState>>,
41    #[doc(hidden)]
42    pub __source_breaking: fidl::marker::SourceBreaking,
43}
44
45impl fidl::Persistable for SuspenderGetSuspendStatesResponse {}
46
47#[derive(Clone, Debug, Default, PartialEq)]
48pub struct SuspenderSuspendResponse {
49    /// The `WakeReason` that caused the system to resume.
50    /// See `type WakeReason` above for more details about wake reasons.
51    pub reason: Option<WakeReason>,
52    /// The amount of time the system spent suspended. If the system is
53    /// interrupted during suspend this field is unset.
54    pub suspend_duration: Option<i64>,
55    /// The amount of time it took for the system to suspend and resume not
56    /// including the duration that the system was suspended.
57    pub suspend_overhead: Option<i64>,
58    #[doc(hidden)]
59    pub __source_breaking: fidl::marker::SourceBreaking,
60}
61
62impl fidl::Persistable for SuspenderSuspendResponse {}
63
64#[derive(Clone, Debug, Default, PartialEq)]
65pub struct WakeReason {
66    /// A list of platform defined integers, each of which corresponds to
67    /// a physical interrupt vector on the system. The simplest such mapping
68    /// would be to map each interrupt number to a wake vector.
69    pub wake_vectors: Option<Vec<u64>>,
70    /// A list of platform defined integers, each of which corresponds to
71    /// a wake vector that is *not* backed by a hardware interrupt.
72    pub soft_wake_vectors: Option<Vec<u64>>,
73    #[doc(hidden)]
74    pub __source_breaking: fidl::marker::SourceBreaking,
75}
76
77impl fidl::Persistable for WakeReason {}
78
79pub mod suspender_ordinals {
80    pub const GET_SUSPEND_STATES: u64 = 0xa3fc4a1101bcbe1;
81    pub const SUSPEND: u64 = 0x5d8bb5e292987c8a;
82}
83
84mod internal {
85    use super::*;
86
87    impl SuspendState {
88        #[inline(always)]
89        fn max_ordinal_present(&self) -> u64 {
90            if let Some(_) = self.resume_latency {
91                return 1;
92            }
93            0
94        }
95    }
96
97    impl fidl::encoding::ValueTypeMarker for SuspendState {
98        type Borrowed<'a> = &'a Self;
99        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
100            value
101        }
102    }
103
104    unsafe impl fidl::encoding::TypeMarker for SuspendState {
105        type Owned = Self;
106
107        #[inline(always)]
108        fn inline_align(_context: fidl::encoding::Context) -> usize {
109            8
110        }
111
112        #[inline(always)]
113        fn inline_size(_context: fidl::encoding::Context) -> usize {
114            16
115        }
116    }
117
118    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SuspendState, D>
119        for &SuspendState
120    {
121        unsafe fn encode(
122            self,
123            encoder: &mut fidl::encoding::Encoder<'_, D>,
124            offset: usize,
125            mut depth: fidl::encoding::Depth,
126        ) -> fidl::Result<()> {
127            encoder.debug_check_bounds::<SuspendState>(offset);
128            // Vector header
129            let max_ordinal: u64 = self.max_ordinal_present();
130            encoder.write_num(max_ordinal, offset);
131            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
132            // Calling encoder.out_of_line_offset(0) is not allowed.
133            if max_ordinal == 0 {
134                return Ok(());
135            }
136            depth.increment()?;
137            let envelope_size = 8;
138            let bytes_len = max_ordinal as usize * envelope_size;
139            #[allow(unused_variables)]
140            let offset = encoder.out_of_line_offset(bytes_len);
141            let mut _prev_end_offset: usize = 0;
142            if 1 > max_ordinal {
143                return Ok(());
144            }
145
146            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
147            // are envelope_size bytes.
148            let cur_offset: usize = (1 - 1) * envelope_size;
149
150            // Zero reserved fields.
151            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
152
153            // Safety:
154            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
155            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
156            //   envelope_size bytes, there is always sufficient room.
157            fidl::encoding::encode_in_envelope_optional::<i64, D>(
158                self.resume_latency.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
159                encoder,
160                offset + cur_offset,
161                depth,
162            )?;
163
164            _prev_end_offset = cur_offset + envelope_size;
165
166            Ok(())
167        }
168    }
169
170    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendState {
171        #[inline(always)]
172        fn new_empty() -> Self {
173            Self::default()
174        }
175
176        unsafe fn decode(
177            &mut self,
178            decoder: &mut fidl::encoding::Decoder<'_, D>,
179            offset: usize,
180            mut depth: fidl::encoding::Depth,
181        ) -> fidl::Result<()> {
182            decoder.debug_check_bounds::<Self>(offset);
183            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
184                None => return Err(fidl::Error::NotNullable),
185                Some(len) => len,
186            };
187            // Calling decoder.out_of_line_offset(0) is not allowed.
188            if len == 0 {
189                return Ok(());
190            };
191            depth.increment()?;
192            let envelope_size = 8;
193            let bytes_len = len * envelope_size;
194            let offset = decoder.out_of_line_offset(bytes_len)?;
195            // Decode the envelope for each type.
196            let mut _next_ordinal_to_read = 0;
197            let mut next_offset = offset;
198            let end_offset = offset + bytes_len;
199            _next_ordinal_to_read += 1;
200            if next_offset >= end_offset {
201                return Ok(());
202            }
203
204            // Decode unknown envelopes for gaps in ordinals.
205            while _next_ordinal_to_read < 1 {
206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
207                _next_ordinal_to_read += 1;
208                next_offset += envelope_size;
209            }
210
211            let next_out_of_line = decoder.next_out_of_line();
212            let handles_before = decoder.remaining_handles();
213            if let Some((inlined, num_bytes, num_handles)) =
214                fidl::encoding::decode_envelope_header(decoder, next_offset)?
215            {
216                let member_inline_size =
217                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
218                if inlined != (member_inline_size <= 4) {
219                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
220                }
221                let inner_offset;
222                let mut inner_depth = depth.clone();
223                if inlined {
224                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
225                    inner_offset = next_offset;
226                } else {
227                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
228                    inner_depth.increment()?;
229                }
230                let val_ref = self.resume_latency.get_or_insert_with(|| fidl::new_empty!(i64, D));
231                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
232                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
233                {
234                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
235                }
236                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
237                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
238                }
239            }
240
241            next_offset += envelope_size;
242
243            // Decode the remaining unknown envelopes.
244            while next_offset < end_offset {
245                _next_ordinal_to_read += 1;
246                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
247                next_offset += envelope_size;
248            }
249
250            Ok(())
251        }
252    }
253
254    impl SuspenderSuspendRequest {
255        #[inline(always)]
256        fn max_ordinal_present(&self) -> u64 {
257            if let Some(_) = self.state_index {
258                return 1;
259            }
260            0
261        }
262    }
263
264    impl fidl::encoding::ValueTypeMarker for SuspenderSuspendRequest {
265        type Borrowed<'a> = &'a Self;
266        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
267            value
268        }
269    }
270
271    unsafe impl fidl::encoding::TypeMarker for SuspenderSuspendRequest {
272        type Owned = Self;
273
274        #[inline(always)]
275        fn inline_align(_context: fidl::encoding::Context) -> usize {
276            8
277        }
278
279        #[inline(always)]
280        fn inline_size(_context: fidl::encoding::Context) -> usize {
281            16
282        }
283    }
284
285    unsafe impl<D: fidl::encoding::ResourceDialect>
286        fidl::encoding::Encode<SuspenderSuspendRequest, D> for &SuspenderSuspendRequest
287    {
288        unsafe fn encode(
289            self,
290            encoder: &mut fidl::encoding::Encoder<'_, D>,
291            offset: usize,
292            mut depth: fidl::encoding::Depth,
293        ) -> fidl::Result<()> {
294            encoder.debug_check_bounds::<SuspenderSuspendRequest>(offset);
295            // Vector header
296            let max_ordinal: u64 = self.max_ordinal_present();
297            encoder.write_num(max_ordinal, offset);
298            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
299            // Calling encoder.out_of_line_offset(0) is not allowed.
300            if max_ordinal == 0 {
301                return Ok(());
302            }
303            depth.increment()?;
304            let envelope_size = 8;
305            let bytes_len = max_ordinal as usize * envelope_size;
306            #[allow(unused_variables)]
307            let offset = encoder.out_of_line_offset(bytes_len);
308            let mut _prev_end_offset: usize = 0;
309            if 1 > max_ordinal {
310                return Ok(());
311            }
312
313            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
314            // are envelope_size bytes.
315            let cur_offset: usize = (1 - 1) * envelope_size;
316
317            // Zero reserved fields.
318            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
319
320            // Safety:
321            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
322            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
323            //   envelope_size bytes, there is always sufficient room.
324            fidl::encoding::encode_in_envelope_optional::<u64, D>(
325                self.state_index.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
326                encoder,
327                offset + cur_offset,
328                depth,
329            )?;
330
331            _prev_end_offset = cur_offset + envelope_size;
332
333            Ok(())
334        }
335    }
336
337    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
338        for SuspenderSuspendRequest
339    {
340        #[inline(always)]
341        fn new_empty() -> Self {
342            Self::default()
343        }
344
345        unsafe fn decode(
346            &mut self,
347            decoder: &mut fidl::encoding::Decoder<'_, D>,
348            offset: usize,
349            mut depth: fidl::encoding::Depth,
350        ) -> fidl::Result<()> {
351            decoder.debug_check_bounds::<Self>(offset);
352            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
353                None => return Err(fidl::Error::NotNullable),
354                Some(len) => len,
355            };
356            // Calling decoder.out_of_line_offset(0) is not allowed.
357            if len == 0 {
358                return Ok(());
359            };
360            depth.increment()?;
361            let envelope_size = 8;
362            let bytes_len = len * envelope_size;
363            let offset = decoder.out_of_line_offset(bytes_len)?;
364            // Decode the envelope for each type.
365            let mut _next_ordinal_to_read = 0;
366            let mut next_offset = offset;
367            let end_offset = offset + bytes_len;
368            _next_ordinal_to_read += 1;
369            if next_offset >= end_offset {
370                return Ok(());
371            }
372
373            // Decode unknown envelopes for gaps in ordinals.
374            while _next_ordinal_to_read < 1 {
375                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
376                _next_ordinal_to_read += 1;
377                next_offset += envelope_size;
378            }
379
380            let next_out_of_line = decoder.next_out_of_line();
381            let handles_before = decoder.remaining_handles();
382            if let Some((inlined, num_bytes, num_handles)) =
383                fidl::encoding::decode_envelope_header(decoder, next_offset)?
384            {
385                let member_inline_size =
386                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
387                if inlined != (member_inline_size <= 4) {
388                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
389                }
390                let inner_offset;
391                let mut inner_depth = depth.clone();
392                if inlined {
393                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
394                    inner_offset = next_offset;
395                } else {
396                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
397                    inner_depth.increment()?;
398                }
399                let val_ref = self.state_index.get_or_insert_with(|| fidl::new_empty!(u64, D));
400                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
401                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
402                {
403                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
404                }
405                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
406                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
407                }
408            }
409
410            next_offset += envelope_size;
411
412            // Decode the remaining unknown envelopes.
413            while next_offset < end_offset {
414                _next_ordinal_to_read += 1;
415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
416                next_offset += envelope_size;
417            }
418
419            Ok(())
420        }
421    }
422
423    impl SuspenderGetSuspendStatesResponse {
424        #[inline(always)]
425        fn max_ordinal_present(&self) -> u64 {
426            if let Some(_) = self.suspend_states {
427                return 1;
428            }
429            0
430        }
431    }
432
433    impl fidl::encoding::ValueTypeMarker for SuspenderGetSuspendStatesResponse {
434        type Borrowed<'a> = &'a Self;
435        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
436            value
437        }
438    }
439
440    unsafe impl fidl::encoding::TypeMarker for SuspenderGetSuspendStatesResponse {
441        type Owned = Self;
442
443        #[inline(always)]
444        fn inline_align(_context: fidl::encoding::Context) -> usize {
445            8
446        }
447
448        #[inline(always)]
449        fn inline_size(_context: fidl::encoding::Context) -> usize {
450            16
451        }
452    }
453
454    unsafe impl<D: fidl::encoding::ResourceDialect>
455        fidl::encoding::Encode<SuspenderGetSuspendStatesResponse, D>
456        for &SuspenderGetSuspendStatesResponse
457    {
458        unsafe fn encode(
459            self,
460            encoder: &mut fidl::encoding::Encoder<'_, D>,
461            offset: usize,
462            mut depth: fidl::encoding::Depth,
463        ) -> fidl::Result<()> {
464            encoder.debug_check_bounds::<SuspenderGetSuspendStatesResponse>(offset);
465            // Vector header
466            let max_ordinal: u64 = self.max_ordinal_present();
467            encoder.write_num(max_ordinal, offset);
468            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
469            // Calling encoder.out_of_line_offset(0) is not allowed.
470            if max_ordinal == 0 {
471                return Ok(());
472            }
473            depth.increment()?;
474            let envelope_size = 8;
475            let bytes_len = max_ordinal as usize * envelope_size;
476            #[allow(unused_variables)]
477            let offset = encoder.out_of_line_offset(bytes_len);
478            let mut _prev_end_offset: usize = 0;
479            if 1 > max_ordinal {
480                return Ok(());
481            }
482
483            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
484            // are envelope_size bytes.
485            let cur_offset: usize = (1 - 1) * envelope_size;
486
487            // Zero reserved fields.
488            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
489
490            // Safety:
491            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
492            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
493            //   envelope_size bytes, there is always sufficient room.
494            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SuspendState, 256>, D>(
495            self.suspend_states.as_ref().map(<fidl::encoding::Vector<SuspendState, 256> as fidl::encoding::ValueTypeMarker>::borrow),
496            encoder, offset + cur_offset, depth
497        )?;
498
499            _prev_end_offset = cur_offset + envelope_size;
500
501            Ok(())
502        }
503    }
504
505    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
506        for SuspenderGetSuspendStatesResponse
507    {
508        #[inline(always)]
509        fn new_empty() -> Self {
510            Self::default()
511        }
512
513        unsafe fn decode(
514            &mut self,
515            decoder: &mut fidl::encoding::Decoder<'_, D>,
516            offset: usize,
517            mut depth: fidl::encoding::Depth,
518        ) -> fidl::Result<()> {
519            decoder.debug_check_bounds::<Self>(offset);
520            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
521                None => return Err(fidl::Error::NotNullable),
522                Some(len) => len,
523            };
524            // Calling decoder.out_of_line_offset(0) is not allowed.
525            if len == 0 {
526                return Ok(());
527            };
528            depth.increment()?;
529            let envelope_size = 8;
530            let bytes_len = len * envelope_size;
531            let offset = decoder.out_of_line_offset(bytes_len)?;
532            // Decode the envelope for each type.
533            let mut _next_ordinal_to_read = 0;
534            let mut next_offset = offset;
535            let end_offset = offset + bytes_len;
536            _next_ordinal_to_read += 1;
537            if next_offset >= end_offset {
538                return Ok(());
539            }
540
541            // Decode unknown envelopes for gaps in ordinals.
542            while _next_ordinal_to_read < 1 {
543                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
544                _next_ordinal_to_read += 1;
545                next_offset += envelope_size;
546            }
547
548            let next_out_of_line = decoder.next_out_of_line();
549            let handles_before = decoder.remaining_handles();
550            if let Some((inlined, num_bytes, num_handles)) =
551                fidl::encoding::decode_envelope_header(decoder, next_offset)?
552            {
553                let member_inline_size = <fidl::encoding::Vector<SuspendState, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
554                if inlined != (member_inline_size <= 4) {
555                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
556                }
557                let inner_offset;
558                let mut inner_depth = depth.clone();
559                if inlined {
560                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
561                    inner_offset = next_offset;
562                } else {
563                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
564                    inner_depth.increment()?;
565                }
566                let val_ref = self.suspend_states.get_or_insert_with(
567                    || fidl::new_empty!(fidl::encoding::Vector<SuspendState, 256>, D),
568                );
569                fidl::decode!(fidl::encoding::Vector<SuspendState, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
570                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
571                {
572                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
573                }
574                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
575                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
576                }
577            }
578
579            next_offset += envelope_size;
580
581            // Decode the remaining unknown envelopes.
582            while next_offset < end_offset {
583                _next_ordinal_to_read += 1;
584                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
585                next_offset += envelope_size;
586            }
587
588            Ok(())
589        }
590    }
591
592    impl SuspenderSuspendResponse {
593        #[inline(always)]
594        fn max_ordinal_present(&self) -> u64 {
595            if let Some(_) = self.suspend_overhead {
596                return 3;
597            }
598            if let Some(_) = self.suspend_duration {
599                return 2;
600            }
601            if let Some(_) = self.reason {
602                return 1;
603            }
604            0
605        }
606    }
607
608    impl fidl::encoding::ValueTypeMarker for SuspenderSuspendResponse {
609        type Borrowed<'a> = &'a Self;
610        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
611            value
612        }
613    }
614
615    unsafe impl fidl::encoding::TypeMarker for SuspenderSuspendResponse {
616        type Owned = Self;
617
618        #[inline(always)]
619        fn inline_align(_context: fidl::encoding::Context) -> usize {
620            8
621        }
622
623        #[inline(always)]
624        fn inline_size(_context: fidl::encoding::Context) -> usize {
625            16
626        }
627    }
628
629    unsafe impl<D: fidl::encoding::ResourceDialect>
630        fidl::encoding::Encode<SuspenderSuspendResponse, D> for &SuspenderSuspendResponse
631    {
632        unsafe fn encode(
633            self,
634            encoder: &mut fidl::encoding::Encoder<'_, D>,
635            offset: usize,
636            mut depth: fidl::encoding::Depth,
637        ) -> fidl::Result<()> {
638            encoder.debug_check_bounds::<SuspenderSuspendResponse>(offset);
639            // Vector header
640            let max_ordinal: u64 = self.max_ordinal_present();
641            encoder.write_num(max_ordinal, offset);
642            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
643            // Calling encoder.out_of_line_offset(0) is not allowed.
644            if max_ordinal == 0 {
645                return Ok(());
646            }
647            depth.increment()?;
648            let envelope_size = 8;
649            let bytes_len = max_ordinal as usize * envelope_size;
650            #[allow(unused_variables)]
651            let offset = encoder.out_of_line_offset(bytes_len);
652            let mut _prev_end_offset: usize = 0;
653            if 1 > max_ordinal {
654                return Ok(());
655            }
656
657            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
658            // are envelope_size bytes.
659            let cur_offset: usize = (1 - 1) * envelope_size;
660
661            // Zero reserved fields.
662            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
663
664            // Safety:
665            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
666            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
667            //   envelope_size bytes, there is always sufficient room.
668            fidl::encoding::encode_in_envelope_optional::<WakeReason, D>(
669                self.reason.as_ref().map(<WakeReason as fidl::encoding::ValueTypeMarker>::borrow),
670                encoder,
671                offset + cur_offset,
672                depth,
673            )?;
674
675            _prev_end_offset = cur_offset + envelope_size;
676            if 2 > max_ordinal {
677                return Ok(());
678            }
679
680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
681            // are envelope_size bytes.
682            let cur_offset: usize = (2 - 1) * envelope_size;
683
684            // Zero reserved fields.
685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
686
687            // Safety:
688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
690            //   envelope_size bytes, there is always sufficient room.
691            fidl::encoding::encode_in_envelope_optional::<i64, D>(
692                self.suspend_duration
693                    .as_ref()
694                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
695                encoder,
696                offset + cur_offset,
697                depth,
698            )?;
699
700            _prev_end_offset = cur_offset + envelope_size;
701            if 3 > max_ordinal {
702                return Ok(());
703            }
704
705            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
706            // are envelope_size bytes.
707            let cur_offset: usize = (3 - 1) * envelope_size;
708
709            // Zero reserved fields.
710            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
711
712            // Safety:
713            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
714            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
715            //   envelope_size bytes, there is always sufficient room.
716            fidl::encoding::encode_in_envelope_optional::<i64, D>(
717                self.suspend_overhead
718                    .as_ref()
719                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
720                encoder,
721                offset + cur_offset,
722                depth,
723            )?;
724
725            _prev_end_offset = cur_offset + envelope_size;
726
727            Ok(())
728        }
729    }
730
731    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
732        for SuspenderSuspendResponse
733    {
734        #[inline(always)]
735        fn new_empty() -> Self {
736            Self::default()
737        }
738
739        unsafe fn decode(
740            &mut self,
741            decoder: &mut fidl::encoding::Decoder<'_, D>,
742            offset: usize,
743            mut depth: fidl::encoding::Depth,
744        ) -> fidl::Result<()> {
745            decoder.debug_check_bounds::<Self>(offset);
746            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
747                None => return Err(fidl::Error::NotNullable),
748                Some(len) => len,
749            };
750            // Calling decoder.out_of_line_offset(0) is not allowed.
751            if len == 0 {
752                return Ok(());
753            };
754            depth.increment()?;
755            let envelope_size = 8;
756            let bytes_len = len * envelope_size;
757            let offset = decoder.out_of_line_offset(bytes_len)?;
758            // Decode the envelope for each type.
759            let mut _next_ordinal_to_read = 0;
760            let mut next_offset = offset;
761            let end_offset = offset + bytes_len;
762            _next_ordinal_to_read += 1;
763            if next_offset >= end_offset {
764                return Ok(());
765            }
766
767            // Decode unknown envelopes for gaps in ordinals.
768            while _next_ordinal_to_read < 1 {
769                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
770                _next_ordinal_to_read += 1;
771                next_offset += envelope_size;
772            }
773
774            let next_out_of_line = decoder.next_out_of_line();
775            let handles_before = decoder.remaining_handles();
776            if let Some((inlined, num_bytes, num_handles)) =
777                fidl::encoding::decode_envelope_header(decoder, next_offset)?
778            {
779                let member_inline_size =
780                    <WakeReason as fidl::encoding::TypeMarker>::inline_size(decoder.context);
781                if inlined != (member_inline_size <= 4) {
782                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
783                }
784                let inner_offset;
785                let mut inner_depth = depth.clone();
786                if inlined {
787                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
788                    inner_offset = next_offset;
789                } else {
790                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
791                    inner_depth.increment()?;
792                }
793                let val_ref = self.reason.get_or_insert_with(|| fidl::new_empty!(WakeReason, D));
794                fidl::decode!(WakeReason, D, val_ref, decoder, inner_offset, inner_depth)?;
795                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
796                {
797                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
798                }
799                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
800                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
801                }
802            }
803
804            next_offset += envelope_size;
805            _next_ordinal_to_read += 1;
806            if next_offset >= end_offset {
807                return Ok(());
808            }
809
810            // Decode unknown envelopes for gaps in ordinals.
811            while _next_ordinal_to_read < 2 {
812                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
813                _next_ordinal_to_read += 1;
814                next_offset += envelope_size;
815            }
816
817            let next_out_of_line = decoder.next_out_of_line();
818            let handles_before = decoder.remaining_handles();
819            if let Some((inlined, num_bytes, num_handles)) =
820                fidl::encoding::decode_envelope_header(decoder, next_offset)?
821            {
822                let member_inline_size =
823                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
824                if inlined != (member_inline_size <= 4) {
825                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
826                }
827                let inner_offset;
828                let mut inner_depth = depth.clone();
829                if inlined {
830                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
831                    inner_offset = next_offset;
832                } else {
833                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
834                    inner_depth.increment()?;
835                }
836                let val_ref = self.suspend_duration.get_or_insert_with(|| fidl::new_empty!(i64, D));
837                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
838                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
839                {
840                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
841                }
842                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
843                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
844                }
845            }
846
847            next_offset += envelope_size;
848            _next_ordinal_to_read += 1;
849            if next_offset >= end_offset {
850                return Ok(());
851            }
852
853            // Decode unknown envelopes for gaps in ordinals.
854            while _next_ordinal_to_read < 3 {
855                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
856                _next_ordinal_to_read += 1;
857                next_offset += envelope_size;
858            }
859
860            let next_out_of_line = decoder.next_out_of_line();
861            let handles_before = decoder.remaining_handles();
862            if let Some((inlined, num_bytes, num_handles)) =
863                fidl::encoding::decode_envelope_header(decoder, next_offset)?
864            {
865                let member_inline_size =
866                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
867                if inlined != (member_inline_size <= 4) {
868                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
869                }
870                let inner_offset;
871                let mut inner_depth = depth.clone();
872                if inlined {
873                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
874                    inner_offset = next_offset;
875                } else {
876                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
877                    inner_depth.increment()?;
878                }
879                let val_ref = self.suspend_overhead.get_or_insert_with(|| fidl::new_empty!(i64, D));
880                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
881                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
882                {
883                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
884                }
885                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
886                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
887                }
888            }
889
890            next_offset += envelope_size;
891
892            // Decode the remaining unknown envelopes.
893            while next_offset < end_offset {
894                _next_ordinal_to_read += 1;
895                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
896                next_offset += envelope_size;
897            }
898
899            Ok(())
900        }
901    }
902
903    impl WakeReason {
904        #[inline(always)]
905        fn max_ordinal_present(&self) -> u64 {
906            if let Some(_) = self.soft_wake_vectors {
907                return 2;
908            }
909            if let Some(_) = self.wake_vectors {
910                return 1;
911            }
912            0
913        }
914    }
915
916    impl fidl::encoding::ValueTypeMarker for WakeReason {
917        type Borrowed<'a> = &'a Self;
918        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
919            value
920        }
921    }
922
923    unsafe impl fidl::encoding::TypeMarker for WakeReason {
924        type Owned = Self;
925
926        #[inline(always)]
927        fn inline_align(_context: fidl::encoding::Context) -> usize {
928            8
929        }
930
931        #[inline(always)]
932        fn inline_size(_context: fidl::encoding::Context) -> usize {
933            16
934        }
935    }
936
937    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WakeReason, D>
938        for &WakeReason
939    {
940        unsafe fn encode(
941            self,
942            encoder: &mut fidl::encoding::Encoder<'_, D>,
943            offset: usize,
944            mut depth: fidl::encoding::Depth,
945        ) -> fidl::Result<()> {
946            encoder.debug_check_bounds::<WakeReason>(offset);
947            // Vector header
948            let max_ordinal: u64 = self.max_ordinal_present();
949            encoder.write_num(max_ordinal, offset);
950            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
951            // Calling encoder.out_of_line_offset(0) is not allowed.
952            if max_ordinal == 0 {
953                return Ok(());
954            }
955            depth.increment()?;
956            let envelope_size = 8;
957            let bytes_len = max_ordinal as usize * envelope_size;
958            #[allow(unused_variables)]
959            let offset = encoder.out_of_line_offset(bytes_len);
960            let mut _prev_end_offset: usize = 0;
961            if 1 > max_ordinal {
962                return Ok(());
963            }
964
965            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
966            // are envelope_size bytes.
967            let cur_offset: usize = (1 - 1) * envelope_size;
968
969            // Zero reserved fields.
970            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
971
972            // Safety:
973            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
974            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
975            //   envelope_size bytes, there is always sufficient room.
976            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
977            self.wake_vectors.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
978            encoder, offset + cur_offset, depth
979        )?;
980
981            _prev_end_offset = cur_offset + envelope_size;
982            if 2 > max_ordinal {
983                return Ok(());
984            }
985
986            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
987            // are envelope_size bytes.
988            let cur_offset: usize = (2 - 1) * envelope_size;
989
990            // Zero reserved fields.
991            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
992
993            // Safety:
994            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
995            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
996            //   envelope_size bytes, there is always sufficient room.
997            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
998            self.soft_wake_vectors.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
999            encoder, offset + cur_offset, depth
1000        )?;
1001
1002            _prev_end_offset = cur_offset + envelope_size;
1003
1004            Ok(())
1005        }
1006    }
1007
1008    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WakeReason {
1009        #[inline(always)]
1010        fn new_empty() -> Self {
1011            Self::default()
1012        }
1013
1014        unsafe fn decode(
1015            &mut self,
1016            decoder: &mut fidl::encoding::Decoder<'_, D>,
1017            offset: usize,
1018            mut depth: fidl::encoding::Depth,
1019        ) -> fidl::Result<()> {
1020            decoder.debug_check_bounds::<Self>(offset);
1021            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1022                None => return Err(fidl::Error::NotNullable),
1023                Some(len) => len,
1024            };
1025            // Calling decoder.out_of_line_offset(0) is not allowed.
1026            if len == 0 {
1027                return Ok(());
1028            };
1029            depth.increment()?;
1030            let envelope_size = 8;
1031            let bytes_len = len * envelope_size;
1032            let offset = decoder.out_of_line_offset(bytes_len)?;
1033            // Decode the envelope for each type.
1034            let mut _next_ordinal_to_read = 0;
1035            let mut next_offset = offset;
1036            let end_offset = offset + bytes_len;
1037            _next_ordinal_to_read += 1;
1038            if next_offset >= end_offset {
1039                return Ok(());
1040            }
1041
1042            // Decode unknown envelopes for gaps in ordinals.
1043            while _next_ordinal_to_read < 1 {
1044                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1045                _next_ordinal_to_read += 1;
1046                next_offset += envelope_size;
1047            }
1048
1049            let next_out_of_line = decoder.next_out_of_line();
1050            let handles_before = decoder.remaining_handles();
1051            if let Some((inlined, num_bytes, num_handles)) =
1052                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1053            {
1054                let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1055                if inlined != (member_inline_size <= 4) {
1056                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1057                }
1058                let inner_offset;
1059                let mut inner_depth = depth.clone();
1060                if inlined {
1061                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1062                    inner_offset = next_offset;
1063                } else {
1064                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1065                    inner_depth.increment()?;
1066                }
1067                let val_ref = self.wake_vectors.get_or_insert_with(|| {
1068                    fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1069                });
1070                fidl::decode!(
1071                    fidl::encoding::UnboundedVector<u64>,
1072                    D,
1073                    val_ref,
1074                    decoder,
1075                    inner_offset,
1076                    inner_depth
1077                )?;
1078                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1079                {
1080                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1081                }
1082                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1083                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1084                }
1085            }
1086
1087            next_offset += envelope_size;
1088            _next_ordinal_to_read += 1;
1089            if next_offset >= end_offset {
1090                return Ok(());
1091            }
1092
1093            // Decode unknown envelopes for gaps in ordinals.
1094            while _next_ordinal_to_read < 2 {
1095                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1096                _next_ordinal_to_read += 1;
1097                next_offset += envelope_size;
1098            }
1099
1100            let next_out_of_line = decoder.next_out_of_line();
1101            let handles_before = decoder.remaining_handles();
1102            if let Some((inlined, num_bytes, num_handles)) =
1103                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1104            {
1105                let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1106                if inlined != (member_inline_size <= 4) {
1107                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1108                }
1109                let inner_offset;
1110                let mut inner_depth = depth.clone();
1111                if inlined {
1112                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1113                    inner_offset = next_offset;
1114                } else {
1115                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1116                    inner_depth.increment()?;
1117                }
1118                let val_ref = self.soft_wake_vectors.get_or_insert_with(|| {
1119                    fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1120                });
1121                fidl::decode!(
1122                    fidl::encoding::UnboundedVector<u64>,
1123                    D,
1124                    val_ref,
1125                    decoder,
1126                    inner_offset,
1127                    inner_depth
1128                )?;
1129                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1130                {
1131                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1132                }
1133                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1134                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1135                }
1136            }
1137
1138            next_offset += envelope_size;
1139
1140            // Decode the remaining unknown envelopes.
1141            while next_offset < end_offset {
1142                _next_ordinal_to_read += 1;
1143                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1144                next_offset += envelope_size;
1145            }
1146
1147            Ok(())
1148        }
1149    }
1150}