fidl_fuchsia_hardware_rtc__common/
fidl_fuchsia_hardware_rtc__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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12#[repr(C)]
13pub struct DeviceSet2Request {
14    pub rtc: Time,
15}
16
17impl fidl::Persistable for DeviceSet2Request {}
18
19#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
20#[repr(C)]
21pub struct DeviceGetResponse {
22    pub rtc: Time,
23}
24
25impl fidl::Persistable for DeviceGetResponse {}
26
27#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
28#[repr(C)]
29pub struct Time {
30    pub seconds: u8,
31    pub minutes: u8,
32    pub hours: u8,
33    pub day: u8,
34    pub month: u8,
35    pub year: u16,
36}
37
38impl fidl::Persistable for Time {}
39
40pub mod device_ordinals {
41    pub const GET: u64 = 0x27fdad10b3816ff4;
42    pub const SET2: u64 = 0x16698df780253ae5;
43}
44
45mod internal {
46    use super::*;
47
48    impl fidl::encoding::ValueTypeMarker for DeviceSet2Request {
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 DeviceSet2Request {
56        type Owned = Self;
57
58        #[inline(always)]
59        fn inline_align(_context: fidl::encoding::Context) -> usize {
60            2
61        }
62
63        #[inline(always)]
64        fn inline_size(_context: fidl::encoding::Context) -> usize {
65            8
66        }
67    }
68
69    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceSet2Request, D>
70        for &DeviceSet2Request
71    {
72        #[inline]
73        unsafe fn encode(
74            self,
75            encoder: &mut fidl::encoding::Encoder<'_, D>,
76            offset: usize,
77            _depth: fidl::encoding::Depth,
78        ) -> fidl::Result<()> {
79            encoder.debug_check_bounds::<DeviceSet2Request>(offset);
80            unsafe {
81                // Copy the object into the buffer.
82                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
83                (buf_ptr as *mut DeviceSet2Request)
84                    .write_unaligned((self as *const DeviceSet2Request).read());
85                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
86                // done second because the memcpy will write garbage to these bytes.
87                let padding_ptr = buf_ptr.offset(4) as *mut u16;
88                let padding_mask = 0xff00u16;
89                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
90            }
91            Ok(())
92        }
93    }
94    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Time, D>>
95        fidl::encoding::Encode<DeviceSet2Request, D> for (T0,)
96    {
97        #[inline]
98        unsafe fn encode(
99            self,
100            encoder: &mut fidl::encoding::Encoder<'_, D>,
101            offset: usize,
102            depth: fidl::encoding::Depth,
103        ) -> fidl::Result<()> {
104            encoder.debug_check_bounds::<DeviceSet2Request>(offset);
105            // Zero out padding regions. There's no need to apply masks
106            // because the unmasked parts will be overwritten by fields.
107            // Write the fields.
108            self.0.encode(encoder, offset + 0, depth)?;
109            Ok(())
110        }
111    }
112
113    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceSet2Request {
114        #[inline(always)]
115        fn new_empty() -> Self {
116            Self { rtc: fidl::new_empty!(Time, D) }
117        }
118
119        #[inline]
120        unsafe fn decode(
121            &mut self,
122            decoder: &mut fidl::encoding::Decoder<'_, D>,
123            offset: usize,
124            _depth: fidl::encoding::Depth,
125        ) -> fidl::Result<()> {
126            decoder.debug_check_bounds::<Self>(offset);
127            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
128            // Verify that padding bytes are zero.
129            let ptr = unsafe { buf_ptr.offset(4) };
130            let padval = unsafe { (ptr as *const u16).read_unaligned() };
131            let mask = 0xff00u16;
132            let maskedval = padval & mask;
133            if maskedval != 0 {
134                return Err(fidl::Error::NonZeroPadding {
135                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
136                });
137            }
138            // Copy from the buffer into the object.
139            unsafe {
140                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
141            }
142            Ok(())
143        }
144    }
145
146    impl fidl::encoding::ValueTypeMarker for DeviceGetResponse {
147        type Borrowed<'a> = &'a Self;
148        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
149            value
150        }
151    }
152
153    unsafe impl fidl::encoding::TypeMarker for DeviceGetResponse {
154        type Owned = Self;
155
156        #[inline(always)]
157        fn inline_align(_context: fidl::encoding::Context) -> usize {
158            2
159        }
160
161        #[inline(always)]
162        fn inline_size(_context: fidl::encoding::Context) -> usize {
163            8
164        }
165    }
166
167    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceGetResponse, D>
168        for &DeviceGetResponse
169    {
170        #[inline]
171        unsafe fn encode(
172            self,
173            encoder: &mut fidl::encoding::Encoder<'_, D>,
174            offset: usize,
175            _depth: fidl::encoding::Depth,
176        ) -> fidl::Result<()> {
177            encoder.debug_check_bounds::<DeviceGetResponse>(offset);
178            unsafe {
179                // Copy the object into the buffer.
180                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
181                (buf_ptr as *mut DeviceGetResponse)
182                    .write_unaligned((self as *const DeviceGetResponse).read());
183                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
184                // done second because the memcpy will write garbage to these bytes.
185                let padding_ptr = buf_ptr.offset(4) as *mut u16;
186                let padding_mask = 0xff00u16;
187                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
188            }
189            Ok(())
190        }
191    }
192    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Time, D>>
193        fidl::encoding::Encode<DeviceGetResponse, D> for (T0,)
194    {
195        #[inline]
196        unsafe fn encode(
197            self,
198            encoder: &mut fidl::encoding::Encoder<'_, D>,
199            offset: usize,
200            depth: fidl::encoding::Depth,
201        ) -> fidl::Result<()> {
202            encoder.debug_check_bounds::<DeviceGetResponse>(offset);
203            // Zero out padding regions. There's no need to apply masks
204            // because the unmasked parts will be overwritten by fields.
205            // Write the fields.
206            self.0.encode(encoder, offset + 0, depth)?;
207            Ok(())
208        }
209    }
210
211    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceGetResponse {
212        #[inline(always)]
213        fn new_empty() -> Self {
214            Self { rtc: fidl::new_empty!(Time, D) }
215        }
216
217        #[inline]
218        unsafe fn decode(
219            &mut self,
220            decoder: &mut fidl::encoding::Decoder<'_, D>,
221            offset: usize,
222            _depth: fidl::encoding::Depth,
223        ) -> fidl::Result<()> {
224            decoder.debug_check_bounds::<Self>(offset);
225            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
226            // Verify that padding bytes are zero.
227            let ptr = unsafe { buf_ptr.offset(4) };
228            let padval = unsafe { (ptr as *const u16).read_unaligned() };
229            let mask = 0xff00u16;
230            let maskedval = padval & mask;
231            if maskedval != 0 {
232                return Err(fidl::Error::NonZeroPadding {
233                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
234                });
235            }
236            // Copy from the buffer into the object.
237            unsafe {
238                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
239            }
240            Ok(())
241        }
242    }
243
244    impl fidl::encoding::ValueTypeMarker for Time {
245        type Borrowed<'a> = &'a Self;
246        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
247            value
248        }
249    }
250
251    unsafe impl fidl::encoding::TypeMarker for Time {
252        type Owned = Self;
253
254        #[inline(always)]
255        fn inline_align(_context: fidl::encoding::Context) -> usize {
256            2
257        }
258
259        #[inline(always)]
260        fn inline_size(_context: fidl::encoding::Context) -> usize {
261            8
262        }
263    }
264
265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Time, D> for &Time {
266        #[inline]
267        unsafe fn encode(
268            self,
269            encoder: &mut fidl::encoding::Encoder<'_, D>,
270            offset: usize,
271            _depth: fidl::encoding::Depth,
272        ) -> fidl::Result<()> {
273            encoder.debug_check_bounds::<Time>(offset);
274            unsafe {
275                // Copy the object into the buffer.
276                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
277                (buf_ptr as *mut Time).write_unaligned((self as *const Time).read());
278                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
279                // done second because the memcpy will write garbage to these bytes.
280                let padding_ptr = buf_ptr.offset(4) as *mut u16;
281                let padding_mask = 0xff00u16;
282                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
283            }
284            Ok(())
285        }
286    }
287    unsafe impl<
288        D: fidl::encoding::ResourceDialect,
289        T0: fidl::encoding::Encode<u8, D>,
290        T1: fidl::encoding::Encode<u8, D>,
291        T2: fidl::encoding::Encode<u8, D>,
292        T3: fidl::encoding::Encode<u8, D>,
293        T4: fidl::encoding::Encode<u8, D>,
294        T5: fidl::encoding::Encode<u16, D>,
295    > fidl::encoding::Encode<Time, D> for (T0, T1, T2, T3, T4, T5)
296    {
297        #[inline]
298        unsafe fn encode(
299            self,
300            encoder: &mut fidl::encoding::Encoder<'_, D>,
301            offset: usize,
302            depth: fidl::encoding::Depth,
303        ) -> fidl::Result<()> {
304            encoder.debug_check_bounds::<Time>(offset);
305            // Zero out padding regions. There's no need to apply masks
306            // because the unmasked parts will be overwritten by fields.
307            unsafe {
308                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
309                (ptr as *mut u16).write_unaligned(0);
310            }
311            // Write the fields.
312            self.0.encode(encoder, offset + 0, depth)?;
313            self.1.encode(encoder, offset + 1, depth)?;
314            self.2.encode(encoder, offset + 2, depth)?;
315            self.3.encode(encoder, offset + 3, depth)?;
316            self.4.encode(encoder, offset + 4, depth)?;
317            self.5.encode(encoder, offset + 6, depth)?;
318            Ok(())
319        }
320    }
321
322    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Time {
323        #[inline(always)]
324        fn new_empty() -> Self {
325            Self {
326                seconds: fidl::new_empty!(u8, D),
327                minutes: fidl::new_empty!(u8, D),
328                hours: fidl::new_empty!(u8, D),
329                day: fidl::new_empty!(u8, D),
330                month: fidl::new_empty!(u8, D),
331                year: fidl::new_empty!(u16, D),
332            }
333        }
334
335        #[inline]
336        unsafe fn decode(
337            &mut self,
338            decoder: &mut fidl::encoding::Decoder<'_, D>,
339            offset: usize,
340            _depth: fidl::encoding::Depth,
341        ) -> fidl::Result<()> {
342            decoder.debug_check_bounds::<Self>(offset);
343            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
344            // Verify that padding bytes are zero.
345            let ptr = unsafe { buf_ptr.offset(4) };
346            let padval = unsafe { (ptr as *const u16).read_unaligned() };
347            let mask = 0xff00u16;
348            let maskedval = padval & mask;
349            if maskedval != 0 {
350                return Err(fidl::Error::NonZeroPadding {
351                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
352                });
353            }
354            // Copy from the buffer into the object.
355            unsafe {
356                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
357            }
358            Ok(())
359        }
360    }
361}
fidl_fuchsia_hardware_rtc__common/fidl_fuchsia_hardware_rtc__common.rs

fidl_fuchsia_hardware_rtc__common/
fidl_fuchsia_hardware_rtc__common.rs
