fidl_fuchsia_usb_policy__common/
fidl_fuchsia_usb_policy__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/// A snapshot of the USB controller's current status and health.
12#[derive(Clone, Debug, Default, PartialEq)]
13pub struct HealthReport {
14    /// The current state of the device as defined by the USB 2.0 spec.
15    pub state: Option<fidl_fuchsia_hardware_usb_policy__common::DeviceState>,
16    /// The address assigned to the USB device.
17    pub address: Option<u8>,
18    #[doc(hidden)]
19    pub __source_breaking: fidl::marker::SourceBreaking,
20}
21
22impl fidl::Persistable for HealthReport {}
23
24pub mod health_ordinals {
25    pub const GET_REPORT: u64 = 0x45f3bc8cbb38e701;
26}
27
28pub mod policy_provider_ordinals {
29    pub const WATCH_DEVICE_STATE: u64 = 0x44628a2275753738;
30}
31
32mod internal {
33    use super::*;
34
35    impl HealthReport {
36        #[inline(always)]
37        fn max_ordinal_present(&self) -> u64 {
38            if let Some(_) = self.address {
39                return 2;
40            }
41            if let Some(_) = self.state {
42                return 1;
43            }
44            0
45        }
46    }
47
48    impl fidl::encoding::ValueTypeMarker for HealthReport {
49        type Borrowed<'a> = &'a Self;
50        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
51            value
52        }
53    }
54
55    unsafe impl fidl::encoding::TypeMarker for HealthReport {
56        type Owned = Self;
57
58        #[inline(always)]
59        fn inline_align(_context: fidl::encoding::Context) -> usize {
60            8
61        }
62
63        #[inline(always)]
64        fn inline_size(_context: fidl::encoding::Context) -> usize {
65            16
66        }
67    }
68
69    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HealthReport, D>
70        for &HealthReport
71    {
72        unsafe fn encode(
73            self,
74            encoder: &mut fidl::encoding::Encoder<'_, D>,
75            offset: usize,
76            mut depth: fidl::encoding::Depth,
77        ) -> fidl::Result<()> {
78            encoder.debug_check_bounds::<HealthReport>(offset);
79            // Vector header
80            let max_ordinal: u64 = self.max_ordinal_present();
81            encoder.write_num(max_ordinal, offset);
82            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83            // Calling encoder.out_of_line_offset(0) is not allowed.
84            if max_ordinal == 0 {
85                return Ok(());
86            }
87            depth.increment()?;
88            let envelope_size = 8;
89            let bytes_len = max_ordinal as usize * envelope_size;
90            #[allow(unused_variables)]
91            let offset = encoder.out_of_line_offset(bytes_len);
92            let mut _prev_end_offset: usize = 0;
93            if 1 > max_ordinal {
94                return Ok(());
95            }
96
97            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
98            // are envelope_size bytes.
99            let cur_offset: usize = (1 - 1) * envelope_size;
100
101            // Zero reserved fields.
102            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
103
104            // Safety:
105            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
106            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
107            //   envelope_size bytes, there is always sufficient room.
108            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_usb_policy__common::DeviceState, D>(
109            self.state.as_ref().map(<fidl_fuchsia_hardware_usb_policy__common::DeviceState as fidl::encoding::ValueTypeMarker>::borrow),
110            encoder, offset + cur_offset, depth
111        )?;
112
113            _prev_end_offset = cur_offset + envelope_size;
114            if 2 > max_ordinal {
115                return Ok(());
116            }
117
118            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
119            // are envelope_size bytes.
120            let cur_offset: usize = (2 - 1) * envelope_size;
121
122            // Zero reserved fields.
123            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
124
125            // Safety:
126            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
127            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
128            //   envelope_size bytes, there is always sufficient room.
129            fidl::encoding::encode_in_envelope_optional::<u8, D>(
130                self.address.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
131                encoder,
132                offset + cur_offset,
133                depth,
134            )?;
135
136            _prev_end_offset = cur_offset + envelope_size;
137
138            Ok(())
139        }
140    }
141
142    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthReport {
143        #[inline(always)]
144        fn new_empty() -> Self {
145            Self::default()
146        }
147
148        unsafe fn decode(
149            &mut self,
150            decoder: &mut fidl::encoding::Decoder<'_, D>,
151            offset: usize,
152            mut depth: fidl::encoding::Depth,
153        ) -> fidl::Result<()> {
154            decoder.debug_check_bounds::<Self>(offset);
155            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
156                None => return Err(fidl::Error::NotNullable),
157                Some(len) => len,
158            };
159            // Calling decoder.out_of_line_offset(0) is not allowed.
160            if len == 0 {
161                return Ok(());
162            };
163            depth.increment()?;
164            let envelope_size = 8;
165            let bytes_len = len * envelope_size;
166            let offset = decoder.out_of_line_offset(bytes_len)?;
167            // Decode the envelope for each type.
168            let mut _next_ordinal_to_read = 0;
169            let mut next_offset = offset;
170            let end_offset = offset + bytes_len;
171            _next_ordinal_to_read += 1;
172            if next_offset >= end_offset {
173                return Ok(());
174            }
175
176            // Decode unknown envelopes for gaps in ordinals.
177            while _next_ordinal_to_read < 1 {
178                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
179                _next_ordinal_to_read += 1;
180                next_offset += envelope_size;
181            }
182
183            let next_out_of_line = decoder.next_out_of_line();
184            let handles_before = decoder.remaining_handles();
185            if let Some((inlined, num_bytes, num_handles)) =
186                fidl::encoding::decode_envelope_header(decoder, next_offset)?
187            {
188                let member_inline_size = <fidl_fuchsia_hardware_usb_policy__common::DeviceState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
189                if inlined != (member_inline_size <= 4) {
190                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
191                }
192                let inner_offset;
193                let mut inner_depth = depth.clone();
194                if inlined {
195                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
196                    inner_offset = next_offset;
197                } else {
198                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
199                    inner_depth.increment()?;
200                }
201                let val_ref = self.state.get_or_insert_with(|| {
202                    fidl::new_empty!(fidl_fuchsia_hardware_usb_policy__common::DeviceState, D)
203                });
204                fidl::decode!(
205                    fidl_fuchsia_hardware_usb_policy__common::DeviceState,
206                    D,
207                    val_ref,
208                    decoder,
209                    inner_offset,
210                    inner_depth
211                )?;
212                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
213                {
214                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
215                }
216                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
217                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
218                }
219            }
220
221            next_offset += envelope_size;
222            _next_ordinal_to_read += 1;
223            if next_offset >= end_offset {
224                return Ok(());
225            }
226
227            // Decode unknown envelopes for gaps in ordinals.
228            while _next_ordinal_to_read < 2 {
229                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
230                _next_ordinal_to_read += 1;
231                next_offset += envelope_size;
232            }
233
234            let next_out_of_line = decoder.next_out_of_line();
235            let handles_before = decoder.remaining_handles();
236            if let Some((inlined, num_bytes, num_handles)) =
237                fidl::encoding::decode_envelope_header(decoder, next_offset)?
238            {
239                let member_inline_size =
240                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
241                if inlined != (member_inline_size <= 4) {
242                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
243                }
244                let inner_offset;
245                let mut inner_depth = depth.clone();
246                if inlined {
247                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
248                    inner_offset = next_offset;
249                } else {
250                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
251                    inner_depth.increment()?;
252                }
253                let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u8, D));
254                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
255                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
256                {
257                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
258                }
259                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
260                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
261                }
262            }
263
264            next_offset += envelope_size;
265
266            // Decode the remaining unknown envelopes.
267            while next_offset < end_offset {
268                _next_ordinal_to_read += 1;
269                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
270                next_offset += envelope_size;
271            }
272
273            Ok(())
274        }
275    }
276}
fidl_fuchsia_usb_policy__common/fidl_fuchsia_usb_policy__common.rs

fidl_fuchsia_usb_policy__common/
fidl_fuchsia_usb_policy__common.rs
