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 pub present_current_ma: Option<i32>,
214 #[doc(hidden)]
215 pub __source_breaking: fidl::marker::SourceBreaking,
216}
217
218impl fidl::Persistable for BatteryInfo {}
219
220#[derive(Clone, Debug, Default, PartialEq)]
222pub struct BatterySpec {
223 pub max_charging_current_ua: Option<i32>,
225 pub max_charging_voltage_uv: Option<i32>,
227 pub design_capacity_uah: Option<i32>,
229 #[doc(hidden)]
230 pub __source_breaking: fidl::marker::SourceBreaking,
231}
232
233impl fidl::Persistable for BatterySpec {}
234
235#[derive(Clone, Debug)]
237pub enum TimeRemaining {
238 Indeterminate(i64),
240 BatteryLife(i64),
242 FullCharge(i64),
244 #[doc(hidden)]
245 __SourceBreaking { unknown_ordinal: u64 },
246}
247
248#[macro_export]
250macro_rules! TimeRemainingUnknown {
251 () => {
252 _
253 };
254}
255
256impl PartialEq for TimeRemaining {
258 fn eq(&self, other: &Self) -> bool {
259 match (self, other) {
260 (Self::Indeterminate(x), Self::Indeterminate(y)) => *x == *y,
261 (Self::BatteryLife(x), Self::BatteryLife(y)) => *x == *y,
262 (Self::FullCharge(x), Self::FullCharge(y)) => *x == *y,
263 _ => false,
264 }
265 }
266}
267
268impl TimeRemaining {
269 #[inline]
270 pub fn ordinal(&self) -> u64 {
271 match *self {
272 Self::Indeterminate(_) => 1,
273 Self::BatteryLife(_) => 2,
274 Self::FullCharge(_) => 3,
275 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
276 }
277 }
278
279 #[inline]
280 pub fn unknown_variant_for_testing() -> Self {
281 Self::__SourceBreaking { unknown_ordinal: 0 }
282 }
283
284 #[inline]
285 pub fn is_unknown(&self) -> bool {
286 match self {
287 Self::__SourceBreaking { .. } => true,
288 _ => false,
289 }
290 }
291}
292
293impl fidl::Persistable for TimeRemaining {}
294
295pub mod battery_info_provider_ordinals {
296 pub const GET_BATTERY_INFO: u64 = 0x51ea101e4fe7a192;
297 pub const WATCH: u64 = 0x4d44a314cd3f5191;
298}
299
300pub mod battery_info_watcher_ordinals {
301 pub const ON_CHANGE_BATTERY_INFO: u64 = 0x2d1eb8ed2b619a7d;
302}
303
304pub mod battery_manager_ordinals {
305 pub const GET_BATTERY_INFO: u64 = 0x51ea101e4fe7a192;
306 pub const WATCH: u64 = 0x4d44a314cd3f5191;
307}
308
309mod internal {
310 use super::*;
311 unsafe impl fidl::encoding::TypeMarker for BatteryStatus {
312 type Owned = Self;
313
314 #[inline(always)]
315 fn inline_align(_context: fidl::encoding::Context) -> usize {
316 std::mem::align_of::<u32>()
317 }
318
319 #[inline(always)]
320 fn inline_size(_context: fidl::encoding::Context) -> usize {
321 std::mem::size_of::<u32>()
322 }
323
324 #[inline(always)]
325 fn encode_is_copy() -> bool {
326 true
327 }
328
329 #[inline(always)]
330 fn decode_is_copy() -> bool {
331 false
332 }
333 }
334
335 impl fidl::encoding::ValueTypeMarker for BatteryStatus {
336 type Borrowed<'a> = Self;
337 #[inline(always)]
338 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
339 *value
340 }
341 }
342
343 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BatteryStatus {
344 #[inline]
345 unsafe fn encode(
346 self,
347 encoder: &mut fidl::encoding::Encoder<'_, D>,
348 offset: usize,
349 _depth: fidl::encoding::Depth,
350 ) -> fidl::Result<()> {
351 encoder.debug_check_bounds::<Self>(offset);
352 encoder.write_num(self.into_primitive(), offset);
353 Ok(())
354 }
355 }
356
357 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryStatus {
358 #[inline(always)]
359 fn new_empty() -> Self {
360 Self::Unknown
361 }
362
363 #[inline]
364 unsafe fn decode(
365 &mut self,
366 decoder: &mut fidl::encoding::Decoder<'_, D>,
367 offset: usize,
368 _depth: fidl::encoding::Depth,
369 ) -> fidl::Result<()> {
370 decoder.debug_check_bounds::<Self>(offset);
371 let prim = decoder.read_num::<u32>(offset);
372
373 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
374 Ok(())
375 }
376 }
377 unsafe impl fidl::encoding::TypeMarker for ChargeSource {
378 type Owned = Self;
379
380 #[inline(always)]
381 fn inline_align(_context: fidl::encoding::Context) -> usize {
382 std::mem::align_of::<u32>()
383 }
384
385 #[inline(always)]
386 fn inline_size(_context: fidl::encoding::Context) -> usize {
387 std::mem::size_of::<u32>()
388 }
389
390 #[inline(always)]
391 fn encode_is_copy() -> bool {
392 true
393 }
394
395 #[inline(always)]
396 fn decode_is_copy() -> bool {
397 false
398 }
399 }
400
401 impl fidl::encoding::ValueTypeMarker for ChargeSource {
402 type Borrowed<'a> = Self;
403 #[inline(always)]
404 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
405 *value
406 }
407 }
408
409 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ChargeSource {
410 #[inline]
411 unsafe fn encode(
412 self,
413 encoder: &mut fidl::encoding::Encoder<'_, D>,
414 offset: usize,
415 _depth: fidl::encoding::Depth,
416 ) -> fidl::Result<()> {
417 encoder.debug_check_bounds::<Self>(offset);
418 encoder.write_num(self.into_primitive(), offset);
419 Ok(())
420 }
421 }
422
423 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChargeSource {
424 #[inline(always)]
425 fn new_empty() -> Self {
426 Self::Unknown
427 }
428
429 #[inline]
430 unsafe fn decode(
431 &mut self,
432 decoder: &mut fidl::encoding::Decoder<'_, D>,
433 offset: usize,
434 _depth: fidl::encoding::Depth,
435 ) -> fidl::Result<()> {
436 decoder.debug_check_bounds::<Self>(offset);
437 let prim = decoder.read_num::<u32>(offset);
438
439 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
440 Ok(())
441 }
442 }
443 unsafe impl fidl::encoding::TypeMarker for ChargeStatus {
444 type Owned = Self;
445
446 #[inline(always)]
447 fn inline_align(_context: fidl::encoding::Context) -> usize {
448 std::mem::align_of::<u32>()
449 }
450
451 #[inline(always)]
452 fn inline_size(_context: fidl::encoding::Context) -> usize {
453 std::mem::size_of::<u32>()
454 }
455
456 #[inline(always)]
457 fn encode_is_copy() -> bool {
458 true
459 }
460
461 #[inline(always)]
462 fn decode_is_copy() -> bool {
463 false
464 }
465 }
466
467 impl fidl::encoding::ValueTypeMarker for ChargeStatus {
468 type Borrowed<'a> = Self;
469 #[inline(always)]
470 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
471 *value
472 }
473 }
474
475 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ChargeStatus {
476 #[inline]
477 unsafe fn encode(
478 self,
479 encoder: &mut fidl::encoding::Encoder<'_, D>,
480 offset: usize,
481 _depth: fidl::encoding::Depth,
482 ) -> fidl::Result<()> {
483 encoder.debug_check_bounds::<Self>(offset);
484 encoder.write_num(self.into_primitive(), offset);
485 Ok(())
486 }
487 }
488
489 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChargeStatus {
490 #[inline(always)]
491 fn new_empty() -> Self {
492 Self::Unknown
493 }
494
495 #[inline]
496 unsafe fn decode(
497 &mut self,
498 decoder: &mut fidl::encoding::Decoder<'_, D>,
499 offset: usize,
500 _depth: fidl::encoding::Depth,
501 ) -> fidl::Result<()> {
502 decoder.debug_check_bounds::<Self>(offset);
503 let prim = decoder.read_num::<u32>(offset);
504
505 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
506 Ok(())
507 }
508 }
509 unsafe impl fidl::encoding::TypeMarker for HealthStatus {
510 type Owned = Self;
511
512 #[inline(always)]
513 fn inline_align(_context: fidl::encoding::Context) -> usize {
514 std::mem::align_of::<u32>()
515 }
516
517 #[inline(always)]
518 fn inline_size(_context: fidl::encoding::Context) -> usize {
519 std::mem::size_of::<u32>()
520 }
521
522 #[inline(always)]
523 fn encode_is_copy() -> bool {
524 true
525 }
526
527 #[inline(always)]
528 fn decode_is_copy() -> bool {
529 false
530 }
531 }
532
533 impl fidl::encoding::ValueTypeMarker for HealthStatus {
534 type Borrowed<'a> = Self;
535 #[inline(always)]
536 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
537 *value
538 }
539 }
540
541 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HealthStatus {
542 #[inline]
543 unsafe fn encode(
544 self,
545 encoder: &mut fidl::encoding::Encoder<'_, D>,
546 offset: usize,
547 _depth: fidl::encoding::Depth,
548 ) -> fidl::Result<()> {
549 encoder.debug_check_bounds::<Self>(offset);
550 encoder.write_num(self.into_primitive(), offset);
551 Ok(())
552 }
553 }
554
555 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthStatus {
556 #[inline(always)]
557 fn new_empty() -> Self {
558 Self::Unknown
559 }
560
561 #[inline]
562 unsafe fn decode(
563 &mut self,
564 decoder: &mut fidl::encoding::Decoder<'_, D>,
565 offset: usize,
566 _depth: fidl::encoding::Depth,
567 ) -> fidl::Result<()> {
568 decoder.debug_check_bounds::<Self>(offset);
569 let prim = decoder.read_num::<u32>(offset);
570
571 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
572 Ok(())
573 }
574 }
575 unsafe impl fidl::encoding::TypeMarker for LevelStatus {
576 type Owned = Self;
577
578 #[inline(always)]
579 fn inline_align(_context: fidl::encoding::Context) -> usize {
580 std::mem::align_of::<u32>()
581 }
582
583 #[inline(always)]
584 fn inline_size(_context: fidl::encoding::Context) -> usize {
585 std::mem::size_of::<u32>()
586 }
587
588 #[inline(always)]
589 fn encode_is_copy() -> bool {
590 true
591 }
592
593 #[inline(always)]
594 fn decode_is_copy() -> bool {
595 false
596 }
597 }
598
599 impl fidl::encoding::ValueTypeMarker for LevelStatus {
600 type Borrowed<'a> = Self;
601 #[inline(always)]
602 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
603 *value
604 }
605 }
606
607 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LevelStatus {
608 #[inline]
609 unsafe fn encode(
610 self,
611 encoder: &mut fidl::encoding::Encoder<'_, D>,
612 offset: usize,
613 _depth: fidl::encoding::Depth,
614 ) -> fidl::Result<()> {
615 encoder.debug_check_bounds::<Self>(offset);
616 encoder.write_num(self.into_primitive(), offset);
617 Ok(())
618 }
619 }
620
621 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelStatus {
622 #[inline(always)]
623 fn new_empty() -> Self {
624 Self::Unknown
625 }
626
627 #[inline]
628 unsafe fn decode(
629 &mut self,
630 decoder: &mut fidl::encoding::Decoder<'_, D>,
631 offset: usize,
632 _depth: fidl::encoding::Depth,
633 ) -> fidl::Result<()> {
634 decoder.debug_check_bounds::<Self>(offset);
635 let prim = decoder.read_num::<u32>(offset);
636
637 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
638 Ok(())
639 }
640 }
641
642 impl fidl::encoding::ValueTypeMarker for BatteryInfoProviderGetBatteryInfoResponse {
643 type Borrowed<'a> = &'a Self;
644 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
645 value
646 }
647 }
648
649 unsafe impl fidl::encoding::TypeMarker for BatteryInfoProviderGetBatteryInfoResponse {
650 type Owned = Self;
651
652 #[inline(always)]
653 fn inline_align(_context: fidl::encoding::Context) -> usize {
654 8
655 }
656
657 #[inline(always)]
658 fn inline_size(_context: fidl::encoding::Context) -> usize {
659 16
660 }
661 }
662
663 unsafe impl<D: fidl::encoding::ResourceDialect>
664 fidl::encoding::Encode<BatteryInfoProviderGetBatteryInfoResponse, D>
665 for &BatteryInfoProviderGetBatteryInfoResponse
666 {
667 #[inline]
668 unsafe fn encode(
669 self,
670 encoder: &mut fidl::encoding::Encoder<'_, D>,
671 offset: usize,
672 _depth: fidl::encoding::Depth,
673 ) -> fidl::Result<()> {
674 encoder.debug_check_bounds::<BatteryInfoProviderGetBatteryInfoResponse>(offset);
675 fidl::encoding::Encode::<BatteryInfoProviderGetBatteryInfoResponse, D>::encode(
677 (<BatteryInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
678 encoder,
679 offset,
680 _depth,
681 )
682 }
683 }
684 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BatteryInfo, D>>
685 fidl::encoding::Encode<BatteryInfoProviderGetBatteryInfoResponse, D> for (T0,)
686 {
687 #[inline]
688 unsafe fn encode(
689 self,
690 encoder: &mut fidl::encoding::Encoder<'_, D>,
691 offset: usize,
692 depth: fidl::encoding::Depth,
693 ) -> fidl::Result<()> {
694 encoder.debug_check_bounds::<BatteryInfoProviderGetBatteryInfoResponse>(offset);
695 self.0.encode(encoder, offset + 0, depth)?;
699 Ok(())
700 }
701 }
702
703 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
704 for BatteryInfoProviderGetBatteryInfoResponse
705 {
706 #[inline(always)]
707 fn new_empty() -> Self {
708 Self { info: fidl::new_empty!(BatteryInfo, D) }
709 }
710
711 #[inline]
712 unsafe fn decode(
713 &mut self,
714 decoder: &mut fidl::encoding::Decoder<'_, D>,
715 offset: usize,
716 _depth: fidl::encoding::Depth,
717 ) -> fidl::Result<()> {
718 decoder.debug_check_bounds::<Self>(offset);
719 fidl::decode!(BatteryInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
721 Ok(())
722 }
723 }
724
725 impl BatteryInfo {
726 #[inline(always)]
727 fn max_ordinal_present(&self) -> u64 {
728 if let Some(_) = self.present_current_ma {
729 return 14;
730 }
731 if let Some(_) = self.temperature_mc {
732 return 13;
733 }
734 if let Some(_) = self.full_capacity_uah {
735 return 12;
736 }
737 if let Some(_) = self.battery_spec {
738 return 11;
739 }
740 if let Some(_) = self.remaining_capacity_uah {
741 return 10;
742 }
743 if let Some(_) = self.present_voltage_mv {
744 return 9;
745 }
746 if let Some(_) = self.timestamp {
747 return 8;
748 }
749 if let Some(_) = self.time_remaining {
750 return 7;
751 }
752 if let Some(_) = self.health {
753 return 6;
754 }
755 if let Some(_) = self.level_status {
756 return 5;
757 }
758 if let Some(_) = self.level_percent {
759 return 4;
760 }
761 if let Some(_) = self.charge_source {
762 return 3;
763 }
764 if let Some(_) = self.charge_status {
765 return 2;
766 }
767 if let Some(_) = self.status {
768 return 1;
769 }
770 0
771 }
772 }
773
774 impl fidl::encoding::ValueTypeMarker for BatteryInfo {
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 BatteryInfo {
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<BatteryInfo, D>
796 for &BatteryInfo
797 {
798 unsafe fn encode(
799 self,
800 encoder: &mut fidl::encoding::Encoder<'_, D>,
801 offset: usize,
802 mut depth: fidl::encoding::Depth,
803 ) -> fidl::Result<()> {
804 encoder.debug_check_bounds::<BatteryInfo>(offset);
805 let max_ordinal: u64 = self.max_ordinal_present();
807 encoder.write_num(max_ordinal, offset);
808 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
809 if max_ordinal == 0 {
811 return Ok(());
812 }
813 depth.increment()?;
814 let envelope_size = 8;
815 let bytes_len = max_ordinal as usize * envelope_size;
816 #[allow(unused_variables)]
817 let offset = encoder.out_of_line_offset(bytes_len);
818 let mut _prev_end_offset: usize = 0;
819 if 1 > max_ordinal {
820 return Ok(());
821 }
822
823 let cur_offset: usize = (1 - 1) * envelope_size;
826
827 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
829
830 fidl::encoding::encode_in_envelope_optional::<BatteryStatus, D>(
835 self.status
836 .as_ref()
837 .map(<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow),
838 encoder,
839 offset + cur_offset,
840 depth,
841 )?;
842
843 _prev_end_offset = cur_offset + envelope_size;
844 if 2 > max_ordinal {
845 return Ok(());
846 }
847
848 let cur_offset: usize = (2 - 1) * envelope_size;
851
852 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
854
855 fidl::encoding::encode_in_envelope_optional::<ChargeStatus, D>(
860 self.charge_status
861 .as_ref()
862 .map(<ChargeStatus as fidl::encoding::ValueTypeMarker>::borrow),
863 encoder,
864 offset + cur_offset,
865 depth,
866 )?;
867
868 _prev_end_offset = cur_offset + envelope_size;
869 if 3 > max_ordinal {
870 return Ok(());
871 }
872
873 let cur_offset: usize = (3 - 1) * envelope_size;
876
877 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
879
880 fidl::encoding::encode_in_envelope_optional::<ChargeSource, D>(
885 self.charge_source
886 .as_ref()
887 .map(<ChargeSource as fidl::encoding::ValueTypeMarker>::borrow),
888 encoder,
889 offset + cur_offset,
890 depth,
891 )?;
892
893 _prev_end_offset = cur_offset + envelope_size;
894 if 4 > max_ordinal {
895 return Ok(());
896 }
897
898 let cur_offset: usize = (4 - 1) * envelope_size;
901
902 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
904
905 fidl::encoding::encode_in_envelope_optional::<f32, D>(
910 self.level_percent.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
911 encoder,
912 offset + cur_offset,
913 depth,
914 )?;
915
916 _prev_end_offset = cur_offset + envelope_size;
917 if 5 > max_ordinal {
918 return Ok(());
919 }
920
921 let cur_offset: usize = (5 - 1) * envelope_size;
924
925 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
927
928 fidl::encoding::encode_in_envelope_optional::<LevelStatus, D>(
933 self.level_status
934 .as_ref()
935 .map(<LevelStatus as fidl::encoding::ValueTypeMarker>::borrow),
936 encoder,
937 offset + cur_offset,
938 depth,
939 )?;
940
941 _prev_end_offset = cur_offset + envelope_size;
942 if 6 > max_ordinal {
943 return Ok(());
944 }
945
946 let cur_offset: usize = (6 - 1) * envelope_size;
949
950 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
952
953 fidl::encoding::encode_in_envelope_optional::<HealthStatus, D>(
958 self.health.as_ref().map(<HealthStatus as fidl::encoding::ValueTypeMarker>::borrow),
959 encoder,
960 offset + cur_offset,
961 depth,
962 )?;
963
964 _prev_end_offset = cur_offset + envelope_size;
965 if 7 > max_ordinal {
966 return Ok(());
967 }
968
969 let cur_offset: usize = (7 - 1) * envelope_size;
972
973 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
975
976 fidl::encoding::encode_in_envelope_optional::<TimeRemaining, D>(
981 self.time_remaining
982 .as_ref()
983 .map(<TimeRemaining as fidl::encoding::ValueTypeMarker>::borrow),
984 encoder,
985 offset + cur_offset,
986 depth,
987 )?;
988
989 _prev_end_offset = cur_offset + envelope_size;
990 if 8 > max_ordinal {
991 return Ok(());
992 }
993
994 let cur_offset: usize = (8 - 1) * envelope_size;
997
998 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1000
1001 fidl::encoding::encode_in_envelope_optional::<i64, D>(
1006 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1007 encoder,
1008 offset + cur_offset,
1009 depth,
1010 )?;
1011
1012 _prev_end_offset = cur_offset + envelope_size;
1013 if 9 > max_ordinal {
1014 return Ok(());
1015 }
1016
1017 let cur_offset: usize = (9 - 1) * envelope_size;
1020
1021 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1023
1024 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1029 self.present_voltage_mv
1030 .as_ref()
1031 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1032 encoder,
1033 offset + cur_offset,
1034 depth,
1035 )?;
1036
1037 _prev_end_offset = cur_offset + envelope_size;
1038 if 10 > max_ordinal {
1039 return Ok(());
1040 }
1041
1042 let cur_offset: usize = (10 - 1) * envelope_size;
1045
1046 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1048
1049 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1054 self.remaining_capacity_uah
1055 .as_ref()
1056 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1057 encoder,
1058 offset + cur_offset,
1059 depth,
1060 )?;
1061
1062 _prev_end_offset = cur_offset + envelope_size;
1063 if 11 > max_ordinal {
1064 return Ok(());
1065 }
1066
1067 let cur_offset: usize = (11 - 1) * envelope_size;
1070
1071 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1073
1074 fidl::encoding::encode_in_envelope_optional::<BatterySpec, D>(
1079 self.battery_spec
1080 .as_ref()
1081 .map(<BatterySpec as fidl::encoding::ValueTypeMarker>::borrow),
1082 encoder,
1083 offset + cur_offset,
1084 depth,
1085 )?;
1086
1087 _prev_end_offset = cur_offset + envelope_size;
1088 if 12 > max_ordinal {
1089 return Ok(());
1090 }
1091
1092 let cur_offset: usize = (12 - 1) * envelope_size;
1095
1096 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1098
1099 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1104 self.full_capacity_uah
1105 .as_ref()
1106 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1107 encoder,
1108 offset + cur_offset,
1109 depth,
1110 )?;
1111
1112 _prev_end_offset = cur_offset + envelope_size;
1113 if 13 > max_ordinal {
1114 return Ok(());
1115 }
1116
1117 let cur_offset: usize = (13 - 1) * envelope_size;
1120
1121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1123
1124 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1129 self.temperature_mc.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1130 encoder,
1131 offset + cur_offset,
1132 depth,
1133 )?;
1134
1135 _prev_end_offset = cur_offset + envelope_size;
1136 if 14 > max_ordinal {
1137 return Ok(());
1138 }
1139
1140 let cur_offset: usize = (14 - 1) * envelope_size;
1143
1144 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1146
1147 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1152 self.present_current_ma
1153 .as_ref()
1154 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1155 encoder,
1156 offset + cur_offset,
1157 depth,
1158 )?;
1159
1160 _prev_end_offset = cur_offset + envelope_size;
1161
1162 Ok(())
1163 }
1164 }
1165
1166 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryInfo {
1167 #[inline(always)]
1168 fn new_empty() -> Self {
1169 Self::default()
1170 }
1171
1172 unsafe fn decode(
1173 &mut self,
1174 decoder: &mut fidl::encoding::Decoder<'_, D>,
1175 offset: usize,
1176 mut depth: fidl::encoding::Depth,
1177 ) -> fidl::Result<()> {
1178 decoder.debug_check_bounds::<Self>(offset);
1179 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1180 None => return Err(fidl::Error::NotNullable),
1181 Some(len) => len,
1182 };
1183 if len == 0 {
1185 return Ok(());
1186 };
1187 depth.increment()?;
1188 let envelope_size = 8;
1189 let bytes_len = len * envelope_size;
1190 let offset = decoder.out_of_line_offset(bytes_len)?;
1191 let mut _next_ordinal_to_read = 0;
1193 let mut next_offset = offset;
1194 let end_offset = offset + bytes_len;
1195 _next_ordinal_to_read += 1;
1196 if next_offset >= end_offset {
1197 return Ok(());
1198 }
1199
1200 while _next_ordinal_to_read < 1 {
1202 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1203 _next_ordinal_to_read += 1;
1204 next_offset += envelope_size;
1205 }
1206
1207 let next_out_of_line = decoder.next_out_of_line();
1208 let handles_before = decoder.remaining_handles();
1209 if let Some((inlined, num_bytes, num_handles)) =
1210 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1211 {
1212 let member_inline_size =
1213 <BatteryStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1214 if inlined != (member_inline_size <= 4) {
1215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1216 }
1217 let inner_offset;
1218 let mut inner_depth = depth.clone();
1219 if inlined {
1220 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1221 inner_offset = next_offset;
1222 } else {
1223 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1224 inner_depth.increment()?;
1225 }
1226 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(BatteryStatus, D));
1227 fidl::decode!(BatteryStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1228 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1229 {
1230 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1231 }
1232 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1233 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1234 }
1235 }
1236
1237 next_offset += envelope_size;
1238 _next_ordinal_to_read += 1;
1239 if next_offset >= end_offset {
1240 return Ok(());
1241 }
1242
1243 while _next_ordinal_to_read < 2 {
1245 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1246 _next_ordinal_to_read += 1;
1247 next_offset += envelope_size;
1248 }
1249
1250 let next_out_of_line = decoder.next_out_of_line();
1251 let handles_before = decoder.remaining_handles();
1252 if let Some((inlined, num_bytes, num_handles)) =
1253 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1254 {
1255 let member_inline_size =
1256 <ChargeStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1257 if inlined != (member_inline_size <= 4) {
1258 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1259 }
1260 let inner_offset;
1261 let mut inner_depth = depth.clone();
1262 if inlined {
1263 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1264 inner_offset = next_offset;
1265 } else {
1266 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1267 inner_depth.increment()?;
1268 }
1269 let val_ref =
1270 self.charge_status.get_or_insert_with(|| fidl::new_empty!(ChargeStatus, D));
1271 fidl::decode!(ChargeStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1272 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1273 {
1274 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1275 }
1276 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1277 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1278 }
1279 }
1280
1281 next_offset += envelope_size;
1282 _next_ordinal_to_read += 1;
1283 if next_offset >= end_offset {
1284 return Ok(());
1285 }
1286
1287 while _next_ordinal_to_read < 3 {
1289 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1290 _next_ordinal_to_read += 1;
1291 next_offset += envelope_size;
1292 }
1293
1294 let next_out_of_line = decoder.next_out_of_line();
1295 let handles_before = decoder.remaining_handles();
1296 if let Some((inlined, num_bytes, num_handles)) =
1297 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1298 {
1299 let member_inline_size =
1300 <ChargeSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1301 if inlined != (member_inline_size <= 4) {
1302 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1303 }
1304 let inner_offset;
1305 let mut inner_depth = depth.clone();
1306 if inlined {
1307 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1308 inner_offset = next_offset;
1309 } else {
1310 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1311 inner_depth.increment()?;
1312 }
1313 let val_ref =
1314 self.charge_source.get_or_insert_with(|| fidl::new_empty!(ChargeSource, D));
1315 fidl::decode!(ChargeSource, D, val_ref, decoder, inner_offset, inner_depth)?;
1316 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1317 {
1318 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1319 }
1320 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1321 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1322 }
1323 }
1324
1325 next_offset += envelope_size;
1326 _next_ordinal_to_read += 1;
1327 if next_offset >= end_offset {
1328 return Ok(());
1329 }
1330
1331 while _next_ordinal_to_read < 4 {
1333 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1334 _next_ordinal_to_read += 1;
1335 next_offset += envelope_size;
1336 }
1337
1338 let next_out_of_line = decoder.next_out_of_line();
1339 let handles_before = decoder.remaining_handles();
1340 if let Some((inlined, num_bytes, num_handles)) =
1341 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1342 {
1343 let member_inline_size =
1344 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1345 if inlined != (member_inline_size <= 4) {
1346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1347 }
1348 let inner_offset;
1349 let mut inner_depth = depth.clone();
1350 if inlined {
1351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1352 inner_offset = next_offset;
1353 } else {
1354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1355 inner_depth.increment()?;
1356 }
1357 let val_ref = self.level_percent.get_or_insert_with(|| fidl::new_empty!(f32, D));
1358 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
1359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1360 {
1361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1362 }
1363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1365 }
1366 }
1367
1368 next_offset += envelope_size;
1369 _next_ordinal_to_read += 1;
1370 if next_offset >= end_offset {
1371 return Ok(());
1372 }
1373
1374 while _next_ordinal_to_read < 5 {
1376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1377 _next_ordinal_to_read += 1;
1378 next_offset += envelope_size;
1379 }
1380
1381 let next_out_of_line = decoder.next_out_of_line();
1382 let handles_before = decoder.remaining_handles();
1383 if let Some((inlined, num_bytes, num_handles)) =
1384 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1385 {
1386 let member_inline_size =
1387 <LevelStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1388 if inlined != (member_inline_size <= 4) {
1389 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1390 }
1391 let inner_offset;
1392 let mut inner_depth = depth.clone();
1393 if inlined {
1394 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1395 inner_offset = next_offset;
1396 } else {
1397 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1398 inner_depth.increment()?;
1399 }
1400 let val_ref =
1401 self.level_status.get_or_insert_with(|| fidl::new_empty!(LevelStatus, D));
1402 fidl::decode!(LevelStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1403 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1404 {
1405 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1406 }
1407 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1408 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1409 }
1410 }
1411
1412 next_offset += envelope_size;
1413 _next_ordinal_to_read += 1;
1414 if next_offset >= end_offset {
1415 return Ok(());
1416 }
1417
1418 while _next_ordinal_to_read < 6 {
1420 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1421 _next_ordinal_to_read += 1;
1422 next_offset += envelope_size;
1423 }
1424
1425 let next_out_of_line = decoder.next_out_of_line();
1426 let handles_before = decoder.remaining_handles();
1427 if let Some((inlined, num_bytes, num_handles)) =
1428 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1429 {
1430 let member_inline_size =
1431 <HealthStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1432 if inlined != (member_inline_size <= 4) {
1433 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1434 }
1435 let inner_offset;
1436 let mut inner_depth = depth.clone();
1437 if inlined {
1438 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1439 inner_offset = next_offset;
1440 } else {
1441 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1442 inner_depth.increment()?;
1443 }
1444 let val_ref = self.health.get_or_insert_with(|| fidl::new_empty!(HealthStatus, D));
1445 fidl::decode!(HealthStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
1446 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1447 {
1448 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1449 }
1450 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1451 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1452 }
1453 }
1454
1455 next_offset += envelope_size;
1456 _next_ordinal_to_read += 1;
1457 if next_offset >= end_offset {
1458 return Ok(());
1459 }
1460
1461 while _next_ordinal_to_read < 7 {
1463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1464 _next_ordinal_to_read += 1;
1465 next_offset += envelope_size;
1466 }
1467
1468 let next_out_of_line = decoder.next_out_of_line();
1469 let handles_before = decoder.remaining_handles();
1470 if let Some((inlined, num_bytes, num_handles)) =
1471 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1472 {
1473 let member_inline_size =
1474 <TimeRemaining as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1475 if inlined != (member_inline_size <= 4) {
1476 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1477 }
1478 let inner_offset;
1479 let mut inner_depth = depth.clone();
1480 if inlined {
1481 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1482 inner_offset = next_offset;
1483 } else {
1484 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1485 inner_depth.increment()?;
1486 }
1487 let val_ref =
1488 self.time_remaining.get_or_insert_with(|| fidl::new_empty!(TimeRemaining, D));
1489 fidl::decode!(TimeRemaining, D, val_ref, decoder, inner_offset, inner_depth)?;
1490 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1491 {
1492 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1493 }
1494 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1495 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1496 }
1497 }
1498
1499 next_offset += envelope_size;
1500 _next_ordinal_to_read += 1;
1501 if next_offset >= end_offset {
1502 return Ok(());
1503 }
1504
1505 while _next_ordinal_to_read < 8 {
1507 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1508 _next_ordinal_to_read += 1;
1509 next_offset += envelope_size;
1510 }
1511
1512 let next_out_of_line = decoder.next_out_of_line();
1513 let handles_before = decoder.remaining_handles();
1514 if let Some((inlined, num_bytes, num_handles)) =
1515 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1516 {
1517 let member_inline_size =
1518 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1519 if inlined != (member_inline_size <= 4) {
1520 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1521 }
1522 let inner_offset;
1523 let mut inner_depth = depth.clone();
1524 if inlined {
1525 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1526 inner_offset = next_offset;
1527 } else {
1528 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1529 inner_depth.increment()?;
1530 }
1531 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
1532 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1533 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1534 {
1535 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1536 }
1537 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1538 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1539 }
1540 }
1541
1542 next_offset += envelope_size;
1543 _next_ordinal_to_read += 1;
1544 if next_offset >= end_offset {
1545 return Ok(());
1546 }
1547
1548 while _next_ordinal_to_read < 9 {
1550 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1551 _next_ordinal_to_read += 1;
1552 next_offset += envelope_size;
1553 }
1554
1555 let next_out_of_line = decoder.next_out_of_line();
1556 let handles_before = decoder.remaining_handles();
1557 if let Some((inlined, num_bytes, num_handles)) =
1558 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1559 {
1560 let member_inline_size =
1561 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1562 if inlined != (member_inline_size <= 4) {
1563 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1564 }
1565 let inner_offset;
1566 let mut inner_depth = depth.clone();
1567 if inlined {
1568 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1569 inner_offset = next_offset;
1570 } else {
1571 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1572 inner_depth.increment()?;
1573 }
1574 let val_ref =
1575 self.present_voltage_mv.get_or_insert_with(|| fidl::new_empty!(u32, D));
1576 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1577 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1578 {
1579 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1580 }
1581 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1582 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1583 }
1584 }
1585
1586 next_offset += envelope_size;
1587 _next_ordinal_to_read += 1;
1588 if next_offset >= end_offset {
1589 return Ok(());
1590 }
1591
1592 while _next_ordinal_to_read < 10 {
1594 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1595 _next_ordinal_to_read += 1;
1596 next_offset += envelope_size;
1597 }
1598
1599 let next_out_of_line = decoder.next_out_of_line();
1600 let handles_before = decoder.remaining_handles();
1601 if let Some((inlined, num_bytes, num_handles)) =
1602 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1603 {
1604 let member_inline_size =
1605 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1606 if inlined != (member_inline_size <= 4) {
1607 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1608 }
1609 let inner_offset;
1610 let mut inner_depth = depth.clone();
1611 if inlined {
1612 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1613 inner_offset = next_offset;
1614 } else {
1615 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1616 inner_depth.increment()?;
1617 }
1618 let val_ref =
1619 self.remaining_capacity_uah.get_or_insert_with(|| fidl::new_empty!(u32, D));
1620 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1621 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1622 {
1623 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1624 }
1625 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1626 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1627 }
1628 }
1629
1630 next_offset += envelope_size;
1631 _next_ordinal_to_read += 1;
1632 if next_offset >= end_offset {
1633 return Ok(());
1634 }
1635
1636 while _next_ordinal_to_read < 11 {
1638 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1639 _next_ordinal_to_read += 1;
1640 next_offset += envelope_size;
1641 }
1642
1643 let next_out_of_line = decoder.next_out_of_line();
1644 let handles_before = decoder.remaining_handles();
1645 if let Some((inlined, num_bytes, num_handles)) =
1646 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1647 {
1648 let member_inline_size =
1649 <BatterySpec as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1650 if inlined != (member_inline_size <= 4) {
1651 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1652 }
1653 let inner_offset;
1654 let mut inner_depth = depth.clone();
1655 if inlined {
1656 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1657 inner_offset = next_offset;
1658 } else {
1659 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1660 inner_depth.increment()?;
1661 }
1662 let val_ref =
1663 self.battery_spec.get_or_insert_with(|| fidl::new_empty!(BatterySpec, D));
1664 fidl::decode!(BatterySpec, D, val_ref, decoder, inner_offset, inner_depth)?;
1665 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1666 {
1667 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1668 }
1669 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1670 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1671 }
1672 }
1673
1674 next_offset += envelope_size;
1675 _next_ordinal_to_read += 1;
1676 if next_offset >= end_offset {
1677 return Ok(());
1678 }
1679
1680 while _next_ordinal_to_read < 12 {
1682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1683 _next_ordinal_to_read += 1;
1684 next_offset += envelope_size;
1685 }
1686
1687 let next_out_of_line = decoder.next_out_of_line();
1688 let handles_before = decoder.remaining_handles();
1689 if let Some((inlined, num_bytes, num_handles)) =
1690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1691 {
1692 let member_inline_size =
1693 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1694 if inlined != (member_inline_size <= 4) {
1695 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1696 }
1697 let inner_offset;
1698 let mut inner_depth = depth.clone();
1699 if inlined {
1700 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1701 inner_offset = next_offset;
1702 } else {
1703 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1704 inner_depth.increment()?;
1705 }
1706 let val_ref =
1707 self.full_capacity_uah.get_or_insert_with(|| fidl::new_empty!(i32, D));
1708 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1709 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1710 {
1711 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1712 }
1713 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1714 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1715 }
1716 }
1717
1718 next_offset += envelope_size;
1719 _next_ordinal_to_read += 1;
1720 if next_offset >= end_offset {
1721 return Ok(());
1722 }
1723
1724 while _next_ordinal_to_read < 13 {
1726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1727 _next_ordinal_to_read += 1;
1728 next_offset += envelope_size;
1729 }
1730
1731 let next_out_of_line = decoder.next_out_of_line();
1732 let handles_before = decoder.remaining_handles();
1733 if let Some((inlined, num_bytes, num_handles)) =
1734 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1735 {
1736 let member_inline_size =
1737 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1738 if inlined != (member_inline_size <= 4) {
1739 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1740 }
1741 let inner_offset;
1742 let mut inner_depth = depth.clone();
1743 if inlined {
1744 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1745 inner_offset = next_offset;
1746 } else {
1747 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1748 inner_depth.increment()?;
1749 }
1750 let val_ref = self.temperature_mc.get_or_insert_with(|| fidl::new_empty!(i32, D));
1751 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1752 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1753 {
1754 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1755 }
1756 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1757 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1758 }
1759 }
1760
1761 next_offset += envelope_size;
1762 _next_ordinal_to_read += 1;
1763 if next_offset >= end_offset {
1764 return Ok(());
1765 }
1766
1767 while _next_ordinal_to_read < 14 {
1769 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1770 _next_ordinal_to_read += 1;
1771 next_offset += envelope_size;
1772 }
1773
1774 let next_out_of_line = decoder.next_out_of_line();
1775 let handles_before = decoder.remaining_handles();
1776 if let Some((inlined, num_bytes, num_handles)) =
1777 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1778 {
1779 let member_inline_size =
1780 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1781 if inlined != (member_inline_size <= 4) {
1782 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1783 }
1784 let inner_offset;
1785 let mut inner_depth = depth.clone();
1786 if inlined {
1787 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1788 inner_offset = next_offset;
1789 } else {
1790 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1791 inner_depth.increment()?;
1792 }
1793 let val_ref =
1794 self.present_current_ma.get_or_insert_with(|| fidl::new_empty!(i32, D));
1795 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
1796 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1797 {
1798 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1799 }
1800 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1801 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1802 }
1803 }
1804
1805 next_offset += envelope_size;
1806
1807 while next_offset < end_offset {
1809 _next_ordinal_to_read += 1;
1810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1811 next_offset += envelope_size;
1812 }
1813
1814 Ok(())
1815 }
1816 }
1817
1818 impl BatterySpec {
1819 #[inline(always)]
1820 fn max_ordinal_present(&self) -> u64 {
1821 if let Some(_) = self.design_capacity_uah {
1822 return 3;
1823 }
1824 if let Some(_) = self.max_charging_voltage_uv {
1825 return 2;
1826 }
1827 if let Some(_) = self.max_charging_current_ua {
1828 return 1;
1829 }
1830 0
1831 }
1832 }
1833
1834 impl fidl::encoding::ValueTypeMarker for BatterySpec {
1835 type Borrowed<'a> = &'a Self;
1836 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1837 value
1838 }
1839 }
1840
1841 unsafe impl fidl::encoding::TypeMarker for BatterySpec {
1842 type Owned = Self;
1843
1844 #[inline(always)]
1845 fn inline_align(_context: fidl::encoding::Context) -> usize {
1846 8
1847 }
1848
1849 #[inline(always)]
1850 fn inline_size(_context: fidl::encoding::Context) -> usize {
1851 16
1852 }
1853 }
1854
1855 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BatterySpec, D>
1856 for &BatterySpec
1857 {
1858 unsafe fn encode(
1859 self,
1860 encoder: &mut fidl::encoding::Encoder<'_, D>,
1861 offset: usize,
1862 mut depth: fidl::encoding::Depth,
1863 ) -> fidl::Result<()> {
1864 encoder.debug_check_bounds::<BatterySpec>(offset);
1865 let max_ordinal: u64 = self.max_ordinal_present();
1867 encoder.write_num(max_ordinal, offset);
1868 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1869 if max_ordinal == 0 {
1871 return Ok(());
1872 }
1873 depth.increment()?;
1874 let envelope_size = 8;
1875 let bytes_len = max_ordinal as usize * envelope_size;
1876 #[allow(unused_variables)]
1877 let offset = encoder.out_of_line_offset(bytes_len);
1878 let mut _prev_end_offset: usize = 0;
1879 if 1 > max_ordinal {
1880 return Ok(());
1881 }
1882
1883 let cur_offset: usize = (1 - 1) * envelope_size;
1886
1887 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1889
1890 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1895 self.max_charging_current_ua
1896 .as_ref()
1897 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1898 encoder,
1899 offset + cur_offset,
1900 depth,
1901 )?;
1902
1903 _prev_end_offset = cur_offset + envelope_size;
1904 if 2 > max_ordinal {
1905 return Ok(());
1906 }
1907
1908 let cur_offset: usize = (2 - 1) * envelope_size;
1911
1912 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1914
1915 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1920 self.max_charging_voltage_uv
1921 .as_ref()
1922 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1923 encoder,
1924 offset + cur_offset,
1925 depth,
1926 )?;
1927
1928 _prev_end_offset = cur_offset + envelope_size;
1929 if 3 > max_ordinal {
1930 return Ok(());
1931 }
1932
1933 let cur_offset: usize = (3 - 1) * envelope_size;
1936
1937 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1939
1940 fidl::encoding::encode_in_envelope_optional::<i32, D>(
1945 self.design_capacity_uah
1946 .as_ref()
1947 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
1948 encoder,
1949 offset + cur_offset,
1950 depth,
1951 )?;
1952
1953 _prev_end_offset = cur_offset + envelope_size;
1954
1955 Ok(())
1956 }
1957 }
1958
1959 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatterySpec {
1960 #[inline(always)]
1961 fn new_empty() -> Self {
1962 Self::default()
1963 }
1964
1965 unsafe fn decode(
1966 &mut self,
1967 decoder: &mut fidl::encoding::Decoder<'_, D>,
1968 offset: usize,
1969 mut depth: fidl::encoding::Depth,
1970 ) -> fidl::Result<()> {
1971 decoder.debug_check_bounds::<Self>(offset);
1972 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1973 None => return Err(fidl::Error::NotNullable),
1974 Some(len) => len,
1975 };
1976 if len == 0 {
1978 return Ok(());
1979 };
1980 depth.increment()?;
1981 let envelope_size = 8;
1982 let bytes_len = len * envelope_size;
1983 let offset = decoder.out_of_line_offset(bytes_len)?;
1984 let mut _next_ordinal_to_read = 0;
1986 let mut next_offset = offset;
1987 let end_offset = offset + bytes_len;
1988 _next_ordinal_to_read += 1;
1989 if next_offset >= end_offset {
1990 return Ok(());
1991 }
1992
1993 while _next_ordinal_to_read < 1 {
1995 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1996 _next_ordinal_to_read += 1;
1997 next_offset += envelope_size;
1998 }
1999
2000 let next_out_of_line = decoder.next_out_of_line();
2001 let handles_before = decoder.remaining_handles();
2002 if let Some((inlined, num_bytes, num_handles)) =
2003 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2004 {
2005 let member_inline_size =
2006 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2007 if inlined != (member_inline_size <= 4) {
2008 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2009 }
2010 let inner_offset;
2011 let mut inner_depth = depth.clone();
2012 if inlined {
2013 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2014 inner_offset = next_offset;
2015 } else {
2016 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2017 inner_depth.increment()?;
2018 }
2019 let val_ref =
2020 self.max_charging_current_ua.get_or_insert_with(|| fidl::new_empty!(i32, D));
2021 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2022 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2023 {
2024 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2025 }
2026 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2027 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2028 }
2029 }
2030
2031 next_offset += envelope_size;
2032 _next_ordinal_to_read += 1;
2033 if next_offset >= end_offset {
2034 return Ok(());
2035 }
2036
2037 while _next_ordinal_to_read < 2 {
2039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2040 _next_ordinal_to_read += 1;
2041 next_offset += envelope_size;
2042 }
2043
2044 let next_out_of_line = decoder.next_out_of_line();
2045 let handles_before = decoder.remaining_handles();
2046 if let Some((inlined, num_bytes, num_handles)) =
2047 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2048 {
2049 let member_inline_size =
2050 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2051 if inlined != (member_inline_size <= 4) {
2052 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2053 }
2054 let inner_offset;
2055 let mut inner_depth = depth.clone();
2056 if inlined {
2057 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2058 inner_offset = next_offset;
2059 } else {
2060 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2061 inner_depth.increment()?;
2062 }
2063 let val_ref =
2064 self.max_charging_voltage_uv.get_or_insert_with(|| fidl::new_empty!(i32, D));
2065 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2066 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2067 {
2068 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2069 }
2070 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2071 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2072 }
2073 }
2074
2075 next_offset += envelope_size;
2076 _next_ordinal_to_read += 1;
2077 if next_offset >= end_offset {
2078 return Ok(());
2079 }
2080
2081 while _next_ordinal_to_read < 3 {
2083 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2084 _next_ordinal_to_read += 1;
2085 next_offset += envelope_size;
2086 }
2087
2088 let next_out_of_line = decoder.next_out_of_line();
2089 let handles_before = decoder.remaining_handles();
2090 if let Some((inlined, num_bytes, num_handles)) =
2091 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2092 {
2093 let member_inline_size =
2094 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2095 if inlined != (member_inline_size <= 4) {
2096 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2097 }
2098 let inner_offset;
2099 let mut inner_depth = depth.clone();
2100 if inlined {
2101 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2102 inner_offset = next_offset;
2103 } else {
2104 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2105 inner_depth.increment()?;
2106 }
2107 let val_ref =
2108 self.design_capacity_uah.get_or_insert_with(|| fidl::new_empty!(i32, D));
2109 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2110 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2111 {
2112 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2113 }
2114 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2115 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2116 }
2117 }
2118
2119 next_offset += envelope_size;
2120
2121 while next_offset < end_offset {
2123 _next_ordinal_to_read += 1;
2124 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2125 next_offset += envelope_size;
2126 }
2127
2128 Ok(())
2129 }
2130 }
2131
2132 impl fidl::encoding::ValueTypeMarker for TimeRemaining {
2133 type Borrowed<'a> = &'a Self;
2134 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2135 value
2136 }
2137 }
2138
2139 unsafe impl fidl::encoding::TypeMarker for TimeRemaining {
2140 type Owned = Self;
2141
2142 #[inline(always)]
2143 fn inline_align(_context: fidl::encoding::Context) -> usize {
2144 8
2145 }
2146
2147 #[inline(always)]
2148 fn inline_size(_context: fidl::encoding::Context) -> usize {
2149 16
2150 }
2151 }
2152
2153 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TimeRemaining, D>
2154 for &TimeRemaining
2155 {
2156 #[inline]
2157 unsafe fn encode(
2158 self,
2159 encoder: &mut fidl::encoding::Encoder<'_, D>,
2160 offset: usize,
2161 _depth: fidl::encoding::Depth,
2162 ) -> fidl::Result<()> {
2163 encoder.debug_check_bounds::<TimeRemaining>(offset);
2164 encoder.write_num::<u64>(self.ordinal(), offset);
2165 match self {
2166 TimeRemaining::Indeterminate(ref val) => {
2167 fidl::encoding::encode_in_envelope::<i64, D>(
2168 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2169 encoder,
2170 offset + 8,
2171 _depth,
2172 )
2173 }
2174 TimeRemaining::BatteryLife(ref val) => {
2175 fidl::encoding::encode_in_envelope::<i64, D>(
2176 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2177 encoder,
2178 offset + 8,
2179 _depth,
2180 )
2181 }
2182 TimeRemaining::FullCharge(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
2183 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2184 encoder,
2185 offset + 8,
2186 _depth,
2187 ),
2188 TimeRemaining::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
2189 }
2190 }
2191 }
2192
2193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TimeRemaining {
2194 #[inline(always)]
2195 fn new_empty() -> Self {
2196 Self::__SourceBreaking { unknown_ordinal: 0 }
2197 }
2198
2199 #[inline]
2200 unsafe fn decode(
2201 &mut self,
2202 decoder: &mut fidl::encoding::Decoder<'_, D>,
2203 offset: usize,
2204 mut depth: fidl::encoding::Depth,
2205 ) -> fidl::Result<()> {
2206 decoder.debug_check_bounds::<Self>(offset);
2207 #[allow(unused_variables)]
2208 let next_out_of_line = decoder.next_out_of_line();
2209 let handles_before = decoder.remaining_handles();
2210 let (ordinal, inlined, num_bytes, num_handles) =
2211 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2212
2213 let member_inline_size = match ordinal {
2214 1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2215 2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2216 3 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2217 0 => return Err(fidl::Error::UnknownUnionTag),
2218 _ => num_bytes as usize,
2219 };
2220
2221 if inlined != (member_inline_size <= 4) {
2222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2223 }
2224 let _inner_offset;
2225 if inlined {
2226 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2227 _inner_offset = offset + 8;
2228 } else {
2229 depth.increment()?;
2230 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2231 }
2232 match ordinal {
2233 1 => {
2234 #[allow(irrefutable_let_patterns)]
2235 if let TimeRemaining::Indeterminate(_) = self {
2236 } else {
2238 *self = TimeRemaining::Indeterminate(fidl::new_empty!(i64, D));
2240 }
2241 #[allow(irrefutable_let_patterns)]
2242 if let TimeRemaining::Indeterminate(ref mut val) = self {
2243 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2244 } else {
2245 unreachable!()
2246 }
2247 }
2248 2 => {
2249 #[allow(irrefutable_let_patterns)]
2250 if let TimeRemaining::BatteryLife(_) = self {
2251 } else {
2253 *self = TimeRemaining::BatteryLife(fidl::new_empty!(i64, D));
2255 }
2256 #[allow(irrefutable_let_patterns)]
2257 if let TimeRemaining::BatteryLife(ref mut val) = self {
2258 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2259 } else {
2260 unreachable!()
2261 }
2262 }
2263 3 => {
2264 #[allow(irrefutable_let_patterns)]
2265 if let TimeRemaining::FullCharge(_) = self {
2266 } else {
2268 *self = TimeRemaining::FullCharge(fidl::new_empty!(i64, D));
2270 }
2271 #[allow(irrefutable_let_patterns)]
2272 if let TimeRemaining::FullCharge(ref mut val) = self {
2273 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2274 } else {
2275 unreachable!()
2276 }
2277 }
2278 #[allow(deprecated)]
2279 ordinal => {
2280 for _ in 0..num_handles {
2281 decoder.drop_next_handle()?;
2282 }
2283 *self = TimeRemaining::__SourceBreaking { unknown_ordinal: ordinal };
2284 }
2285 }
2286 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2287 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2288 }
2289 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2290 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2291 }
2292 Ok(())
2293 }
2294 }
2295}