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
95pub mod device_ordinals {
96 pub const SET_SUSPEND_STATES: u64 = 0x3d37a51c2955e852;
97 pub const AWAIT_SUSPEND: u64 = 0x7eb0d662063b347e;
98 pub const RESUME: u64 = 0x2deb813cfe9b881e;
99}
100
101mod internal {
102 use super::*;
103
104 impl DeviceSetSuspendStatesRequest {
105 #[inline(always)]
106 fn max_ordinal_present(&self) -> u64 {
107 if let Some(_) = self.suspend_states {
108 return 1;
109 }
110 0
111 }
112 }
113
114 impl fidl::encoding::ValueTypeMarker for DeviceSetSuspendStatesRequest {
115 type Borrowed<'a> = &'a Self;
116 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
117 value
118 }
119 }
120
121 unsafe impl fidl::encoding::TypeMarker for DeviceSetSuspendStatesRequest {
122 type Owned = Self;
123
124 #[inline(always)]
125 fn inline_align(_context: fidl::encoding::Context) -> usize {
126 8
127 }
128
129 #[inline(always)]
130 fn inline_size(_context: fidl::encoding::Context) -> usize {
131 16
132 }
133 }
134
135 unsafe impl<D: fidl::encoding::ResourceDialect>
136 fidl::encoding::Encode<DeviceSetSuspendStatesRequest, D>
137 for &DeviceSetSuspendStatesRequest
138 {
139 unsafe fn encode(
140 self,
141 encoder: &mut fidl::encoding::Encoder<'_, D>,
142 offset: usize,
143 mut depth: fidl::encoding::Depth,
144 ) -> fidl::Result<()> {
145 encoder.debug_check_bounds::<DeviceSetSuspendStatesRequest>(offset);
146 let max_ordinal: u64 = self.max_ordinal_present();
148 encoder.write_num(max_ordinal, offset);
149 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
150 if max_ordinal == 0 {
152 return Ok(());
153 }
154 depth.increment()?;
155 let envelope_size = 8;
156 let bytes_len = max_ordinal as usize * envelope_size;
157 #[allow(unused_variables)]
158 let offset = encoder.out_of_line_offset(bytes_len);
159 let mut _prev_end_offset: usize = 0;
160 if 1 > max_ordinal {
161 return Ok(());
162 }
163
164 let cur_offset: usize = (1 - 1) * envelope_size;
167
168 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
170
171 fidl::encoding::encode_in_envelope_optional::<
176 fidl::encoding::Vector<
177 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
178 256,
179 >,
180 D,
181 >(
182 self.suspend_states.as_ref().map(
183 <fidl::encoding::Vector<
184 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
185 256,
186 > as fidl::encoding::ValueTypeMarker>::borrow,
187 ),
188 encoder,
189 offset + cur_offset,
190 depth,
191 )?;
192
193 _prev_end_offset = cur_offset + envelope_size;
194
195 Ok(())
196 }
197 }
198
199 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
200 for DeviceSetSuspendStatesRequest
201 {
202 #[inline(always)]
203 fn new_empty() -> Self {
204 Self::default()
205 }
206
207 unsafe fn decode(
208 &mut self,
209 decoder: &mut fidl::encoding::Decoder<'_, D>,
210 offset: usize,
211 mut depth: fidl::encoding::Depth,
212 ) -> fidl::Result<()> {
213 decoder.debug_check_bounds::<Self>(offset);
214 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
215 None => return Err(fidl::Error::NotNullable),
216 Some(len) => len,
217 };
218 if len == 0 {
220 return Ok(());
221 };
222 depth.increment()?;
223 let envelope_size = 8;
224 let bytes_len = len * envelope_size;
225 let offset = decoder.out_of_line_offset(bytes_len)?;
226 let mut _next_ordinal_to_read = 0;
228 let mut next_offset = offset;
229 let end_offset = offset + bytes_len;
230 _next_ordinal_to_read += 1;
231 if next_offset >= end_offset {
232 return Ok(());
233 }
234
235 while _next_ordinal_to_read < 1 {
237 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
238 _next_ordinal_to_read += 1;
239 next_offset += envelope_size;
240 }
241
242 let next_out_of_line = decoder.next_out_of_line();
243 let handles_before = decoder.remaining_handles();
244 if let Some((inlined, num_bytes, num_handles)) =
245 fidl::encoding::decode_envelope_header(decoder, next_offset)?
246 {
247 let member_inline_size = <fidl::encoding::Vector<
248 fidl_fuchsia_hardware_power_suspend__common::SuspendState,
249 256,
250 > as fidl::encoding::TypeMarker>::inline_size(
251 decoder.context
252 );
253 if inlined != (member_inline_size <= 4) {
254 return Err(fidl::Error::InvalidInlineBitInEnvelope);
255 }
256 let inner_offset;
257 let mut inner_depth = depth.clone();
258 if inlined {
259 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
260 inner_offset = next_offset;
261 } else {
262 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
263 inner_depth.increment()?;
264 }
265 let val_ref =
266 self.suspend_states.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D));
267 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
268 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
269 {
270 return Err(fidl::Error::InvalidNumBytesInEnvelope);
271 }
272 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
273 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
274 }
275 }
276
277 next_offset += envelope_size;
278
279 while next_offset < end_offset {
281 _next_ordinal_to_read += 1;
282 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
283 next_offset += envelope_size;
284 }
285
286 Ok(())
287 }
288 }
289
290 impl DeviceAwaitSuspendResponse {
291 #[inline(always)]
292 fn max_ordinal_present(&self) -> u64 {
293 if let Some(_) = self.state_index {
294 return 1;
295 }
296 0
297 }
298 }
299
300 impl fidl::encoding::ValueTypeMarker for DeviceAwaitSuspendResponse {
301 type Borrowed<'a> = &'a Self;
302 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
303 value
304 }
305 }
306
307 unsafe impl fidl::encoding::TypeMarker for DeviceAwaitSuspendResponse {
308 type Owned = Self;
309
310 #[inline(always)]
311 fn inline_align(_context: fidl::encoding::Context) -> usize {
312 8
313 }
314
315 #[inline(always)]
316 fn inline_size(_context: fidl::encoding::Context) -> usize {
317 16
318 }
319 }
320
321 unsafe impl<D: fidl::encoding::ResourceDialect>
322 fidl::encoding::Encode<DeviceAwaitSuspendResponse, D> for &DeviceAwaitSuspendResponse
323 {
324 unsafe fn encode(
325 self,
326 encoder: &mut fidl::encoding::Encoder<'_, D>,
327 offset: usize,
328 mut depth: fidl::encoding::Depth,
329 ) -> fidl::Result<()> {
330 encoder.debug_check_bounds::<DeviceAwaitSuspendResponse>(offset);
331 let max_ordinal: u64 = self.max_ordinal_present();
333 encoder.write_num(max_ordinal, offset);
334 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
335 if max_ordinal == 0 {
337 return Ok(());
338 }
339 depth.increment()?;
340 let envelope_size = 8;
341 let bytes_len = max_ordinal as usize * envelope_size;
342 #[allow(unused_variables)]
343 let offset = encoder.out_of_line_offset(bytes_len);
344 let mut _prev_end_offset: usize = 0;
345 if 1 > max_ordinal {
346 return Ok(());
347 }
348
349 let cur_offset: usize = (1 - 1) * envelope_size;
352
353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
355
356 fidl::encoding::encode_in_envelope_optional::<u64, D>(
361 self.state_index.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
362 encoder,
363 offset + cur_offset,
364 depth,
365 )?;
366
367 _prev_end_offset = cur_offset + envelope_size;
368
369 Ok(())
370 }
371 }
372
373 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
374 for DeviceAwaitSuspendResponse
375 {
376 #[inline(always)]
377 fn new_empty() -> Self {
378 Self::default()
379 }
380
381 unsafe fn decode(
382 &mut self,
383 decoder: &mut fidl::encoding::Decoder<'_, D>,
384 offset: usize,
385 mut depth: fidl::encoding::Depth,
386 ) -> fidl::Result<()> {
387 decoder.debug_check_bounds::<Self>(offset);
388 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
389 None => return Err(fidl::Error::NotNullable),
390 Some(len) => len,
391 };
392 if len == 0 {
394 return Ok(());
395 };
396 depth.increment()?;
397 let envelope_size = 8;
398 let bytes_len = len * envelope_size;
399 let offset = decoder.out_of_line_offset(bytes_len)?;
400 let mut _next_ordinal_to_read = 0;
402 let mut next_offset = offset;
403 let end_offset = offset + bytes_len;
404 _next_ordinal_to_read += 1;
405 if next_offset >= end_offset {
406 return Ok(());
407 }
408
409 while _next_ordinal_to_read < 1 {
411 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
412 _next_ordinal_to_read += 1;
413 next_offset += envelope_size;
414 }
415
416 let next_out_of_line = decoder.next_out_of_line();
417 let handles_before = decoder.remaining_handles();
418 if let Some((inlined, num_bytes, num_handles)) =
419 fidl::encoding::decode_envelope_header(decoder, next_offset)?
420 {
421 let member_inline_size =
422 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
423 if inlined != (member_inline_size <= 4) {
424 return Err(fidl::Error::InvalidInlineBitInEnvelope);
425 }
426 let inner_offset;
427 let mut inner_depth = depth.clone();
428 if inlined {
429 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
430 inner_offset = next_offset;
431 } else {
432 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
433 inner_depth.increment()?;
434 }
435 let val_ref = self.state_index.get_or_insert_with(|| fidl::new_empty!(u64, D));
436 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
437 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
438 {
439 return Err(fidl::Error::InvalidNumBytesInEnvelope);
440 }
441 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
442 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
443 }
444 }
445
446 next_offset += envelope_size;
447
448 while next_offset < end_offset {
450 _next_ordinal_to_read += 1;
451 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
452 next_offset += envelope_size;
453 }
454
455 Ok(())
456 }
457 }
458
459 impl SuspendResult {
460 #[inline(always)]
461 fn max_ordinal_present(&self) -> u64 {
462 if let Some(_) = self.suspend_overhead {
463 return 3;
464 }
465 if let Some(_) = self.suspend_duration {
466 return 2;
467 }
468 if let Some(_) = self.reason {
469 return 1;
470 }
471 0
472 }
473 }
474
475 impl fidl::encoding::ValueTypeMarker for SuspendResult {
476 type Borrowed<'a> = &'a Self;
477 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
478 value
479 }
480 }
481
482 unsafe impl fidl::encoding::TypeMarker for SuspendResult {
483 type Owned = Self;
484
485 #[inline(always)]
486 fn inline_align(_context: fidl::encoding::Context) -> usize {
487 8
488 }
489
490 #[inline(always)]
491 fn inline_size(_context: fidl::encoding::Context) -> usize {
492 16
493 }
494 }
495
496 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SuspendResult, D>
497 for &SuspendResult
498 {
499 unsafe fn encode(
500 self,
501 encoder: &mut fidl::encoding::Encoder<'_, D>,
502 offset: usize,
503 mut depth: fidl::encoding::Depth,
504 ) -> fidl::Result<()> {
505 encoder.debug_check_bounds::<SuspendResult>(offset);
506 let max_ordinal: u64 = self.max_ordinal_present();
508 encoder.write_num(max_ordinal, offset);
509 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
510 if max_ordinal == 0 {
512 return Ok(());
513 }
514 depth.increment()?;
515 let envelope_size = 8;
516 let bytes_len = max_ordinal as usize * envelope_size;
517 #[allow(unused_variables)]
518 let offset = encoder.out_of_line_offset(bytes_len);
519 let mut _prev_end_offset: usize = 0;
520 if 1 > max_ordinal {
521 return Ok(());
522 }
523
524 let cur_offset: usize = (1 - 1) * envelope_size;
527
528 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
530
531 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_power_suspend__common::WakeReason, D>(
536 self.reason.as_ref().map(<fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::ValueTypeMarker>::borrow),
537 encoder, offset + cur_offset, depth
538 )?;
539
540 _prev_end_offset = cur_offset + envelope_size;
541 if 2 > max_ordinal {
542 return Ok(());
543 }
544
545 let cur_offset: usize = (2 - 1) * envelope_size;
548
549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
551
552 fidl::encoding::encode_in_envelope_optional::<i64, D>(
557 self.suspend_duration
558 .as_ref()
559 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
560 encoder,
561 offset + cur_offset,
562 depth,
563 )?;
564
565 _prev_end_offset = cur_offset + envelope_size;
566 if 3 > max_ordinal {
567 return Ok(());
568 }
569
570 let cur_offset: usize = (3 - 1) * envelope_size;
573
574 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
576
577 fidl::encoding::encode_in_envelope_optional::<i64, D>(
582 self.suspend_overhead
583 .as_ref()
584 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
585 encoder,
586 offset + cur_offset,
587 depth,
588 )?;
589
590 _prev_end_offset = cur_offset + envelope_size;
591
592 Ok(())
593 }
594 }
595
596 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendResult {
597 #[inline(always)]
598 fn new_empty() -> Self {
599 Self::default()
600 }
601
602 unsafe fn decode(
603 &mut self,
604 decoder: &mut fidl::encoding::Decoder<'_, D>,
605 offset: usize,
606 mut depth: fidl::encoding::Depth,
607 ) -> fidl::Result<()> {
608 decoder.debug_check_bounds::<Self>(offset);
609 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
610 None => return Err(fidl::Error::NotNullable),
611 Some(len) => len,
612 };
613 if len == 0 {
615 return Ok(());
616 };
617 depth.increment()?;
618 let envelope_size = 8;
619 let bytes_len = len * envelope_size;
620 let offset = decoder.out_of_line_offset(bytes_len)?;
621 let mut _next_ordinal_to_read = 0;
623 let mut next_offset = offset;
624 let end_offset = offset + bytes_len;
625 _next_ordinal_to_read += 1;
626 if next_offset >= end_offset {
627 return Ok(());
628 }
629
630 while _next_ordinal_to_read < 1 {
632 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
633 _next_ordinal_to_read += 1;
634 next_offset += envelope_size;
635 }
636
637 let next_out_of_line = decoder.next_out_of_line();
638 let handles_before = decoder.remaining_handles();
639 if let Some((inlined, num_bytes, num_handles)) =
640 fidl::encoding::decode_envelope_header(decoder, next_offset)?
641 {
642 let member_inline_size = <fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::TypeMarker>::inline_size(decoder.context);
643 if inlined != (member_inline_size <= 4) {
644 return Err(fidl::Error::InvalidInlineBitInEnvelope);
645 }
646 let inner_offset;
647 let mut inner_depth = depth.clone();
648 if inlined {
649 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
650 inner_offset = next_offset;
651 } else {
652 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
653 inner_depth.increment()?;
654 }
655 let val_ref = self.reason.get_or_insert_with(|| {
656 fidl::new_empty!(fidl_fuchsia_hardware_power_suspend__common::WakeReason, D)
657 });
658 fidl::decode!(
659 fidl_fuchsia_hardware_power_suspend__common::WakeReason,
660 D,
661 val_ref,
662 decoder,
663 inner_offset,
664 inner_depth
665 )?;
666 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
667 {
668 return Err(fidl::Error::InvalidNumBytesInEnvelope);
669 }
670 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
671 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
672 }
673 }
674
675 next_offset += envelope_size;
676 _next_ordinal_to_read += 1;
677 if next_offset >= end_offset {
678 return Ok(());
679 }
680
681 while _next_ordinal_to_read < 2 {
683 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
684 _next_ordinal_to_read += 1;
685 next_offset += envelope_size;
686 }
687
688 let next_out_of_line = decoder.next_out_of_line();
689 let handles_before = decoder.remaining_handles();
690 if let Some((inlined, num_bytes, num_handles)) =
691 fidl::encoding::decode_envelope_header(decoder, next_offset)?
692 {
693 let member_inline_size =
694 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
695 if inlined != (member_inline_size <= 4) {
696 return Err(fidl::Error::InvalidInlineBitInEnvelope);
697 }
698 let inner_offset;
699 let mut inner_depth = depth.clone();
700 if inlined {
701 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
702 inner_offset = next_offset;
703 } else {
704 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
705 inner_depth.increment()?;
706 }
707 let val_ref = self.suspend_duration.get_or_insert_with(|| fidl::new_empty!(i64, D));
708 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
709 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
710 {
711 return Err(fidl::Error::InvalidNumBytesInEnvelope);
712 }
713 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
714 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
715 }
716 }
717
718 next_offset += envelope_size;
719 _next_ordinal_to_read += 1;
720 if next_offset >= end_offset {
721 return Ok(());
722 }
723
724 while _next_ordinal_to_read < 3 {
726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
727 _next_ordinal_to_read += 1;
728 next_offset += envelope_size;
729 }
730
731 let next_out_of_line = decoder.next_out_of_line();
732 let handles_before = decoder.remaining_handles();
733 if let Some((inlined, num_bytes, num_handles)) =
734 fidl::encoding::decode_envelope_header(decoder, next_offset)?
735 {
736 let member_inline_size =
737 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
738 if inlined != (member_inline_size <= 4) {
739 return Err(fidl::Error::InvalidInlineBitInEnvelope);
740 }
741 let inner_offset;
742 let mut inner_depth = depth.clone();
743 if inlined {
744 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
745 inner_offset = next_offset;
746 } else {
747 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
748 inner_depth.increment()?;
749 }
750 let val_ref = self.suspend_overhead.get_or_insert_with(|| fidl::new_empty!(i64, D));
751 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
752 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
753 {
754 return Err(fidl::Error::InvalidNumBytesInEnvelope);
755 }
756 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
757 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
758 }
759 }
760
761 next_offset += envelope_size;
762
763 while next_offset < end_offset {
765 _next_ordinal_to_read += 1;
766 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
767 next_offset += envelope_size;
768 }
769
770 Ok(())
771 }
772 }
773
774 impl fidl::encoding::ValueTypeMarker for DeviceResumeRequest {
775 type Borrowed<'a> = &'a Self;
776 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
777 value
778 }
779 }
780
781 unsafe impl fidl::encoding::TypeMarker for DeviceResumeRequest {
782 type Owned = Self;
783
784 #[inline(always)]
785 fn inline_align(_context: fidl::encoding::Context) -> usize {
786 8
787 }
788
789 #[inline(always)]
790 fn inline_size(_context: fidl::encoding::Context) -> usize {
791 16
792 }
793 }
794
795 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceResumeRequest, D>
796 for &DeviceResumeRequest
797 {
798 #[inline]
799 unsafe fn encode(
800 self,
801 encoder: &mut fidl::encoding::Encoder<'_, D>,
802 offset: usize,
803 _depth: fidl::encoding::Depth,
804 ) -> fidl::Result<()> {
805 encoder.debug_check_bounds::<DeviceResumeRequest>(offset);
806 encoder.write_num::<u64>(self.ordinal(), offset);
807 match self {
808 DeviceResumeRequest::Result(ref val) => {
809 fidl::encoding::encode_in_envelope::<SuspendResult, D>(
810 <SuspendResult as fidl::encoding::ValueTypeMarker>::borrow(val),
811 encoder,
812 offset + 8,
813 _depth,
814 )
815 }
816 DeviceResumeRequest::Error(ref val) => {
817 fidl::encoding::encode_in_envelope::<i32, D>(
818 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
819 encoder,
820 offset + 8,
821 _depth,
822 )
823 }
824 DeviceResumeRequest::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
825 }
826 }
827 }
828
829 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceResumeRequest {
830 #[inline(always)]
831 fn new_empty() -> Self {
832 Self::__SourceBreaking { unknown_ordinal: 0 }
833 }
834
835 #[inline]
836 unsafe fn decode(
837 &mut self,
838 decoder: &mut fidl::encoding::Decoder<'_, D>,
839 offset: usize,
840 mut depth: fidl::encoding::Depth,
841 ) -> fidl::Result<()> {
842 decoder.debug_check_bounds::<Self>(offset);
843 #[allow(unused_variables)]
844 let next_out_of_line = decoder.next_out_of_line();
845 let handles_before = decoder.remaining_handles();
846 let (ordinal, inlined, num_bytes, num_handles) =
847 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
848
849 let member_inline_size = match ordinal {
850 1 => <SuspendResult as fidl::encoding::TypeMarker>::inline_size(decoder.context),
851 2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
852 0 => return Err(fidl::Error::UnknownUnionTag),
853 _ => num_bytes as usize,
854 };
855
856 if inlined != (member_inline_size <= 4) {
857 return Err(fidl::Error::InvalidInlineBitInEnvelope);
858 }
859 let _inner_offset;
860 if inlined {
861 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
862 _inner_offset = offset + 8;
863 } else {
864 depth.increment()?;
865 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
866 }
867 match ordinal {
868 1 => {
869 #[allow(irrefutable_let_patterns)]
870 if let DeviceResumeRequest::Result(_) = self {
871 } else {
873 *self = DeviceResumeRequest::Result(fidl::new_empty!(SuspendResult, D));
875 }
876 #[allow(irrefutable_let_patterns)]
877 if let DeviceResumeRequest::Result(ref mut val) = self {
878 fidl::decode!(SuspendResult, D, val, decoder, _inner_offset, depth)?;
879 } else {
880 unreachable!()
881 }
882 }
883 2 => {
884 #[allow(irrefutable_let_patterns)]
885 if let DeviceResumeRequest::Error(_) = self {
886 } else {
888 *self = DeviceResumeRequest::Error(fidl::new_empty!(i32, D));
890 }
891 #[allow(irrefutable_let_patterns)]
892 if let DeviceResumeRequest::Error(ref mut val) = self {
893 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
894 } else {
895 unreachable!()
896 }
897 }
898 #[allow(deprecated)]
899 ordinal => {
900 for _ in 0..num_handles {
901 decoder.drop_next_handle()?;
902 }
903 *self = DeviceResumeRequest::__SourceBreaking { unknown_ordinal: ordinal };
904 }
905 }
906 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
907 return Err(fidl::Error::InvalidNumBytesInEnvelope);
908 }
909 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
910 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
911 }
912 Ok(())
913 }
914 }
915}