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(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13#[repr(u32)]
14pub enum BatteryStatus {
15 Unknown = 0,
17 Ok = 1,
19 NotAvailable = 2,
21 NotPresent = 3,
23}
24
25impl BatteryStatus {
26 #[inline]
27 pub fn from_primitive(prim: u32) -> Option<Self> {
28 match prim {
29 0 => Some(Self::Unknown),
30 1 => Some(Self::Ok),
31 2 => Some(Self::NotAvailable),
32 3 => Some(Self::NotPresent),
33 _ => None,
34 }
35 }
36
37 #[inline]
38 pub const fn into_primitive(self) -> u32 {
39 self as u32
40 }
41}
42
43#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
45#[repr(u32)]
46pub enum ChargeSource {
47 Unknown = 0,
48 None = 1,
49 AcAdapter = 2,
50 Usb = 3,
51 Wireless = 4,
52}
53
54impl ChargeSource {
55 #[inline]
56 pub fn from_primitive(prim: u32) -> Option<Self> {
57 match prim {
58 0 => Some(Self::Unknown),
59 1 => Some(Self::None),
60 2 => Some(Self::AcAdapter),
61 3 => Some(Self::Usb),
62 4 => Some(Self::Wireless),
63 _ => None,
64 }
65 }
66
67 #[inline]
68 pub const fn into_primitive(self) -> u32 {
69 self as u32
70 }
71}
72
73#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
75#[repr(u32)]
76pub enum ChargeStatus {
77 Unknown = 0,
78 NotCharging = 1,
79 Charging = 2,
80 Discharging = 3,
81 Full = 4,
82}
83
84impl ChargeStatus {
85 #[inline]
86 pub fn from_primitive(prim: u32) -> Option<Self> {
87 match prim {
88 0 => Some(Self::Unknown),
89 1 => Some(Self::NotCharging),
90 2 => Some(Self::Charging),
91 3 => Some(Self::Discharging),
92 4 => Some(Self::Full),
93 _ => None,
94 }
95 }
96
97 #[inline]
98 pub const fn into_primitive(self) -> u32 {
99 self as u32
100 }
101}
102
103#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
105#[repr(u32)]
106pub enum HealthStatus {
107 Unknown = 0,
108 Good = 1,
109 Cold = 2,
110 Hot = 3,
111 Dead = 4,
112 OverVoltage = 5,
113 UnspecifiedFailure = 6,
114 Cool = 7,
115 Warm = 8,
116 Overheat = 9,
117}
118
119impl HealthStatus {
120 #[inline]
121 pub fn from_primitive(prim: u32) -> Option<Self> {
122 match prim {
123 0 => Some(Self::Unknown),
124 1 => Some(Self::Good),
125 2 => Some(Self::Cold),
126 3 => Some(Self::Hot),
127 4 => Some(Self::Dead),
128 5 => Some(Self::OverVoltage),
129 6 => Some(Self::UnspecifiedFailure),
130 7 => Some(Self::Cool),
131 8 => Some(Self::Warm),
132 9 => Some(Self::Overheat),
133 _ => None,
134 }
135 }
136
137 #[inline]
138 pub const fn into_primitive(self) -> u32 {
139 self as u32
140 }
141}
142
143#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
145#[repr(u32)]
146pub enum LevelStatus {
147 Unknown = 0,
148 Ok = 1,
149 Warning = 2,
150 Low = 3,
151 Critical = 4,
152}
153
154impl LevelStatus {
155 #[inline]
156 pub fn from_primitive(prim: u32) -> Option<Self> {
157 match prim {
158 0 => Some(Self::Unknown),
159 1 => Some(Self::Ok),
160 2 => Some(Self::Warning),
161 3 => Some(Self::Low),
162 4 => Some(Self::Critical),
163 _ => None,
164 }
165 }
166
167 #[inline]
168 pub const fn into_primitive(self) -> u32 {
169 self as u32
170 }
171}
172
173#[derive(Clone, Debug, PartialEq)]
174pub struct BatteryInfoProviderGetBatteryInfoResponse {
175 pub info: BatteryInfo,
176}
177
178impl fidl::Persistable for BatteryInfoProviderGetBatteryInfoResponse {}
179
180#[derive(Clone, Debug, Default, PartialEq)]
182pub struct BatteryInfo {
183 pub status: Option<BatteryStatus>,
185 pub charge_status: Option<ChargeStatus>,
187 pub charge_source: Option<ChargeSource>,
191 pub level_percent: Option<f32>,
194 pub level_status: Option<LevelStatus>,
196 pub health: Option<HealthStatus>,
198 pub time_remaining: Option<TimeRemaining>,
200 pub timestamp: Option<i64>,
202 pub present_voltage_mv: Option<u32>,
204 pub remaining_capacity_uah: Option<u32>,
206 pub battery_spec: Option<BatterySpec>,
208 pub full_capacity_uah: Option<i32>,
210 pub temperature_mc: Option<i32>,
212 #[doc(hidden)]
213 pub __source_breaking: fidl::marker::SourceBreaking,
214}
215
216impl fidl::Persistable for BatteryInfo {}
217
218#[derive(Clone, Debug, Default, PartialEq)]
220pub struct BatterySpec {
221 pub max_charging_current_ua: Option<i32>,
223 pub max_charging_voltage_uv: Option<i32>,
225 pub design_capacity_uah: Option<i32>,
227 #[doc(hidden)]
228 pub __source_breaking: fidl::marker::SourceBreaking,
229}
230
231impl fidl::Persistable for BatterySpec {}
232
233#[derive(Clone, Debug)]
235pub enum TimeRemaining {
236 Indeterminate(i64),
238 BatteryLife(i64),
240 FullCharge(i64),
242 #[doc(hidden)]
243 __SourceBreaking { unknown_ordinal: u64 },
244}
245
246#[macro_export]
248macro_rules! TimeRemainingUnknown {
249 () => {
250 _
251 };
252}
253
254impl PartialEq for TimeRemaining {
256 fn eq(&self, other: &Self) -> bool {
257 match (self, other) {
258 (Self::Indeterminate(x), Self::Indeterminate(y)) => *x == *y,
259 (Self::BatteryLife(x), Self::BatteryLife(y)) => *x == *y,
260 (Self::FullCharge(x), Self::FullCharge(y)) => *x == *y,
261 _ => false,
262 }
263 }
264}
265
266impl TimeRemaining {
267 #[inline]
268 pub fn ordinal(&self) -> u64 {
269 match *self {
270 Self::Indeterminate(_) => 1,
271 Self::BatteryLife(_) => 2,
272 Self::FullCharge(_) => 3,
273 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
274 }
275 }
276
277 #[inline]
278 pub fn unknown_variant_for_testing() -> Self {
279 Self::__SourceBreaking { unknown_ordinal: 0 }
280 }
281
282 #[inline]
283 pub fn is_unknown(&self) -> bool {
284 match self {
285 Self::__SourceBreaking { .. } => true,
286 _ => false,
287 }
288 }
289}
290
291impl fidl::Persistable for TimeRemaining {}
292
293pub mod battery_info_provider_ordinals {
294 pub const GET_BATTERY_INFO: u64 = 0x51ea101e4fe7a192;
295 pub const WATCH: u64 = 0x4d44a314cd3f5191;
296}
297
298pub mod battery_info_watcher_ordinals {
299 pub const ON_CHANGE_BATTERY_INFO: u64 = 0x2d1eb8ed2b619a7d;
300}
301
302pub mod battery_manager_ordinals {
303 pub const GET_BATTERY_INFO: u64 = 0x51ea101e4fe7a192;
304 pub const WATCH: u64 = 0x4d44a314cd3f5191;
305}
306
307mod internal {
308 use super::*;
309 unsafe impl fidl::encoding::TypeMarker for BatteryStatus {
310 type Owned = Self;
311
312 #[inline(always)]
313 fn inline_align(_context: fidl::encoding::Context) -> usize {
314 std::mem::align_of::<u32>()
315 }
316
317 #[inline(always)]
318 fn inline_size(_context: fidl::encoding::Context) -> usize {
319 std::mem::size_of::<u32>()
320 }
321
322 #[inline(always)]
323 fn encode_is_copy() -> bool {
324 true
325 }
326
327 #[inline(always)]
328 fn decode_is_copy() -> bool {
329 false
330 }
331 }
332
333 impl fidl::encoding::ValueTypeMarker for BatteryStatus {
334 type Borrowed<'a> = Self;
335 #[inline(always)]
336 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
337 *value
338 }
339 }
340
341 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BatteryStatus {
342 #[inline]
343 unsafe fn encode(
344 self,
345 encoder: &mut fidl::encoding::Encoder<'_, D>,
346 offset: usize,
347 _depth: fidl::encoding::Depth,
348 ) -> fidl::Result<()> {
349 encoder.debug_check_bounds::<Self>(offset);
350 encoder.write_num(self.into_primitive(), offset);
351 Ok(())
352 }
353 }
354
355 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryStatus {
356 #[inline(always)]
357 fn new_empty() -> Self {
358 Self::Unknown
359 }
360
361 #[inline]
362 unsafe fn decode(
363 &mut self,
364 decoder: &mut fidl::encoding::Decoder<'_, D>,
365 offset: usize,
366 _depth: fidl::encoding::Depth,
367 ) -> fidl::Result<()> {
368 decoder.debug_check_bounds::<Self>(offset);
369 let prim = decoder.read_num::<u32>(offset);
370
371 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
372 Ok(())
373 }
374 }
375 unsafe impl fidl::encoding::TypeMarker for ChargeSource {
376 type Owned = Self;
377
378 #[inline(always)]
379 fn inline_align(_context: fidl::encoding::Context) -> usize {
380 std::mem::align_of::<u32>()
381 }
382
383 #[inline(always)]
384 fn inline_size(_context: fidl::encoding::Context) -> usize {
385 std::mem::size_of::<u32>()
386 }
387
388 #[inline(always)]
389 fn encode_is_copy() -> bool {
390 true
391 }
392
393 #[inline(always)]
394 fn decode_is_copy() -> bool {
395 false
396 }
397 }
398
399 impl fidl::encoding::ValueTypeMarker for ChargeSource {
400 type Borrowed<'a> = Self;
401 #[inline(always)]
402 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
403 *value
404 }
405 }
406
407 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ChargeSource {
408 #[inline]
409 unsafe fn encode(
410 self,
411 encoder: &mut fidl::encoding::Encoder<'_, D>,
412 offset: usize,
413 _depth: fidl::encoding::Depth,
414 ) -> fidl::Result<()> {
415 encoder.debug_check_bounds::<Self>(offset);
416 encoder.write_num(self.into_primitive(), offset);
417 Ok(())
418 }
419 }
420
421 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChargeSource {
422 #[inline(always)]
423 fn new_empty() -> Self {
424 Self::Unknown
425 }
426
427 #[inline]
428 unsafe fn decode(
429 &mut self,
430 decoder: &mut fidl::encoding::Decoder<'_, D>,
431 offset: usize,
432 _depth: fidl::encoding::Depth,
433 ) -> fidl::Result<()> {
434 decoder.debug_check_bounds::<Self>(offset);
435 let prim = decoder.read_num::<u32>(offset);
436
437 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
438 Ok(())
439 }
440 }
441 unsafe impl fidl::encoding::TypeMarker for ChargeStatus {
442 type Owned = Self;
443
444 #[inline(always)]
445 fn inline_align(_context: fidl::encoding::Context) -> usize {
446 std::mem::align_of::<u32>()
447 }
448
449 #[inline(always)]
450 fn inline_size(_context: fidl::encoding::Context) -> usize {
451 std::mem::size_of::<u32>()
452 }
453
454 #[inline(always)]
455 fn encode_is_copy() -> bool {
456 true
457 }
458
459 #[inline(always)]
460 fn decode_is_copy() -> bool {
461 false
462 }
463 }
464
465 impl fidl::encoding::ValueTypeMarker for ChargeStatus {
466 type Borrowed<'a> = Self;
467 #[inline(always)]
468 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
469 *value
470 }
471 }
472
473 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ChargeStatus {
474 #[inline]
475 unsafe fn encode(
476 self,
477 encoder: &mut fidl::encoding::Encoder<'_, D>,
478 offset: usize,
479 _depth: fidl::encoding::Depth,
480 ) -> fidl::Result<()> {
481 encoder.debug_check_bounds::<Self>(offset);
482 encoder.write_num(self.into_primitive(), offset);
483 Ok(())
484 }
485 }
486
487 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChargeStatus {
488 #[inline(always)]
489 fn new_empty() -> Self {
490 Self::Unknown
491 }
492
493 #[inline]
494 unsafe fn decode(
495 &mut self,
496 decoder: &mut fidl::encoding::Decoder<'_, D>,
497 offset: usize,
498 _depth: fidl::encoding::Depth,
499 ) -> fidl::Result<()> {
500 decoder.debug_check_bounds::<Self>(offset);
501 let prim = decoder.read_num::<u32>(offset);
502
503 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
504 Ok(())
505 }
506 }
507 unsafe impl fidl::encoding::TypeMarker for HealthStatus {
508 type Owned = Self;
509
510 #[inline(always)]
511 fn inline_align(_context: fidl::encoding::Context) -> usize {
512 std::mem::align_of::<u32>()
513 }
514
515 #[inline(always)]
516 fn inline_size(_context: fidl::encoding::Context) -> usize {
517 std::mem::size_of::<u32>()
518 }
519
520 #[inline(always)]
521 fn encode_is_copy() -> bool {
522 true
523 }
524
525 #[inline(always)]
526 fn decode_is_copy() -> bool {
527 false
528 }
529 }
530
531 impl fidl::encoding::ValueTypeMarker for HealthStatus {
532 type Borrowed<'a> = Self;
533 #[inline(always)]
534 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
535 *value
536 }
537 }
538
539 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HealthStatus {
540 #[inline]
541 unsafe fn encode(
542 self,
543 encoder: &mut fidl::encoding::Encoder<'_, D>,
544 offset: usize,
545 _depth: fidl::encoding::Depth,
546 ) -> fidl::Result<()> {
547 encoder.debug_check_bounds::<Self>(offset);
548 encoder.write_num(self.into_primitive(), offset);
549 Ok(())
550 }
551 }
552
553 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthStatus {
554 #[inline(always)]
555 fn new_empty() -> Self {
556 Self::Unknown
557 }
558
559 #[inline]
560 unsafe fn decode(
561 &mut self,
562 decoder: &mut fidl::encoding::Decoder<'_, D>,
563 offset: usize,
564 _depth: fidl::encoding::Depth,
565 ) -> fidl::Result<()> {
566 decoder.debug_check_bounds::<Self>(offset);
567 let prim = decoder.read_num::<u32>(offset);
568
569 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
570 Ok(())
571 }
572 }
573 unsafe impl fidl::encoding::TypeMarker for LevelStatus {
574 type Owned = Self;
575
576 #[inline(always)]
577 fn inline_align(_context: fidl::encoding::Context) -> usize {
578 std::mem::align_of::<u32>()
579 }
580
581 #[inline(always)]
582 fn inline_size(_context: fidl::encoding::Context) -> usize {
583 std::mem::size_of::<u32>()
584 }
585
586 #[inline(always)]
587 fn encode_is_copy() -> bool {
588 true
589 }
590
591 #[inline(always)]
592 fn decode_is_copy() -> bool {
593 false
594 }
595 }
596
597 impl fidl::encoding::ValueTypeMarker for LevelStatus {
598 type Borrowed<'a> = Self;
599 #[inline(always)]
600 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
601 *value
602 }
603 }
604
605 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LevelStatus {
606 #[inline]
607 unsafe fn encode(
608 self,
609 encoder: &mut fidl::encoding::Encoder<'_, D>,
610 offset: usize,
611 _depth: fidl::encoding::Depth,
612 ) -> fidl::Result<()> {
613 encoder.debug_check_bounds::<Self>(offset);
614 encoder.write_num(self.into_primitive(), offset);
615 Ok(())
616 }
617 }
618
619 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelStatus {
620 #[inline(always)]
621 fn new_empty() -> Self {
622 Self::Unknown
623 }
624
625 #[inline]
626 unsafe fn decode(
627 &mut self,
628 decoder: &mut fidl::encoding::Decoder<'_, D>,
629 offset: usize,
630 _depth: fidl::encoding::Depth,
631 ) -> fidl::Result<()> {
632 decoder.debug_check_bounds::<Self>(offset);
633 let prim = decoder.read_num::<u32>(offset);
634
635 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
636 Ok(())
637 }
638 }
639
640 impl fidl::encoding::ValueTypeMarker for BatteryInfoProviderGetBatteryInfoResponse {
641 type Borrowed<'a> = &'a Self;
642 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
643 value
644 }
645 }
646
647 unsafe impl fidl::encoding::TypeMarker for BatteryInfoProviderGetBatteryInfoResponse {
648 type Owned = Self;
649
650 #[inline(always)]
651 fn inline_align(_context: fidl::encoding::Context) -> usize {
652 8
653 }
654
655 #[inline(always)]
656 fn inline_size(_context: fidl::encoding::Context) -> usize {
657 16
658 }
659 }
660
661 unsafe impl<D: fidl::encoding::ResourceDialect>
662 fidl::encoding::Encode<BatteryInfoProviderGetBatteryInfoResponse, D>
663 for &BatteryInfoProviderGetBatteryInfoResponse
664 {
665 #[inline]
666 unsafe fn encode(
667 self,
668 encoder: &mut fidl::encoding::Encoder<'_, D>,
669 offset: usize,
670 _depth: fidl::encoding::Depth,
671 ) -> fidl::Result<()> {
672 encoder.debug_check_bounds::<BatteryInfoProviderGetBatteryInfoResponse>(offset);
673 fidl::encoding::Encode::<BatteryInfoProviderGetBatteryInfoResponse, D>::encode(
675 (<BatteryInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
676 encoder,
677 offset,
678 _depth,
679 )
680 }
681 }
682 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BatteryInfo, D>>
683 fidl::encoding::Encode<BatteryInfoProviderGetBatteryInfoResponse, D> for (T0,)
684 {
685 #[inline]
686 unsafe fn encode(
687 self,
688 encoder: &mut fidl::encoding::Encoder<'_, D>,
689 offset: usize,
690 depth: fidl::encoding::Depth,
691 ) -> fidl::Result<()> {
692 encoder.debug_check_bounds::<BatteryInfoProviderGetBatteryInfoResponse>(offset);
693 self.0.encode(encoder, offset + 0, depth)?;
697 Ok(())
698 }
699 }
700
701 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
702 for BatteryInfoProviderGetBatteryInfoResponse
703 {
704 #[inline(always)]
705 fn new_empty() -> Self {
706 Self { info: fidl::new_empty!(BatteryInfo, D) }
707 }
708
709 #[inline]
710 unsafe fn decode(
711 &mut self,
712 decoder: &mut fidl::encoding::Decoder<'_, D>,
713 offset: usize,
714 _depth: fidl::encoding::Depth,
715 ) -> fidl::Result<()> {
716 decoder.debug_check_bounds::<Self>(offset);
717 fidl::decode!(BatteryInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
719 Ok(())
720 }
721 }
722
723 impl BatteryInfo {
724 #[inline(always)]
725 fn max_ordinal_present(&self) -> u64 {
726 if let Some(_) = self.temperature_mc {
727 return 13;
728 }
729 if let Some(_) = self.full_capacity_uah {
730 return 12;
731 }
732 if let Some(_) = self.battery_spec {
733 return 11;
734 }
735 if let Some(_) = self.remaining_capacity_uah {
736 return 10;
737 }
738 if let Some(_) = self.present_voltage_mv {
739 return 9;
740 }
741 if let Some(_) = self.timestamp {
742 return 8;
743 }
744 if let Some(_) = self.time_remaining {
745 return 7;
746 }
747 if let Some(_) = self.health {
748 return 6;
749 }
750 if let Some(_) = self.level_status {
751 return 5;
752 }
753 if let Some(_) = self.level_percent {
754 return 4;
755 }
756 if let Some(_) = self.charge_source {
757 return 3;
758 }
759 if let Some(_) = self.charge_status {
760 return 2;
761 }
762 if let Some(_) = self.status {
763 return 1;
764 }
765 0
766 }
767 }
768
769 impl fidl::encoding::ValueTypeMarker for BatteryInfo {
770 type Borrowed<'a> = &'a Self;
771 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
772 value
773 }
774 }
775
776 unsafe impl fidl::encoding::TypeMarker for BatteryInfo {
777 type Owned = Self;
778
779 #[inline(always)]
780 fn inline_align(_context: fidl::encoding::Context) -> usize {
781 8
782 }
783
784 #[inline(always)]
785 fn inline_size(_context: fidl::encoding::Context) -> usize {
786 16
787 }
788 }
789
790 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BatteryInfo, D>
791 for &BatteryInfo
792 {
793 unsafe fn encode(
794 self,
795 encoder: &mut fidl::encoding::Encoder<'_, D>,
796 offset: usize,
797 mut depth: fidl::encoding::Depth,
798 ) -> fidl::Result<()> {
799 encoder.debug_check_bounds::<BatteryInfo>(offset);
800 let max_ordinal: u64 = self.max_ordinal_present();
802 encoder.write_num(max_ordinal, offset);
803 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
804 if max_ordinal == 0 {
806 return Ok(());
807 }
808 depth.increment()?;
809 let envelope_size = 8;
810 let bytes_len = max_ordinal as usize * envelope_size;
811 #[allow(unused_variables)]
812 let offset = encoder.out_of_line_offset(bytes_len);
813 let mut _prev_end_offset: usize = 0;
814 if 1 > max_ordinal {
815 return Ok(());
816 }
817
818 let cur_offset: usize = (1 - 1) * envelope_size;
821
822 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
824
825 fidl::encoding::encode_in_envelope_optional::<BatteryStatus, D>(
830 self.status
831 .as_ref()
832 .map(<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow),
833 encoder,
834 offset + cur_offset,
835 depth,
836 )?;
837
838 _prev_end_offset = cur_offset + envelope_size;
839 if 2 > max_ordinal {
840 return Ok(());
841 }
842
843 let cur_offset: usize = (2 - 1) * envelope_size;
846
847 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
849
850 fidl::encoding::encode_in_envelope_optional::<ChargeStatus, D>(
855 self.charge_status
856 .as_ref()
857 .map(<ChargeStatus as fidl::encoding::ValueTypeMarker>::borrow),
858 encoder,
859 offset + cur_offset,
860 depth,
861 )?;
862
863 _prev_end_offset = cur_offset + envelope_size;
864 if 3 > max_ordinal {
865 return Ok(());
866 }
867
868 let cur_offset: usize = (3 - 1) * envelope_size;
871
872 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
874
875 fidl::encoding::encode_in_envelope_optional::<ChargeSource, D>(
880 self.charge_source
881 .as_ref()
882 .map(<ChargeSource as fidl::encoding::ValueTypeMarker>::borrow),
883 encoder,
884 offset + cur_offset,
885 depth,
886 )?;
887
888 _prev_end_offset = cur_offset + envelope_size;
889 if 4 > max_ordinal {
890 return Ok(());
891 }
892
893 let cur_offset: usize = (4 - 1) * envelope_size;
896
897 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
899
900 fidl::encoding::encode_in_envelope_optional::<f32, D>(
905 self.level_percent.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
906 encoder,
907 offset + cur_offset,
908 depth,
909 )?;
910
911 _prev_end_offset = cur_offset + envelope_size;
912 if 5 > max_ordinal {
913 return Ok(());
914 }
915
916 let cur_offset: usize = (5 - 1) * envelope_size;
919
920 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
922
923 fidl::encoding::encode_in_envelope_optional::<LevelStatus, D>(
928 self.level_status
929 .as_ref()
930 .map(<LevelStatus as fidl::encoding::ValueTypeMarker>::borrow),
931 encoder,
932 offset + cur_offset,
933 depth,
934 )?;
935
936 _prev_end_offset = cur_offset + envelope_size;
937 if 6 > max_ordinal {
938 return Ok(());
939 }
940
941 let cur_offset: usize = (6 - 1) * envelope_size;
944
945 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
947
948 fidl::encoding::encode_in_envelope_optional::<HealthStatus, D>(
953 self.health.as_ref().map(<HealthStatus as fidl::encoding::ValueTypeMarker>::borrow),
954 encoder,
955 offset + cur_offset,
956 depth,
957 )?;
958
959 _prev_end_offset = cur_offset + envelope_size;
960 if 7 > max_ordinal {
961 return Ok(());
962 }
963
964 let cur_offset: usize = (7 - 1) * envelope_size;
967
968 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
970
971 fidl::encoding::encode_in_envelope_optional::<TimeRemaining, D>(
976 self.time_remaining
977 .as_ref()
978 .map(<TimeRemaining as fidl::encoding::ValueTypeMarker>::borrow),
979 encoder,
980 offset + cur_offset,
981 depth,
982 )?;
983
984 _prev_end_offset = cur_offset + envelope_size;
985 if 8 > max_ordinal {
986 return Ok(());
987 }
988
989 let cur_offset: usize = (8 - 1) * envelope_size;
992
993 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
995
996 fidl::encoding::encode_in_envelope_optional::<i64, D>(
1001 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1002 encoder,
1003 offset + cur_offset,
1004 depth,
1005 )?;
1006
1007 _prev_end_offset = cur_offset + envelope_size;
1008 if 9 > max_ordinal {
1009 return Ok(());
1010 }
1011
1012 let cur_offset: usize = (9 - 1) * envelope_size;
1015
1016 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1018
1019 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1024 self.present_voltage_mv
1025 .as_ref()
1026 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1027 encoder,
1028 offset + cur_offset,
1029 depth,
1030 )?;
1031
1032 _prev_end_offset = cur_offset + envelope_size;
1033 if 10 > max_ordinal {
1034 return Ok(());
1035 }
1036
1037 let cur_offset: usize = (10 - 1) * envelope_size;
1040
1041 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1043
1044 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1049 self.remaining_capacity_uah
1050 .as_ref()
1051 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1052 encoder,
1053 offset + cur_offset,
1054 depth,
1055 )?;
1056
1057 _prev_end_offset = cur_offset + envelope_size;
1058 if 11 > max_ordinal {
1059 return Ok(());
1060 }
1061
1062 let cur_offset: usize = (11 - 1) * envelope_size;
1065
1066 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1068
1069 fidl::encoding::encode_in_envelope_optional::<BatterySpec, D>(
1074 self.battery_spec
1075 .as_ref()
1076 .map(<BatterySpec as fidl::encoding::ValueTypeMarker>::borrow),
1077 encoder,
1078 offset + cur_offset,
1079 depth,
1080 )?;
1081
1082 _prev_end_offset = cur_offset + envelope_size;
1083 if 12 > max_ordinal {
1084 return Ok(());
1085 }
1086
1087 let cur_offset: usize = (12 - 1) * envelope_size;
1090
1091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1093
1094 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1099 self.full_capacity_uah
1100 .as_ref()
1101 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1102 encoder,
1103 offset + cur_offset,
1104 depth,
1105 )?;
1106
1107 _prev_end_offset = cur_offset + envelope_size;
1108 if 13 > max_ordinal {
1109 return Ok(());
1110 }
1111
1112 let cur_offset: usize = (13 - 1) * envelope_size;
1115
1116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1118
1119 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1124 self.temperature_mc.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1125 encoder,
1126 offset + cur_offset,
1127 depth,
1128 )?;
1129
1130 _prev_end_offset = cur_offset + envelope_size;
1131
1132 Ok(())
1133 }
1134 }
1135
1136 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryInfo {
1137 #[inline(always)]
1138 fn new_empty() -> Self {
1139 Self::default()
1140 }
1141
1142 unsafe fn decode(
1143 &mut self,
1144 decoder: &mut fidl::encoding::Decoder<'_, D>,
1145 offset: usize,
1146 mut depth: fidl::encoding::Depth,
1147 ) -> fidl::Result<()> {
1148 decoder.debug_check_bounds::<Self>(offset);
1149 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1150 None => return Err(fidl::Error::NotNullable),
1151 Some(len) => len,
1152 };
1153 if len == 0 {
1155 return Ok(());
1156 };
1157 depth.increment()?;
1158 let envelope_size = 8;
1159 let bytes_len = len * envelope_size;
1160 let offset = decoder.out_of_line_offset(bytes_len)?;
1161 let mut _next_ordinal_to_read = 0;
1163 let mut next_offset = offset;
1164 let end_offset = offset + bytes_len;
1165 _next_ordinal_to_read += 1;
1166 if next_offset >= end_offset {
1167 return Ok(());
1168 }
1169
1170 while _next_ordinal_to_read < 1 {
1172 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1173 _next_ordinal_to_read += 1;
1174 next_offset += envelope_size;
1175 }
1176
1177 let next_out_of_line = decoder.next_out_of_line();
1178 let handles_before = decoder.remaining_handles();
1179 if let Some((inlined, num_bytes, num_handles)) =
1180 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1181 {
1182 let member_inline_size =
1183 <BatteryStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1184 if inlined != (member_inline_size <= 4) {
1185 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1186 }
1187 let inner_offset;
1188 let mut inner_depth = depth.clone();
1189 if inlined {
1190 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1191 inner_offset = next_offset;
1192 } else {
1193 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1194 inner_depth.increment()?;
1195 }
1196 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(BatteryStatus, D));
1197 fidl::decode!(BatteryStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1198 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1199 {
1200 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1201 }
1202 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1203 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1204 }
1205 }
1206
1207 next_offset += envelope_size;
1208 _next_ordinal_to_read += 1;
1209 if next_offset >= end_offset {
1210 return Ok(());
1211 }
1212
1213 while _next_ordinal_to_read < 2 {
1215 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1216 _next_ordinal_to_read += 1;
1217 next_offset += envelope_size;
1218 }
1219
1220 let next_out_of_line = decoder.next_out_of_line();
1221 let handles_before = decoder.remaining_handles();
1222 if let Some((inlined, num_bytes, num_handles)) =
1223 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1224 {
1225 let member_inline_size =
1226 <ChargeStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1227 if inlined != (member_inline_size <= 4) {
1228 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1229 }
1230 let inner_offset;
1231 let mut inner_depth = depth.clone();
1232 if inlined {
1233 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1234 inner_offset = next_offset;
1235 } else {
1236 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1237 inner_depth.increment()?;
1238 }
1239 let val_ref =
1240 self.charge_status.get_or_insert_with(|| fidl::new_empty!(ChargeStatus, D));
1241 fidl::decode!(ChargeStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1242 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1243 {
1244 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1245 }
1246 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1247 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1248 }
1249 }
1250
1251 next_offset += envelope_size;
1252 _next_ordinal_to_read += 1;
1253 if next_offset >= end_offset {
1254 return Ok(());
1255 }
1256
1257 while _next_ordinal_to_read < 3 {
1259 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1260 _next_ordinal_to_read += 1;
1261 next_offset += envelope_size;
1262 }
1263
1264 let next_out_of_line = decoder.next_out_of_line();
1265 let handles_before = decoder.remaining_handles();
1266 if let Some((inlined, num_bytes, num_handles)) =
1267 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1268 {
1269 let member_inline_size =
1270 <ChargeSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1271 if inlined != (member_inline_size <= 4) {
1272 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1273 }
1274 let inner_offset;
1275 let mut inner_depth = depth.clone();
1276 if inlined {
1277 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1278 inner_offset = next_offset;
1279 } else {
1280 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1281 inner_depth.increment()?;
1282 }
1283 let val_ref =
1284 self.charge_source.get_or_insert_with(|| fidl::new_empty!(ChargeSource, D));
1285 fidl::decode!(ChargeSource, D, val_ref, decoder, inner_offset, inner_depth)?;
1286 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1287 {
1288 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1289 }
1290 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1291 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1292 }
1293 }
1294
1295 next_offset += envelope_size;
1296 _next_ordinal_to_read += 1;
1297 if next_offset >= end_offset {
1298 return Ok(());
1299 }
1300
1301 while _next_ordinal_to_read < 4 {
1303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1304 _next_ordinal_to_read += 1;
1305 next_offset += envelope_size;
1306 }
1307
1308 let next_out_of_line = decoder.next_out_of_line();
1309 let handles_before = decoder.remaining_handles();
1310 if let Some((inlined, num_bytes, num_handles)) =
1311 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1312 {
1313 let member_inline_size =
1314 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1315 if inlined != (member_inline_size <= 4) {
1316 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1317 }
1318 let inner_offset;
1319 let mut inner_depth = depth.clone();
1320 if inlined {
1321 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1322 inner_offset = next_offset;
1323 } else {
1324 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1325 inner_depth.increment()?;
1326 }
1327 let val_ref = self.level_percent.get_or_insert_with(|| fidl::new_empty!(f32, D));
1328 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
1329 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1330 {
1331 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1332 }
1333 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1334 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1335 }
1336 }
1337
1338 next_offset += envelope_size;
1339 _next_ordinal_to_read += 1;
1340 if next_offset >= end_offset {
1341 return Ok(());
1342 }
1343
1344 while _next_ordinal_to_read < 5 {
1346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1347 _next_ordinal_to_read += 1;
1348 next_offset += envelope_size;
1349 }
1350
1351 let next_out_of_line = decoder.next_out_of_line();
1352 let handles_before = decoder.remaining_handles();
1353 if let Some((inlined, num_bytes, num_handles)) =
1354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1355 {
1356 let member_inline_size =
1357 <LevelStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1358 if inlined != (member_inline_size <= 4) {
1359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1360 }
1361 let inner_offset;
1362 let mut inner_depth = depth.clone();
1363 if inlined {
1364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1365 inner_offset = next_offset;
1366 } else {
1367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1368 inner_depth.increment()?;
1369 }
1370 let val_ref =
1371 self.level_status.get_or_insert_with(|| fidl::new_empty!(LevelStatus, D));
1372 fidl::decode!(LevelStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1373 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1374 {
1375 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1376 }
1377 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1378 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1379 }
1380 }
1381
1382 next_offset += envelope_size;
1383 _next_ordinal_to_read += 1;
1384 if next_offset >= end_offset {
1385 return Ok(());
1386 }
1387
1388 while _next_ordinal_to_read < 6 {
1390 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1391 _next_ordinal_to_read += 1;
1392 next_offset += envelope_size;
1393 }
1394
1395 let next_out_of_line = decoder.next_out_of_line();
1396 let handles_before = decoder.remaining_handles();
1397 if let Some((inlined, num_bytes, num_handles)) =
1398 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1399 {
1400 let member_inline_size =
1401 <HealthStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1402 if inlined != (member_inline_size <= 4) {
1403 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1404 }
1405 let inner_offset;
1406 let mut inner_depth = depth.clone();
1407 if inlined {
1408 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1409 inner_offset = next_offset;
1410 } else {
1411 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1412 inner_depth.increment()?;
1413 }
1414 let val_ref = self.health.get_or_insert_with(|| fidl::new_empty!(HealthStatus, D));
1415 fidl::decode!(HealthStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1417 {
1418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1419 }
1420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1422 }
1423 }
1424
1425 next_offset += envelope_size;
1426 _next_ordinal_to_read += 1;
1427 if next_offset >= end_offset {
1428 return Ok(());
1429 }
1430
1431 while _next_ordinal_to_read < 7 {
1433 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1434 _next_ordinal_to_read += 1;
1435 next_offset += envelope_size;
1436 }
1437
1438 let next_out_of_line = decoder.next_out_of_line();
1439 let handles_before = decoder.remaining_handles();
1440 if let Some((inlined, num_bytes, num_handles)) =
1441 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1442 {
1443 let member_inline_size =
1444 <TimeRemaining as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1445 if inlined != (member_inline_size <= 4) {
1446 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1447 }
1448 let inner_offset;
1449 let mut inner_depth = depth.clone();
1450 if inlined {
1451 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1452 inner_offset = next_offset;
1453 } else {
1454 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1455 inner_depth.increment()?;
1456 }
1457 let val_ref =
1458 self.time_remaining.get_or_insert_with(|| fidl::new_empty!(TimeRemaining, D));
1459 fidl::decode!(TimeRemaining, D, val_ref, decoder, inner_offset, inner_depth)?;
1460 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1461 {
1462 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1463 }
1464 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1465 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1466 }
1467 }
1468
1469 next_offset += envelope_size;
1470 _next_ordinal_to_read += 1;
1471 if next_offset >= end_offset {
1472 return Ok(());
1473 }
1474
1475 while _next_ordinal_to_read < 8 {
1477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1478 _next_ordinal_to_read += 1;
1479 next_offset += envelope_size;
1480 }
1481
1482 let next_out_of_line = decoder.next_out_of_line();
1483 let handles_before = decoder.remaining_handles();
1484 if let Some((inlined, num_bytes, num_handles)) =
1485 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1486 {
1487 let member_inline_size =
1488 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1489 if inlined != (member_inline_size <= 4) {
1490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1491 }
1492 let inner_offset;
1493 let mut inner_depth = depth.clone();
1494 if inlined {
1495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1496 inner_offset = next_offset;
1497 } else {
1498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1499 inner_depth.increment()?;
1500 }
1501 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
1502 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1503 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1504 {
1505 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1506 }
1507 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1508 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1509 }
1510 }
1511
1512 next_offset += envelope_size;
1513 _next_ordinal_to_read += 1;
1514 if next_offset >= end_offset {
1515 return Ok(());
1516 }
1517
1518 while _next_ordinal_to_read < 9 {
1520 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1521 _next_ordinal_to_read += 1;
1522 next_offset += envelope_size;
1523 }
1524
1525 let next_out_of_line = decoder.next_out_of_line();
1526 let handles_before = decoder.remaining_handles();
1527 if let Some((inlined, num_bytes, num_handles)) =
1528 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1529 {
1530 let member_inline_size =
1531 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1532 if inlined != (member_inline_size <= 4) {
1533 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1534 }
1535 let inner_offset;
1536 let mut inner_depth = depth.clone();
1537 if inlined {
1538 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1539 inner_offset = next_offset;
1540 } else {
1541 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1542 inner_depth.increment()?;
1543 }
1544 let val_ref =
1545 self.present_voltage_mv.get_or_insert_with(|| fidl::new_empty!(u32, D));
1546 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1547 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1548 {
1549 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1550 }
1551 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1552 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1553 }
1554 }
1555
1556 next_offset += envelope_size;
1557 _next_ordinal_to_read += 1;
1558 if next_offset >= end_offset {
1559 return Ok(());
1560 }
1561
1562 while _next_ordinal_to_read < 10 {
1564 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1565 _next_ordinal_to_read += 1;
1566 next_offset += envelope_size;
1567 }
1568
1569 let next_out_of_line = decoder.next_out_of_line();
1570 let handles_before = decoder.remaining_handles();
1571 if let Some((inlined, num_bytes, num_handles)) =
1572 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1573 {
1574 let member_inline_size =
1575 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1576 if inlined != (member_inline_size <= 4) {
1577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1578 }
1579 let inner_offset;
1580 let mut inner_depth = depth.clone();
1581 if inlined {
1582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1583 inner_offset = next_offset;
1584 } else {
1585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1586 inner_depth.increment()?;
1587 }
1588 let val_ref =
1589 self.remaining_capacity_uah.get_or_insert_with(|| fidl::new_empty!(u32, D));
1590 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1592 {
1593 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1594 }
1595 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1596 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1597 }
1598 }
1599
1600 next_offset += envelope_size;
1601 _next_ordinal_to_read += 1;
1602 if next_offset >= end_offset {
1603 return Ok(());
1604 }
1605
1606 while _next_ordinal_to_read < 11 {
1608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1609 _next_ordinal_to_read += 1;
1610 next_offset += envelope_size;
1611 }
1612
1613 let next_out_of_line = decoder.next_out_of_line();
1614 let handles_before = decoder.remaining_handles();
1615 if let Some((inlined, num_bytes, num_handles)) =
1616 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1617 {
1618 let member_inline_size =
1619 <BatterySpec as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1620 if inlined != (member_inline_size <= 4) {
1621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1622 }
1623 let inner_offset;
1624 let mut inner_depth = depth.clone();
1625 if inlined {
1626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1627 inner_offset = next_offset;
1628 } else {
1629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1630 inner_depth.increment()?;
1631 }
1632 let val_ref =
1633 self.battery_spec.get_or_insert_with(|| fidl::new_empty!(BatterySpec, D));
1634 fidl::decode!(BatterySpec, D, val_ref, decoder, inner_offset, inner_depth)?;
1635 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1636 {
1637 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1638 }
1639 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1640 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1641 }
1642 }
1643
1644 next_offset += envelope_size;
1645 _next_ordinal_to_read += 1;
1646 if next_offset >= end_offset {
1647 return Ok(());
1648 }
1649
1650 while _next_ordinal_to_read < 12 {
1652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1653 _next_ordinal_to_read += 1;
1654 next_offset += envelope_size;
1655 }
1656
1657 let next_out_of_line = decoder.next_out_of_line();
1658 let handles_before = decoder.remaining_handles();
1659 if let Some((inlined, num_bytes, num_handles)) =
1660 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1661 {
1662 let member_inline_size =
1663 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1664 if inlined != (member_inline_size <= 4) {
1665 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1666 }
1667 let inner_offset;
1668 let mut inner_depth = depth.clone();
1669 if inlined {
1670 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1671 inner_offset = next_offset;
1672 } else {
1673 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1674 inner_depth.increment()?;
1675 }
1676 let val_ref =
1677 self.full_capacity_uah.get_or_insert_with(|| fidl::new_empty!(i32, D));
1678 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1679 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1680 {
1681 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1682 }
1683 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1684 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1685 }
1686 }
1687
1688 next_offset += envelope_size;
1689 _next_ordinal_to_read += 1;
1690 if next_offset >= end_offset {
1691 return Ok(());
1692 }
1693
1694 while _next_ordinal_to_read < 13 {
1696 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1697 _next_ordinal_to_read += 1;
1698 next_offset += envelope_size;
1699 }
1700
1701 let next_out_of_line = decoder.next_out_of_line();
1702 let handles_before = decoder.remaining_handles();
1703 if let Some((inlined, num_bytes, num_handles)) =
1704 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1705 {
1706 let member_inline_size =
1707 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1708 if inlined != (member_inline_size <= 4) {
1709 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1710 }
1711 let inner_offset;
1712 let mut inner_depth = depth.clone();
1713 if inlined {
1714 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1715 inner_offset = next_offset;
1716 } else {
1717 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1718 inner_depth.increment()?;
1719 }
1720 let val_ref = self.temperature_mc.get_or_insert_with(|| fidl::new_empty!(i32, D));
1721 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1723 {
1724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1725 }
1726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1728 }
1729 }
1730
1731 next_offset += envelope_size;
1732
1733 while next_offset < end_offset {
1735 _next_ordinal_to_read += 1;
1736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1737 next_offset += envelope_size;
1738 }
1739
1740 Ok(())
1741 }
1742 }
1743
1744 impl BatterySpec {
1745 #[inline(always)]
1746 fn max_ordinal_present(&self) -> u64 {
1747 if let Some(_) = self.design_capacity_uah {
1748 return 3;
1749 }
1750 if let Some(_) = self.max_charging_voltage_uv {
1751 return 2;
1752 }
1753 if let Some(_) = self.max_charging_current_ua {
1754 return 1;
1755 }
1756 0
1757 }
1758 }
1759
1760 impl fidl::encoding::ValueTypeMarker for BatterySpec {
1761 type Borrowed<'a> = &'a Self;
1762 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1763 value
1764 }
1765 }
1766
1767 unsafe impl fidl::encoding::TypeMarker for BatterySpec {
1768 type Owned = Self;
1769
1770 #[inline(always)]
1771 fn inline_align(_context: fidl::encoding::Context) -> usize {
1772 8
1773 }
1774
1775 #[inline(always)]
1776 fn inline_size(_context: fidl::encoding::Context) -> usize {
1777 16
1778 }
1779 }
1780
1781 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BatterySpec, D>
1782 for &BatterySpec
1783 {
1784 unsafe fn encode(
1785 self,
1786 encoder: &mut fidl::encoding::Encoder<'_, D>,
1787 offset: usize,
1788 mut depth: fidl::encoding::Depth,
1789 ) -> fidl::Result<()> {
1790 encoder.debug_check_bounds::<BatterySpec>(offset);
1791 let max_ordinal: u64 = self.max_ordinal_present();
1793 encoder.write_num(max_ordinal, offset);
1794 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1795 if max_ordinal == 0 {
1797 return Ok(());
1798 }
1799 depth.increment()?;
1800 let envelope_size = 8;
1801 let bytes_len = max_ordinal as usize * envelope_size;
1802 #[allow(unused_variables)]
1803 let offset = encoder.out_of_line_offset(bytes_len);
1804 let mut _prev_end_offset: usize = 0;
1805 if 1 > max_ordinal {
1806 return Ok(());
1807 }
1808
1809 let cur_offset: usize = (1 - 1) * envelope_size;
1812
1813 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1815
1816 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1821 self.max_charging_current_ua
1822 .as_ref()
1823 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1824 encoder,
1825 offset + cur_offset,
1826 depth,
1827 )?;
1828
1829 _prev_end_offset = cur_offset + envelope_size;
1830 if 2 > max_ordinal {
1831 return Ok(());
1832 }
1833
1834 let cur_offset: usize = (2 - 1) * envelope_size;
1837
1838 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1840
1841 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1846 self.max_charging_voltage_uv
1847 .as_ref()
1848 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1849 encoder,
1850 offset + cur_offset,
1851 depth,
1852 )?;
1853
1854 _prev_end_offset = cur_offset + envelope_size;
1855 if 3 > max_ordinal {
1856 return Ok(());
1857 }
1858
1859 let cur_offset: usize = (3 - 1) * envelope_size;
1862
1863 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1865
1866 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1871 self.design_capacity_uah
1872 .as_ref()
1873 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1874 encoder,
1875 offset + cur_offset,
1876 depth,
1877 )?;
1878
1879 _prev_end_offset = cur_offset + envelope_size;
1880
1881 Ok(())
1882 }
1883 }
1884
1885 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatterySpec {
1886 #[inline(always)]
1887 fn new_empty() -> Self {
1888 Self::default()
1889 }
1890
1891 unsafe fn decode(
1892 &mut self,
1893 decoder: &mut fidl::encoding::Decoder<'_, D>,
1894 offset: usize,
1895 mut depth: fidl::encoding::Depth,
1896 ) -> fidl::Result<()> {
1897 decoder.debug_check_bounds::<Self>(offset);
1898 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1899 None => return Err(fidl::Error::NotNullable),
1900 Some(len) => len,
1901 };
1902 if len == 0 {
1904 return Ok(());
1905 };
1906 depth.increment()?;
1907 let envelope_size = 8;
1908 let bytes_len = len * envelope_size;
1909 let offset = decoder.out_of_line_offset(bytes_len)?;
1910 let mut _next_ordinal_to_read = 0;
1912 let mut next_offset = offset;
1913 let end_offset = offset + bytes_len;
1914 _next_ordinal_to_read += 1;
1915 if next_offset >= end_offset {
1916 return Ok(());
1917 }
1918
1919 while _next_ordinal_to_read < 1 {
1921 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1922 _next_ordinal_to_read += 1;
1923 next_offset += envelope_size;
1924 }
1925
1926 let next_out_of_line = decoder.next_out_of_line();
1927 let handles_before = decoder.remaining_handles();
1928 if let Some((inlined, num_bytes, num_handles)) =
1929 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1930 {
1931 let member_inline_size =
1932 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1933 if inlined != (member_inline_size <= 4) {
1934 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1935 }
1936 let inner_offset;
1937 let mut inner_depth = depth.clone();
1938 if inlined {
1939 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1940 inner_offset = next_offset;
1941 } else {
1942 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1943 inner_depth.increment()?;
1944 }
1945 let val_ref =
1946 self.max_charging_current_ua.get_or_insert_with(|| fidl::new_empty!(i32, D));
1947 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1948 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1949 {
1950 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1951 }
1952 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1953 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1954 }
1955 }
1956
1957 next_offset += envelope_size;
1958 _next_ordinal_to_read += 1;
1959 if next_offset >= end_offset {
1960 return Ok(());
1961 }
1962
1963 while _next_ordinal_to_read < 2 {
1965 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1966 _next_ordinal_to_read += 1;
1967 next_offset += envelope_size;
1968 }
1969
1970 let next_out_of_line = decoder.next_out_of_line();
1971 let handles_before = decoder.remaining_handles();
1972 if let Some((inlined, num_bytes, num_handles)) =
1973 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1974 {
1975 let member_inline_size =
1976 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1977 if inlined != (member_inline_size <= 4) {
1978 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1979 }
1980 let inner_offset;
1981 let mut inner_depth = depth.clone();
1982 if inlined {
1983 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1984 inner_offset = next_offset;
1985 } else {
1986 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1987 inner_depth.increment()?;
1988 }
1989 let val_ref =
1990 self.max_charging_voltage_uv.get_or_insert_with(|| fidl::new_empty!(i32, D));
1991 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1992 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1993 {
1994 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1995 }
1996 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1997 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1998 }
1999 }
2000
2001 next_offset += envelope_size;
2002 _next_ordinal_to_read += 1;
2003 if next_offset >= end_offset {
2004 return Ok(());
2005 }
2006
2007 while _next_ordinal_to_read < 3 {
2009 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2010 _next_ordinal_to_read += 1;
2011 next_offset += envelope_size;
2012 }
2013
2014 let next_out_of_line = decoder.next_out_of_line();
2015 let handles_before = decoder.remaining_handles();
2016 if let Some((inlined, num_bytes, num_handles)) =
2017 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2018 {
2019 let member_inline_size =
2020 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2021 if inlined != (member_inline_size <= 4) {
2022 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2023 }
2024 let inner_offset;
2025 let mut inner_depth = depth.clone();
2026 if inlined {
2027 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2028 inner_offset = next_offset;
2029 } else {
2030 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2031 inner_depth.increment()?;
2032 }
2033 let val_ref =
2034 self.design_capacity_uah.get_or_insert_with(|| fidl::new_empty!(i32, D));
2035 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2036 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2037 {
2038 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2039 }
2040 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2041 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2042 }
2043 }
2044
2045 next_offset += envelope_size;
2046
2047 while next_offset < end_offset {
2049 _next_ordinal_to_read += 1;
2050 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2051 next_offset += envelope_size;
2052 }
2053
2054 Ok(())
2055 }
2056 }
2057
2058 impl fidl::encoding::ValueTypeMarker for TimeRemaining {
2059 type Borrowed<'a> = &'a Self;
2060 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2061 value
2062 }
2063 }
2064
2065 unsafe impl fidl::encoding::TypeMarker for TimeRemaining {
2066 type Owned = Self;
2067
2068 #[inline(always)]
2069 fn inline_align(_context: fidl::encoding::Context) -> usize {
2070 8
2071 }
2072
2073 #[inline(always)]
2074 fn inline_size(_context: fidl::encoding::Context) -> usize {
2075 16
2076 }
2077 }
2078
2079 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TimeRemaining, D>
2080 for &TimeRemaining
2081 {
2082 #[inline]
2083 unsafe fn encode(
2084 self,
2085 encoder: &mut fidl::encoding::Encoder<'_, D>,
2086 offset: usize,
2087 _depth: fidl::encoding::Depth,
2088 ) -> fidl::Result<()> {
2089 encoder.debug_check_bounds::<TimeRemaining>(offset);
2090 encoder.write_num::<u64>(self.ordinal(), offset);
2091 match self {
2092 TimeRemaining::Indeterminate(ref val) => {
2093 fidl::encoding::encode_in_envelope::<i64, D>(
2094 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2095 encoder,
2096 offset + 8,
2097 _depth,
2098 )
2099 }
2100 TimeRemaining::BatteryLife(ref val) => {
2101 fidl::encoding::encode_in_envelope::<i64, D>(
2102 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2103 encoder,
2104 offset + 8,
2105 _depth,
2106 )
2107 }
2108 TimeRemaining::FullCharge(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
2109 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2110 encoder,
2111 offset + 8,
2112 _depth,
2113 ),
2114 TimeRemaining::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
2115 }
2116 }
2117 }
2118
2119 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TimeRemaining {
2120 #[inline(always)]
2121 fn new_empty() -> Self {
2122 Self::__SourceBreaking { unknown_ordinal: 0 }
2123 }
2124
2125 #[inline]
2126 unsafe fn decode(
2127 &mut self,
2128 decoder: &mut fidl::encoding::Decoder<'_, D>,
2129 offset: usize,
2130 mut depth: fidl::encoding::Depth,
2131 ) -> fidl::Result<()> {
2132 decoder.debug_check_bounds::<Self>(offset);
2133 #[allow(unused_variables)]
2134 let next_out_of_line = decoder.next_out_of_line();
2135 let handles_before = decoder.remaining_handles();
2136 let (ordinal, inlined, num_bytes, num_handles) =
2137 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2138
2139 let member_inline_size = match ordinal {
2140 1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2141 2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2142 3 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2143 0 => return Err(fidl::Error::UnknownUnionTag),
2144 _ => num_bytes as usize,
2145 };
2146
2147 if inlined != (member_inline_size <= 4) {
2148 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2149 }
2150 let _inner_offset;
2151 if inlined {
2152 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2153 _inner_offset = offset + 8;
2154 } else {
2155 depth.increment()?;
2156 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2157 }
2158 match ordinal {
2159 1 => {
2160 #[allow(irrefutable_let_patterns)]
2161 if let TimeRemaining::Indeterminate(_) = self {
2162 } else {
2164 *self = TimeRemaining::Indeterminate(fidl::new_empty!(i64, D));
2166 }
2167 #[allow(irrefutable_let_patterns)]
2168 if let TimeRemaining::Indeterminate(ref mut val) = self {
2169 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2170 } else {
2171 unreachable!()
2172 }
2173 }
2174 2 => {
2175 #[allow(irrefutable_let_patterns)]
2176 if let TimeRemaining::BatteryLife(_) = self {
2177 } else {
2179 *self = TimeRemaining::BatteryLife(fidl::new_empty!(i64, D));
2181 }
2182 #[allow(irrefutable_let_patterns)]
2183 if let TimeRemaining::BatteryLife(ref mut val) = self {
2184 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2185 } else {
2186 unreachable!()
2187 }
2188 }
2189 3 => {
2190 #[allow(irrefutable_let_patterns)]
2191 if let TimeRemaining::FullCharge(_) = self {
2192 } else {
2194 *self = TimeRemaining::FullCharge(fidl::new_empty!(i64, D));
2196 }
2197 #[allow(irrefutable_let_patterns)]
2198 if let TimeRemaining::FullCharge(ref mut val) = self {
2199 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2200 } else {
2201 unreachable!()
2202 }
2203 }
2204 #[allow(deprecated)]
2205 ordinal => {
2206 for _ in 0..num_handles {
2207 decoder.drop_next_handle()?;
2208 }
2209 *self = TimeRemaining::__SourceBreaking { unknown_ordinal: ordinal };
2210 }
2211 }
2212 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2214 }
2215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2217 }
2218 Ok(())
2219 }
2220 }
2221}