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
11#[derive(Clone, Debug, Default, PartialEq)]
12pub struct DeviceSetSuspendStatesRequest {
13 pub suspend_states: Option<Vec<fidl_fuchsia_hardware_power_suspend__common::SuspendState>>,
14 #[doc(hidden)]
15 pub __source_breaking: fidl::marker::SourceBreaking,
16}
17
18impl fidl::Persistable for DeviceSetSuspendStatesRequest {}
19
20#[derive(Clone, Debug, Default, PartialEq)]
21pub struct DeviceAwaitSuspendResponse {
22 pub state_index: Option<u64>,
23 #[doc(hidden)]
24 pub __source_breaking: fidl::marker::SourceBreaking,
25}
26
27impl fidl::Persistable for DeviceAwaitSuspendResponse {}
28
29#[derive(Clone, Debug, Default, PartialEq)]
30pub struct SuspendResult {
31 pub reason: Option<fidl_fuchsia_hardware_power_suspend__common::WakeReason>,
32 pub suspend_duration: Option<i64>,
33 pub suspend_overhead: Option<i64>,
34 #[doc(hidden)]
35 pub __source_breaking: fidl::marker::SourceBreaking,
36}
37
38impl fidl::Persistable for SuspendResult {}
39
40#[derive(Clone, Debug)]
41pub enum DeviceResumeRequest {
42 Result(SuspendResult),
43 Error(i32),
44 #[doc(hidden)]
45 __SourceBreaking {
46 unknown_ordinal: u64,
47 },
48}
49
50#[macro_export]
52macro_rules! DeviceResumeRequestUnknown {
53 () => {
54 _
55 };
56}
57
58impl PartialEq for DeviceResumeRequest {
60 fn eq(&self, other: &Self) -> bool {
61 match (self, other) {
62 (Self::Result(x), Self::Result(y)) => *x == *y,
63 (Self::Error(x), Self::Error(y)) => *x == *y,
64 _ => false,
65 }
66 }
67}
68
69impl DeviceResumeRequest {
70 #[inline]
71 pub fn ordinal(&self) -> u64 {
72 match *self {
73 Self::Result(_) => 1,
74 Self::Error(_) => 2,
75 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
76 }
77 }
78
79 #[inline]
80 pub fn unknown_variant_for_testing() -> Self {
81 Self::__SourceBreaking { unknown_ordinal: 0 }
82 }
83
84 #[inline]
85 pub fn is_unknown(&self) -> bool {
86 match self {
87 Self::__SourceBreaking { .. } => true,
88 _ => false,
89 }
90 }
91}
92
93impl fidl::Persistable for DeviceResumeRequest {}
94
95mod internal {
96 use super::*;
97
98 impl DeviceSetSuspendStatesRequest {
99 #[inline(always)]
100 fn max_ordinal_present(&self) -> u64 {
101 if let Some(_) = self.suspend_states {
102 return 1;
103 }
104 0
105 }
106 }
107
108 impl fidl::encoding::ValueTypeMarker for DeviceSetSuspendStatesRequest {
109 type Borrowed<'a> = &'a Self;
110 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
111 value
112 }
113 }
114
115 unsafe impl fidl::encoding::TypeMarker for DeviceSetSuspendStatesRequest {
116 type Owned = Self;
117
118 #[inline(always)]
119 fn inline_align(_context: fidl::encoding::Context) -> usize {
120 8
121 }
122
123 #[inline(always)]
124 fn inline_size(_context: fidl::encoding::Context) -> usize {
125 16
126 }
127 }
128
129 unsafe impl<D: fidl::encoding::ResourceDialect>
130 fidl::encoding::Encode<DeviceSetSuspendStatesRequest, D>
131 for &DeviceSetSuspendStatesRequest
132 {
133 unsafe fn encode(
134 self,
135 encoder: &mut fidl::encoding::Encoder<'_, D>,
136 offset: usize,
137 mut depth: fidl::encoding::Depth,
138 ) -> fidl::Result<()> {
139 encoder.debug_check_bounds::<DeviceSetSuspendStatesRequest>(offset);
140 let max_ordinal: u64 = self.max_ordinal_present();
142 encoder.write_num(max_ordinal, offset);
143 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
144 if max_ordinal == 0 {
146 return Ok(());
147 }
148 depth.increment()?;
149 let envelope_size = 8;
150 let bytes_len = max_ordinal as usize * envelope_size;
151 #[allow(unused_variables)]
152 let offset = encoder.out_of_line_offset(bytes_len);
153 let mut _prev_end_offset: usize = 0;
154 if 1 > max_ordinal {
155 return Ok(());
156 }
157
158 let cur_offset: usize = (1 - 1) * envelope_size;
161
162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
164
165 fidl::encoding::encode_in_envelope_optional::<
170 fidl::encoding::Vector<
171 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
172 256,
173 >,
174 D,
175 >(
176 self.suspend_states.as_ref().map(
177 <fidl::encoding::Vector<
178 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
179 256,
180 > as fidl::encoding::ValueTypeMarker>::borrow,
181 ),
182 encoder,
183 offset + cur_offset,
184 depth,
185 )?;
186
187 _prev_end_offset = cur_offset + envelope_size;
188
189 Ok(())
190 }
191 }
192
193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
194 for DeviceSetSuspendStatesRequest
195 {
196 #[inline(always)]
197 fn new_empty() -> Self {
198 Self::default()
199 }
200
201 unsafe fn decode(
202 &mut self,
203 decoder: &mut fidl::encoding::Decoder<'_, D>,
204 offset: usize,
205 mut depth: fidl::encoding::Depth,
206 ) -> fidl::Result<()> {
207 decoder.debug_check_bounds::<Self>(offset);
208 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
209 None => return Err(fidl::Error::NotNullable),
210 Some(len) => len,
211 };
212 if len == 0 {
214 return Ok(());
215 };
216 depth.increment()?;
217 let envelope_size = 8;
218 let bytes_len = len * envelope_size;
219 let offset = decoder.out_of_line_offset(bytes_len)?;
220 let mut _next_ordinal_to_read = 0;
222 let mut next_offset = offset;
223 let end_offset = offset + bytes_len;
224 _next_ordinal_to_read += 1;
225 if next_offset >= end_offset {
226 return Ok(());
227 }
228
229 while _next_ordinal_to_read < 1 {
231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
232 _next_ordinal_to_read += 1;
233 next_offset += envelope_size;
234 }
235
236 let next_out_of_line = decoder.next_out_of_line();
237 let handles_before = decoder.remaining_handles();
238 if let Some((inlined, num_bytes, num_handles)) =
239 fidl::encoding::decode_envelope_header(decoder, next_offset)?
240 {
241 let member_inline_size = <fidl::encoding::Vector<
242 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
243 256,
244 > as fidl::encoding::TypeMarker>::inline_size(
245 decoder.context
246 );
247 if inlined != (member_inline_size <= 4) {
248 return Err(fidl::Error::InvalidInlineBitInEnvelope);
249 }
250 let inner_offset;
251 let mut inner_depth = depth.clone();
252 if inlined {
253 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
254 inner_offset = next_offset;
255 } else {
256 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
257 inner_depth.increment()?;
258 }
259 let val_ref =
260 self.suspend_states.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D));
261 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
262 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
263 {
264 return Err(fidl::Error::InvalidNumBytesInEnvelope);
265 }
266 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
267 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
268 }
269 }
270
271 next_offset += envelope_size;
272
273 while next_offset < end_offset {
275 _next_ordinal_to_read += 1;
276 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
277 next_offset += envelope_size;
278 }
279
280 Ok(())
281 }
282 }
283
284 impl DeviceAwaitSuspendResponse {
285 #[inline(always)]
286 fn max_ordinal_present(&self) -> u64 {
287 if let Some(_) = self.state_index {
288 return 1;
289 }
290 0
291 }
292 }
293
294 impl fidl::encoding::ValueTypeMarker for DeviceAwaitSuspendResponse {
295 type Borrowed<'a> = &'a Self;
296 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297 value
298 }
299 }
300
301 unsafe impl fidl::encoding::TypeMarker for DeviceAwaitSuspendResponse {
302 type Owned = Self;
303
304 #[inline(always)]
305 fn inline_align(_context: fidl::encoding::Context) -> usize {
306 8
307 }
308
309 #[inline(always)]
310 fn inline_size(_context: fidl::encoding::Context) -> usize {
311 16
312 }
313 }
314
315 unsafe impl<D: fidl::encoding::ResourceDialect>
316 fidl::encoding::Encode<DeviceAwaitSuspendResponse, D> for &DeviceAwaitSuspendResponse
317 {
318 unsafe fn encode(
319 self,
320 encoder: &mut fidl::encoding::Encoder<'_, D>,
321 offset: usize,
322 mut depth: fidl::encoding::Depth,
323 ) -> fidl::Result<()> {
324 encoder.debug_check_bounds::<DeviceAwaitSuspendResponse>(offset);
325 let max_ordinal: u64 = self.max_ordinal_present();
327 encoder.write_num(max_ordinal, offset);
328 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
329 if max_ordinal == 0 {
331 return Ok(());
332 }
333 depth.increment()?;
334 let envelope_size = 8;
335 let bytes_len = max_ordinal as usize * envelope_size;
336 #[allow(unused_variables)]
337 let offset = encoder.out_of_line_offset(bytes_len);
338 let mut _prev_end_offset: usize = 0;
339 if 1 > max_ordinal {
340 return Ok(());
341 }
342
343 let cur_offset: usize = (1 - 1) * envelope_size;
346
347 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
349
350 fidl::encoding::encode_in_envelope_optional::<u64, D>(
355 self.state_index.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
356 encoder,
357 offset + cur_offset,
358 depth,
359 )?;
360
361 _prev_end_offset = cur_offset + envelope_size;
362
363 Ok(())
364 }
365 }
366
367 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
368 for DeviceAwaitSuspendResponse
369 {
370 #[inline(always)]
371 fn new_empty() -> Self {
372 Self::default()
373 }
374
375 unsafe fn decode(
376 &mut self,
377 decoder: &mut fidl::encoding::Decoder<'_, D>,
378 offset: usize,
379 mut depth: fidl::encoding::Depth,
380 ) -> fidl::Result<()> {
381 decoder.debug_check_bounds::<Self>(offset);
382 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
383 None => return Err(fidl::Error::NotNullable),
384 Some(len) => len,
385 };
386 if len == 0 {
388 return Ok(());
389 };
390 depth.increment()?;
391 let envelope_size = 8;
392 let bytes_len = len * envelope_size;
393 let offset = decoder.out_of_line_offset(bytes_len)?;
394 let mut _next_ordinal_to_read = 0;
396 let mut next_offset = offset;
397 let end_offset = offset + bytes_len;
398 _next_ordinal_to_read += 1;
399 if next_offset >= end_offset {
400 return Ok(());
401 }
402
403 while _next_ordinal_to_read < 1 {
405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
406 _next_ordinal_to_read += 1;
407 next_offset += envelope_size;
408 }
409
410 let next_out_of_line = decoder.next_out_of_line();
411 let handles_before = decoder.remaining_handles();
412 if let Some((inlined, num_bytes, num_handles)) =
413 fidl::encoding::decode_envelope_header(decoder, next_offset)?
414 {
415 let member_inline_size =
416 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
417 if inlined != (member_inline_size <= 4) {
418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
419 }
420 let inner_offset;
421 let mut inner_depth = depth.clone();
422 if inlined {
423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
424 inner_offset = next_offset;
425 } else {
426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
427 inner_depth.increment()?;
428 }
429 let val_ref = self.state_index.get_or_insert_with(|| fidl::new_empty!(u64, D));
430 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
432 {
433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
434 }
435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
437 }
438 }
439
440 next_offset += envelope_size;
441
442 while next_offset < end_offset {
444 _next_ordinal_to_read += 1;
445 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
446 next_offset += envelope_size;
447 }
448
449 Ok(())
450 }
451 }
452
453 impl SuspendResult {
454 #[inline(always)]
455 fn max_ordinal_present(&self) -> u64 {
456 if let Some(_) = self.suspend_overhead {
457 return 3;
458 }
459 if let Some(_) = self.suspend_duration {
460 return 2;
461 }
462 if let Some(_) = self.reason {
463 return 1;
464 }
465 0
466 }
467 }
468
469 impl fidl::encoding::ValueTypeMarker for SuspendResult {
470 type Borrowed<'a> = &'a Self;
471 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
472 value
473 }
474 }
475
476 unsafe impl fidl::encoding::TypeMarker for SuspendResult {
477 type Owned = Self;
478
479 #[inline(always)]
480 fn inline_align(_context: fidl::encoding::Context) -> usize {
481 8
482 }
483
484 #[inline(always)]
485 fn inline_size(_context: fidl::encoding::Context) -> usize {
486 16
487 }
488 }
489
490 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SuspendResult, D>
491 for &SuspendResult
492 {
493 unsafe fn encode(
494 self,
495 encoder: &mut fidl::encoding::Encoder<'_, D>,
496 offset: usize,
497 mut depth: fidl::encoding::Depth,
498 ) -> fidl::Result<()> {
499 encoder.debug_check_bounds::<SuspendResult>(offset);
500 let max_ordinal: u64 = self.max_ordinal_present();
502 encoder.write_num(max_ordinal, offset);
503 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
504 if max_ordinal == 0 {
506 return Ok(());
507 }
508 depth.increment()?;
509 let envelope_size = 8;
510 let bytes_len = max_ordinal as usize * envelope_size;
511 #[allow(unused_variables)]
512 let offset = encoder.out_of_line_offset(bytes_len);
513 let mut _prev_end_offset: usize = 0;
514 if 1 > max_ordinal {
515 return Ok(());
516 }
517
518 let cur_offset: usize = (1 - 1) * envelope_size;
521
522 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
524
525 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_power_suspend__common::WakeReason, D>(
530 self.reason.as_ref().map(<fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::ValueTypeMarker>::borrow),
531 encoder, offset + cur_offset, depth
532 )?;
533
534 _prev_end_offset = cur_offset + envelope_size;
535 if 2 > max_ordinal {
536 return Ok(());
537 }
538
539 let cur_offset: usize = (2 - 1) * envelope_size;
542
543 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
545
546 fidl::encoding::encode_in_envelope_optional::<i64, D>(
551 self.suspend_duration
552 .as_ref()
553 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
554 encoder,
555 offset + cur_offset,
556 depth,
557 )?;
558
559 _prev_end_offset = cur_offset + envelope_size;
560 if 3 > max_ordinal {
561 return Ok(());
562 }
563
564 let cur_offset: usize = (3 - 1) * envelope_size;
567
568 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
570
571 fidl::encoding::encode_in_envelope_optional::<i64, D>(
576 self.suspend_overhead
577 .as_ref()
578 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
579 encoder,
580 offset + cur_offset,
581 depth,
582 )?;
583
584 _prev_end_offset = cur_offset + envelope_size;
585
586 Ok(())
587 }
588 }
589
590 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendResult {
591 #[inline(always)]
592 fn new_empty() -> Self {
593 Self::default()
594 }
595
596 unsafe fn decode(
597 &mut self,
598 decoder: &mut fidl::encoding::Decoder<'_, D>,
599 offset: usize,
600 mut depth: fidl::encoding::Depth,
601 ) -> fidl::Result<()> {
602 decoder.debug_check_bounds::<Self>(offset);
603 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
604 None => return Err(fidl::Error::NotNullable),
605 Some(len) => len,
606 };
607 if len == 0 {
609 return Ok(());
610 };
611 depth.increment()?;
612 let envelope_size = 8;
613 let bytes_len = len * envelope_size;
614 let offset = decoder.out_of_line_offset(bytes_len)?;
615 let mut _next_ordinal_to_read = 0;
617 let mut next_offset = offset;
618 let end_offset = offset + bytes_len;
619 _next_ordinal_to_read += 1;
620 if next_offset >= end_offset {
621 return Ok(());
622 }
623
624 while _next_ordinal_to_read < 1 {
626 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
627 _next_ordinal_to_read += 1;
628 next_offset += envelope_size;
629 }
630
631 let next_out_of_line = decoder.next_out_of_line();
632 let handles_before = decoder.remaining_handles();
633 if let Some((inlined, num_bytes, num_handles)) =
634 fidl::encoding::decode_envelope_header(decoder, next_offset)?
635 {
636 let member_inline_size = <fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::TypeMarker>::inline_size(decoder.context);
637 if inlined != (member_inline_size <= 4) {
638 return Err(fidl::Error::InvalidInlineBitInEnvelope);
639 }
640 let inner_offset;
641 let mut inner_depth = depth.clone();
642 if inlined {
643 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
644 inner_offset = next_offset;
645 } else {
646 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
647 inner_depth.increment()?;
648 }
649 let val_ref = self.reason.get_or_insert_with(|| {
650 fidl::new_empty!(fidl_fuchsia_hardware_power_suspend__common::WakeReason, D)
651 });
652 fidl::decode!(
653 fidl_fuchsia_hardware_power_suspend__common::WakeReason,
654 D,
655 val_ref,
656 decoder,
657 inner_offset,
658 inner_depth
659 )?;
660 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
661 {
662 return Err(fidl::Error::InvalidNumBytesInEnvelope);
663 }
664 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
665 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
666 }
667 }
668
669 next_offset += envelope_size;
670 _next_ordinal_to_read += 1;
671 if next_offset >= end_offset {
672 return Ok(());
673 }
674
675 while _next_ordinal_to_read < 2 {
677 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
678 _next_ordinal_to_read += 1;
679 next_offset += envelope_size;
680 }
681
682 let next_out_of_line = decoder.next_out_of_line();
683 let handles_before = decoder.remaining_handles();
684 if let Some((inlined, num_bytes, num_handles)) =
685 fidl::encoding::decode_envelope_header(decoder, next_offset)?
686 {
687 let member_inline_size =
688 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
689 if inlined != (member_inline_size <= 4) {
690 return Err(fidl::Error::InvalidInlineBitInEnvelope);
691 }
692 let inner_offset;
693 let mut inner_depth = depth.clone();
694 if inlined {
695 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
696 inner_offset = next_offset;
697 } else {
698 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
699 inner_depth.increment()?;
700 }
701 let val_ref = self.suspend_duration.get_or_insert_with(|| fidl::new_empty!(i64, D));
702 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
703 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
704 {
705 return Err(fidl::Error::InvalidNumBytesInEnvelope);
706 }
707 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
708 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
709 }
710 }
711
712 next_offset += envelope_size;
713 _next_ordinal_to_read += 1;
714 if next_offset >= end_offset {
715 return Ok(());
716 }
717
718 while _next_ordinal_to_read < 3 {
720 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
721 _next_ordinal_to_read += 1;
722 next_offset += envelope_size;
723 }
724
725 let next_out_of_line = decoder.next_out_of_line();
726 let handles_before = decoder.remaining_handles();
727 if let Some((inlined, num_bytes, num_handles)) =
728 fidl::encoding::decode_envelope_header(decoder, next_offset)?
729 {
730 let member_inline_size =
731 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
732 if inlined != (member_inline_size <= 4) {
733 return Err(fidl::Error::InvalidInlineBitInEnvelope);
734 }
735 let inner_offset;
736 let mut inner_depth = depth.clone();
737 if inlined {
738 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
739 inner_offset = next_offset;
740 } else {
741 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
742 inner_depth.increment()?;
743 }
744 let val_ref = self.suspend_overhead.get_or_insert_with(|| fidl::new_empty!(i64, D));
745 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
746 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
747 {
748 return Err(fidl::Error::InvalidNumBytesInEnvelope);
749 }
750 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
751 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
752 }
753 }
754
755 next_offset += envelope_size;
756
757 while next_offset < end_offset {
759 _next_ordinal_to_read += 1;
760 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
761 next_offset += envelope_size;
762 }
763
764 Ok(())
765 }
766 }
767
768 impl fidl::encoding::ValueTypeMarker for DeviceResumeRequest {
769 type Borrowed<'a> = &'a Self;
770 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
771 value
772 }
773 }
774
775 unsafe impl fidl::encoding::TypeMarker for DeviceResumeRequest {
776 type Owned = Self;
777
778 #[inline(always)]
779 fn inline_align(_context: fidl::encoding::Context) -> usize {
780 8
781 }
782
783 #[inline(always)]
784 fn inline_size(_context: fidl::encoding::Context) -> usize {
785 16
786 }
787 }
788
789 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceResumeRequest, D>
790 for &DeviceResumeRequest
791 {
792 #[inline]
793 unsafe fn encode(
794 self,
795 encoder: &mut fidl::encoding::Encoder<'_, D>,
796 offset: usize,
797 _depth: fidl::encoding::Depth,
798 ) -> fidl::Result<()> {
799 encoder.debug_check_bounds::<DeviceResumeRequest>(offset);
800 encoder.write_num::<u64>(self.ordinal(), offset);
801 match self {
802 DeviceResumeRequest::Result(ref val) => {
803 fidl::encoding::encode_in_envelope::<SuspendResult, D>(
804 <SuspendResult as fidl::encoding::ValueTypeMarker>::borrow(val),
805 encoder,
806 offset + 8,
807 _depth,
808 )
809 }
810 DeviceResumeRequest::Error(ref val) => {
811 fidl::encoding::encode_in_envelope::<i32, D>(
812 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
813 encoder,
814 offset + 8,
815 _depth,
816 )
817 }
818 DeviceResumeRequest::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
819 }
820 }
821 }
822
823 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceResumeRequest {
824 #[inline(always)]
825 fn new_empty() -> Self {
826 Self::__SourceBreaking { unknown_ordinal: 0 }
827 }
828
829 #[inline]
830 unsafe fn decode(
831 &mut self,
832 decoder: &mut fidl::encoding::Decoder<'_, D>,
833 offset: usize,
834 mut depth: fidl::encoding::Depth,
835 ) -> fidl::Result<()> {
836 decoder.debug_check_bounds::<Self>(offset);
837 #[allow(unused_variables)]
838 let next_out_of_line = decoder.next_out_of_line();
839 let handles_before = decoder.remaining_handles();
840 let (ordinal, inlined, num_bytes, num_handles) =
841 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
842
843 let member_inline_size = match ordinal {
844 1 => <SuspendResult as fidl::encoding::TypeMarker>::inline_size(decoder.context),
845 2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
846 0 => return Err(fidl::Error::UnknownUnionTag),
847 _ => num_bytes as usize,
848 };
849
850 if inlined != (member_inline_size <= 4) {
851 return Err(fidl::Error::InvalidInlineBitInEnvelope);
852 }
853 let _inner_offset;
854 if inlined {
855 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
856 _inner_offset = offset + 8;
857 } else {
858 depth.increment()?;
859 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
860 }
861 match ordinal {
862 1 => {
863 #[allow(irrefutable_let_patterns)]
864 if let DeviceResumeRequest::Result(_) = self {
865 } else {
867 *self = DeviceResumeRequest::Result(fidl::new_empty!(SuspendResult, D));
869 }
870 #[allow(irrefutable_let_patterns)]
871 if let DeviceResumeRequest::Result(ref mut val) = self {
872 fidl::decode!(SuspendResult, D, val, decoder, _inner_offset, depth)?;
873 } else {
874 unreachable!()
875 }
876 }
877 2 => {
878 #[allow(irrefutable_let_patterns)]
879 if let DeviceResumeRequest::Error(_) = self {
880 } else {
882 *self = DeviceResumeRequest::Error(fidl::new_empty!(i32, D));
884 }
885 #[allow(irrefutable_let_patterns)]
886 if let DeviceResumeRequest::Error(ref mut val) = self {
887 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
888 } else {
889 unreachable!()
890 }
891 }
892 #[allow(deprecated)]
893 ordinal => {
894 for _ in 0..num_handles {
895 decoder.drop_next_handle()?;
896 }
897 *self = DeviceResumeRequest::__SourceBreaking { unknown_ordinal: ordinal };
898 }
899 }
900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
901 return Err(fidl::Error::InvalidNumBytesInEnvelope);
902 }
903 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
904 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
905 }
906 Ok(())
907 }
908 }
909}