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_SUSPEND_STATES: u32 = 256;
13
14#[derive(Clone, Debug, Default, PartialEq)]
15pub struct SuspendState {
16 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 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 pub reason: Option<WakeReason>,
52 pub suspend_duration: Option<i64>,
55 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 pub wake_vectors: Option<Vec<u64>>,
70 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
149
150 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
152
153 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
316
317 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
319
320 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
486
487 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
489
490 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
660
661 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
663
664 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 let cur_offset: usize = (2 - 1) * envelope_size;
683
684 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
686
687 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 let cur_offset: usize = (3 - 1) * envelope_size;
708
709 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
711
712 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
968
969 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
971
972 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 let cur_offset: usize = (2 - 1) * envelope_size;
989
990 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
992
993 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 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 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 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 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 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}