Skip to main content

fidl_fuchsia_system_state_common/
fidl_fuchsia_system_state_common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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/// The number of variants of `SystemPowerState`.
12pub const MAX_SYSTEM_POWER_STATES: u32 = 6;
13
14#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
15#[repr(u8)]
16pub enum SystemPowerState {
17    FullyOn = 1,
18    Reboot = 2,
19    RebootBootloader = 3,
20    RebootRecovery = 4,
21    Poweroff = 5,
22    RebootKernelInitiated = 8,
23}
24
25impl SystemPowerState {
26    #[inline]
27    pub fn from_primitive(prim: u8) -> Option<Self> {
28        match prim {
29            1 => Some(Self::FullyOn),
30            2 => Some(Self::Reboot),
31            3 => Some(Self::RebootBootloader),
32            4 => Some(Self::RebootRecovery),
33            5 => Some(Self::Poweroff),
34            8 => Some(Self::RebootKernelInitiated),
35            _ => None,
36        }
37    }
38
39    #[inline]
40    pub const fn into_primitive(self) -> u8 {
41        self as u8
42    }
43}
44
45#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
46pub struct SystemStateTransitionGetTerminationSystemStateResponse {
47    pub state: SystemPowerState,
48}
49
50impl fidl::Persistable for SystemStateTransitionGetTerminationSystemStateResponse {}
51
52pub mod system_state_transition_ordinals {
53    pub const GET_TERMINATION_SYSTEM_STATE: u64 = 0x7570e8c601c5e27e;
54}
55
56mod internal {
57    use super::*;
58    unsafe impl fidl::encoding::TypeMarker for SystemPowerState {
59        type Owned = Self;
60
61        #[inline(always)]
62        fn inline_align(_context: fidl::encoding::Context) -> usize {
63            std::mem::align_of::<u8>()
64        }
65
66        #[inline(always)]
67        fn inline_size(_context: fidl::encoding::Context) -> usize {
68            std::mem::size_of::<u8>()
69        }
70
71        #[inline(always)]
72        fn encode_is_copy() -> bool {
73            true
74        }
75
76        #[inline(always)]
77        fn decode_is_copy() -> bool {
78            false
79        }
80    }
81
82    impl fidl::encoding::ValueTypeMarker for SystemPowerState {
83        type Borrowed<'a> = Self;
84        #[inline(always)]
85        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
86            *value
87        }
88    }
89
90    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
91        for SystemPowerState
92    {
93        #[inline]
94        unsafe fn encode(
95            self,
96            encoder: &mut fidl::encoding::Encoder<'_, D>,
97            offset: usize,
98            _depth: fidl::encoding::Depth,
99        ) -> fidl::Result<()> {
100            encoder.debug_check_bounds::<Self>(offset);
101            encoder.write_num(self.into_primitive(), offset);
102            Ok(())
103        }
104    }
105
106    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SystemPowerState {
107        #[inline(always)]
108        fn new_empty() -> Self {
109            Self::FullyOn
110        }
111
112        #[inline]
113        unsafe fn decode(
114            &mut self,
115            decoder: &mut fidl::encoding::Decoder<'_, D>,
116            offset: usize,
117            _depth: fidl::encoding::Depth,
118        ) -> fidl::Result<()> {
119            decoder.debug_check_bounds::<Self>(offset);
120            let prim = decoder.read_num::<u8>(offset);
121
122            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
123            Ok(())
124        }
125    }
126
127    impl fidl::encoding::ValueTypeMarker for SystemStateTransitionGetTerminationSystemStateResponse {
128        type Borrowed<'a> = &'a Self;
129        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
130            value
131        }
132    }
133
134    unsafe impl fidl::encoding::TypeMarker for SystemStateTransitionGetTerminationSystemStateResponse {
135        type Owned = Self;
136
137        #[inline(always)]
138        fn inline_align(_context: fidl::encoding::Context) -> usize {
139            1
140        }
141
142        #[inline(always)]
143        fn inline_size(_context: fidl::encoding::Context) -> usize {
144            1
145        }
146    }
147
148    unsafe impl<D: fidl::encoding::ResourceDialect>
149        fidl::encoding::Encode<SystemStateTransitionGetTerminationSystemStateResponse, D>
150        for &SystemStateTransitionGetTerminationSystemStateResponse
151    {
152        #[inline]
153        unsafe fn encode(
154            self,
155            encoder: &mut fidl::encoding::Encoder<'_, D>,
156            offset: usize,
157            _depth: fidl::encoding::Depth,
158        ) -> fidl::Result<()> {
159            encoder.debug_check_bounds::<SystemStateTransitionGetTerminationSystemStateResponse>(
160                offset,
161            );
162            // Delegate to tuple encoding.
163            fidl::encoding::Encode::<SystemStateTransitionGetTerminationSystemStateResponse, D>::encode(
164                (
165                    <SystemPowerState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
166                ),
167                encoder, offset, _depth
168            )
169        }
170    }
171    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SystemPowerState, D>>
172        fidl::encoding::Encode<SystemStateTransitionGetTerminationSystemStateResponse, D> for (T0,)
173    {
174        #[inline]
175        unsafe fn encode(
176            self,
177            encoder: &mut fidl::encoding::Encoder<'_, D>,
178            offset: usize,
179            depth: fidl::encoding::Depth,
180        ) -> fidl::Result<()> {
181            encoder.debug_check_bounds::<SystemStateTransitionGetTerminationSystemStateResponse>(
182                offset,
183            );
184            // Zero out padding regions. There's no need to apply masks
185            // because the unmasked parts will be overwritten by fields.
186            // Write the fields.
187            self.0.encode(encoder, offset + 0, depth)?;
188            Ok(())
189        }
190    }
191
192    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
193        for SystemStateTransitionGetTerminationSystemStateResponse
194    {
195        #[inline(always)]
196        fn new_empty() -> Self {
197            Self { state: fidl::new_empty!(SystemPowerState, D) }
198        }
199
200        #[inline]
201        unsafe fn decode(
202            &mut self,
203            decoder: &mut fidl::encoding::Decoder<'_, D>,
204            offset: usize,
205            _depth: fidl::encoding::Depth,
206        ) -> fidl::Result<()> {
207            decoder.debug_check_bounds::<Self>(offset);
208            // Verify that padding bytes are zero.
209            fidl::decode!(SystemPowerState, D, &mut self.state, decoder, offset + 0, _depth)?;
210            Ok(())
211        }
212    }
213}