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 DeviceSetRequest {
22    pub rtc: Time,
23}
24
25impl fidl::Persistable for DeviceSetRequest {}
26
27#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
28#[repr(C)]
29pub struct DeviceGetResponse {
30    pub rtc: Time,
31}
32
33impl fidl::Persistable for DeviceGetResponse {}
34
35#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
36#[repr(C)]
37pub struct DeviceSetResponse {
38    pub status: i32,
39}
40
41impl fidl::Persistable for DeviceSetResponse {}
42
43#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
44#[repr(C)]
45pub struct Time {
46    pub seconds: u8,
47    pub minutes: u8,
48    pub hours: u8,
49    pub day: u8,
50    pub month: u8,
51    pub year: u16,
52}
53
54impl fidl::Persistable for Time {}
55
56pub mod device_ordinals {
57    pub const GET: u64 = 0x27fdad10b3816ff4;
58    pub const SET: u64 = 0x5ff1bca8b571d820;
59    pub const SET2: u64 = 0x16698df780253ae5;
60}
61
62mod internal {
63    use super::*;
64
65    impl fidl::encoding::ValueTypeMarker for DeviceSet2Request {
66        type Borrowed<'a> = &'a Self;
67        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
68            value
69        }
70    }
71
72    unsafe impl fidl::encoding::TypeMarker for DeviceSet2Request {
73        type Owned = Self;
74
75        #[inline(always)]
76        fn inline_align(_context: fidl::encoding::Context) -> usize {
77            2
78        }
79
80        #[inline(always)]
81        fn inline_size(_context: fidl::encoding::Context) -> usize {
82            8
83        }
84    }
85
86    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceSet2Request, D>
87        for &DeviceSet2Request
88    {
89        #[inline]
90        unsafe fn encode(
91            self,
92            encoder: &mut fidl::encoding::Encoder<'_, D>,
93            offset: usize,
94            _depth: fidl::encoding::Depth,
95        ) -> fidl::Result<()> {
96            encoder.debug_check_bounds::<DeviceSet2Request>(offset);
97            unsafe {
98                // Copy the object into the buffer.
99                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
100                (buf_ptr as *mut DeviceSet2Request)
101                    .write_unaligned((self as *const DeviceSet2Request).read());
102                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
103                // done second because the memcpy will write garbage to these bytes.
104                let padding_ptr = buf_ptr.offset(4) as *mut u16;
105                let padding_mask = 0xff00u16;
106                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
107            }
108            Ok(())
109        }
110    }
111    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Time, D>>
112        fidl::encoding::Encode<DeviceSet2Request, D> for (T0,)
113    {
114        #[inline]
115        unsafe fn encode(
116            self,
117            encoder: &mut fidl::encoding::Encoder<'_, D>,
118            offset: usize,
119            depth: fidl::encoding::Depth,
120        ) -> fidl::Result<()> {
121            encoder.debug_check_bounds::<DeviceSet2Request>(offset);
122            // Zero out padding regions. There's no need to apply masks
123            // because the unmasked parts will be overwritten by fields.
124            // Write the fields.
125            self.0.encode(encoder, offset + 0, depth)?;
126            Ok(())
127        }
128    }
129
130    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceSet2Request {
131        #[inline(always)]
132        fn new_empty() -> Self {
133            Self { rtc: fidl::new_empty!(Time, D) }
134        }
135
136        #[inline]
137        unsafe fn decode(
138            &mut self,
139            decoder: &mut fidl::encoding::Decoder<'_, D>,
140            offset: usize,
141            _depth: fidl::encoding::Depth,
142        ) -> fidl::Result<()> {
143            decoder.debug_check_bounds::<Self>(offset);
144            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
145            // Verify that padding bytes are zero.
146            let ptr = unsafe { buf_ptr.offset(4) };
147            let padval = unsafe { (ptr as *const u16).read_unaligned() };
148            let mask = 0xff00u16;
149            let maskedval = padval & mask;
150            if maskedval != 0 {
151                return Err(fidl::Error::NonZeroPadding {
152                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
153                });
154            }
155            // Copy from the buffer into the object.
156            unsafe {
157                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
158            }
159            Ok(())
160        }
161    }
162
163    impl fidl::encoding::ValueTypeMarker for DeviceSetRequest {
164        type Borrowed<'a> = &'a Self;
165        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
166            value
167        }
168    }
169
170    unsafe impl fidl::encoding::TypeMarker for DeviceSetRequest {
171        type Owned = Self;
172
173        #[inline(always)]
174        fn inline_align(_context: fidl::encoding::Context) -> usize {
175            2
176        }
177
178        #[inline(always)]
179        fn inline_size(_context: fidl::encoding::Context) -> usize {
180            8
181        }
182    }
183
184    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceSetRequest, D>
185        for &DeviceSetRequest
186    {
187        #[inline]
188        unsafe fn encode(
189            self,
190            encoder: &mut fidl::encoding::Encoder<'_, D>,
191            offset: usize,
192            _depth: fidl::encoding::Depth,
193        ) -> fidl::Result<()> {
194            encoder.debug_check_bounds::<DeviceSetRequest>(offset);
195            unsafe {
196                // Copy the object into the buffer.
197                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
198                (buf_ptr as *mut DeviceSetRequest)
199                    .write_unaligned((self as *const DeviceSetRequest).read());
200                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
201                // done second because the memcpy will write garbage to these bytes.
202                let padding_ptr = buf_ptr.offset(4) as *mut u16;
203                let padding_mask = 0xff00u16;
204                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
205            }
206            Ok(())
207        }
208    }
209    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Time, D>>
210        fidl::encoding::Encode<DeviceSetRequest, D> for (T0,)
211    {
212        #[inline]
213        unsafe fn encode(
214            self,
215            encoder: &mut fidl::encoding::Encoder<'_, D>,
216            offset: usize,
217            depth: fidl::encoding::Depth,
218        ) -> fidl::Result<()> {
219            encoder.debug_check_bounds::<DeviceSetRequest>(offset);
220            // Zero out padding regions. There's no need to apply masks
221            // because the unmasked parts will be overwritten by fields.
222            // Write the fields.
223            self.0.encode(encoder, offset + 0, depth)?;
224            Ok(())
225        }
226    }
227
228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceSetRequest {
229        #[inline(always)]
230        fn new_empty() -> Self {
231            Self { rtc: fidl::new_empty!(Time, D) }
232        }
233
234        #[inline]
235        unsafe fn decode(
236            &mut self,
237            decoder: &mut fidl::encoding::Decoder<'_, D>,
238            offset: usize,
239            _depth: fidl::encoding::Depth,
240        ) -> fidl::Result<()> {
241            decoder.debug_check_bounds::<Self>(offset);
242            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
243            // Verify that padding bytes are zero.
244            let ptr = unsafe { buf_ptr.offset(4) };
245            let padval = unsafe { (ptr as *const u16).read_unaligned() };
246            let mask = 0xff00u16;
247            let maskedval = padval & mask;
248            if maskedval != 0 {
249                return Err(fidl::Error::NonZeroPadding {
250                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
251                });
252            }
253            // Copy from the buffer into the object.
254            unsafe {
255                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
256            }
257            Ok(())
258        }
259    }
260
261    impl fidl::encoding::ValueTypeMarker for DeviceGetResponse {
262        type Borrowed<'a> = &'a Self;
263        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
264            value
265        }
266    }
267
268    unsafe impl fidl::encoding::TypeMarker for DeviceGetResponse {
269        type Owned = Self;
270
271        #[inline(always)]
272        fn inline_align(_context: fidl::encoding::Context) -> usize {
273            2
274        }
275
276        #[inline(always)]
277        fn inline_size(_context: fidl::encoding::Context) -> usize {
278            8
279        }
280    }
281
282    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceGetResponse, D>
283        for &DeviceGetResponse
284    {
285        #[inline]
286        unsafe fn encode(
287            self,
288            encoder: &mut fidl::encoding::Encoder<'_, D>,
289            offset: usize,
290            _depth: fidl::encoding::Depth,
291        ) -> fidl::Result<()> {
292            encoder.debug_check_bounds::<DeviceGetResponse>(offset);
293            unsafe {
294                // Copy the object into the buffer.
295                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
296                (buf_ptr as *mut DeviceGetResponse)
297                    .write_unaligned((self as *const DeviceGetResponse).read());
298                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
299                // done second because the memcpy will write garbage to these bytes.
300                let padding_ptr = buf_ptr.offset(4) as *mut u16;
301                let padding_mask = 0xff00u16;
302                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
303            }
304            Ok(())
305        }
306    }
307    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Time, D>>
308        fidl::encoding::Encode<DeviceGetResponse, D> for (T0,)
309    {
310        #[inline]
311        unsafe fn encode(
312            self,
313            encoder: &mut fidl::encoding::Encoder<'_, D>,
314            offset: usize,
315            depth: fidl::encoding::Depth,
316        ) -> fidl::Result<()> {
317            encoder.debug_check_bounds::<DeviceGetResponse>(offset);
318            // Zero out padding regions. There's no need to apply masks
319            // because the unmasked parts will be overwritten by fields.
320            // Write the fields.
321            self.0.encode(encoder, offset + 0, depth)?;
322            Ok(())
323        }
324    }
325
326    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceGetResponse {
327        #[inline(always)]
328        fn new_empty() -> Self {
329            Self { rtc: fidl::new_empty!(Time, D) }
330        }
331
332        #[inline]
333        unsafe fn decode(
334            &mut self,
335            decoder: &mut fidl::encoding::Decoder<'_, D>,
336            offset: usize,
337            _depth: fidl::encoding::Depth,
338        ) -> fidl::Result<()> {
339            decoder.debug_check_bounds::<Self>(offset);
340            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
341            // Verify that padding bytes are zero.
342            let ptr = unsafe { buf_ptr.offset(4) };
343            let padval = unsafe { (ptr as *const u16).read_unaligned() };
344            let mask = 0xff00u16;
345            let maskedval = padval & mask;
346            if maskedval != 0 {
347                return Err(fidl::Error::NonZeroPadding {
348                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
349                });
350            }
351            // Copy from the buffer into the object.
352            unsafe {
353                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
354            }
355            Ok(())
356        }
357    }
358
359    impl fidl::encoding::ValueTypeMarker for DeviceSetResponse {
360        type Borrowed<'a> = &'a Self;
361        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
362            value
363        }
364    }
365
366    unsafe impl fidl::encoding::TypeMarker for DeviceSetResponse {
367        type Owned = Self;
368
369        #[inline(always)]
370        fn inline_align(_context: fidl::encoding::Context) -> usize {
371            4
372        }
373
374        #[inline(always)]
375        fn inline_size(_context: fidl::encoding::Context) -> usize {
376            4
377        }
378        #[inline(always)]
379        fn encode_is_copy() -> bool {
380            true
381        }
382
383        #[inline(always)]
384        fn decode_is_copy() -> bool {
385            true
386        }
387    }
388
389    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceSetResponse, D>
390        for &DeviceSetResponse
391    {
392        #[inline]
393        unsafe fn encode(
394            self,
395            encoder: &mut fidl::encoding::Encoder<'_, D>,
396            offset: usize,
397            _depth: fidl::encoding::Depth,
398        ) -> fidl::Result<()> {
399            encoder.debug_check_bounds::<DeviceSetResponse>(offset);
400            unsafe {
401                // Copy the object into the buffer.
402                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
403                (buf_ptr as *mut DeviceSetResponse)
404                    .write_unaligned((self as *const DeviceSetResponse).read());
405                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
406                // done second because the memcpy will write garbage to these bytes.
407            }
408            Ok(())
409        }
410    }
411    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
412        fidl::encoding::Encode<DeviceSetResponse, D> for (T0,)
413    {
414        #[inline]
415        unsafe fn encode(
416            self,
417            encoder: &mut fidl::encoding::Encoder<'_, D>,
418            offset: usize,
419            depth: fidl::encoding::Depth,
420        ) -> fidl::Result<()> {
421            encoder.debug_check_bounds::<DeviceSetResponse>(offset);
422            // Zero out padding regions. There's no need to apply masks
423            // because the unmasked parts will be overwritten by fields.
424            // Write the fields.
425            self.0.encode(encoder, offset + 0, depth)?;
426            Ok(())
427        }
428    }
429
430    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceSetResponse {
431        #[inline(always)]
432        fn new_empty() -> Self {
433            Self { status: fidl::new_empty!(i32, D) }
434        }
435
436        #[inline]
437        unsafe fn decode(
438            &mut self,
439            decoder: &mut fidl::encoding::Decoder<'_, D>,
440            offset: usize,
441            _depth: fidl::encoding::Depth,
442        ) -> fidl::Result<()> {
443            decoder.debug_check_bounds::<Self>(offset);
444            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
445            // Verify that padding bytes are zero.
446            // Copy from the buffer into the object.
447            unsafe {
448                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
449            }
450            Ok(())
451        }
452    }
453
454    impl fidl::encoding::ValueTypeMarker for Time {
455        type Borrowed<'a> = &'a Self;
456        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
457            value
458        }
459    }
460
461    unsafe impl fidl::encoding::TypeMarker for Time {
462        type Owned = Self;
463
464        #[inline(always)]
465        fn inline_align(_context: fidl::encoding::Context) -> usize {
466            2
467        }
468
469        #[inline(always)]
470        fn inline_size(_context: fidl::encoding::Context) -> usize {
471            8
472        }
473    }
474
475    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Time, D> for &Time {
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::<Time>(offset);
484            unsafe {
485                // Copy the object into the buffer.
486                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
487                (buf_ptr as *mut Time).write_unaligned((self as *const Time).read());
488                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
489                // done second because the memcpy will write garbage to these bytes.
490                let padding_ptr = buf_ptr.offset(4) as *mut u16;
491                let padding_mask = 0xff00u16;
492                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
493            }
494            Ok(())
495        }
496    }
497    unsafe impl<
498            D: fidl::encoding::ResourceDialect,
499            T0: fidl::encoding::Encode<u8, D>,
500            T1: fidl::encoding::Encode<u8, D>,
501            T2: fidl::encoding::Encode<u8, D>,
502            T3: fidl::encoding::Encode<u8, D>,
503            T4: fidl::encoding::Encode<u8, D>,
504            T5: fidl::encoding::Encode<u16, D>,
505        > fidl::encoding::Encode<Time, D> for (T0, T1, T2, T3, T4, T5)
506    {
507        #[inline]
508        unsafe fn encode(
509            self,
510            encoder: &mut fidl::encoding::Encoder<'_, D>,
511            offset: usize,
512            depth: fidl::encoding::Depth,
513        ) -> fidl::Result<()> {
514            encoder.debug_check_bounds::<Time>(offset);
515            // Zero out padding regions. There's no need to apply masks
516            // because the unmasked parts will be overwritten by fields.
517            unsafe {
518                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
519                (ptr as *mut u16).write_unaligned(0);
520            }
521            // Write the fields.
522            self.0.encode(encoder, offset + 0, depth)?;
523            self.1.encode(encoder, offset + 1, depth)?;
524            self.2.encode(encoder, offset + 2, depth)?;
525            self.3.encode(encoder, offset + 3, depth)?;
526            self.4.encode(encoder, offset + 4, depth)?;
527            self.5.encode(encoder, offset + 6, depth)?;
528            Ok(())
529        }
530    }
531
532    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Time {
533        #[inline(always)]
534        fn new_empty() -> Self {
535            Self {
536                seconds: fidl::new_empty!(u8, D),
537                minutes: fidl::new_empty!(u8, D),
538                hours: fidl::new_empty!(u8, D),
539                day: fidl::new_empty!(u8, D),
540                month: fidl::new_empty!(u8, D),
541                year: fidl::new_empty!(u16, D),
542            }
543        }
544
545        #[inline]
546        unsafe fn decode(
547            &mut self,
548            decoder: &mut fidl::encoding::Decoder<'_, D>,
549            offset: usize,
550            _depth: fidl::encoding::Depth,
551        ) -> fidl::Result<()> {
552            decoder.debug_check_bounds::<Self>(offset);
553            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
554            // Verify that padding bytes are zero.
555            let ptr = unsafe { buf_ptr.offset(4) };
556            let padval = unsafe { (ptr as *const u16).read_unaligned() };
557            let mask = 0xff00u16;
558            let maskedval = padval & mask;
559            if maskedval != 0 {
560                return Err(fidl::Error::NonZeroPadding {
561                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
562                });
563            }
564            // Copy from the buffer into the object.
565            unsafe {
566                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
567            }
568            Ok(())
569        }
570    }
571}
fidl_fuchsia_hardware_rtc__common/fidl_fuchsia_hardware_rtc__common.rs

fidl_fuchsia_hardware_rtc__common/
fidl_fuchsia_hardware_rtc__common.rs
