fidl_next_common_fuchsia_hardware_rtc/
fidl_next_common_fuchsia_hardware_rtc.rs

1// DO NOT EDIT: This file is machine-generated by fidlgen
2#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8    pub struct Time {
9        pub seconds: u8,
10
11        pub minutes: u8,
12
13        pub hours: u8,
14
15        pub day: u8,
16
17        pub month: u8,
18
19        pub year: u16,
20    }
21
22    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Time, ___E> for Time
23    where
24        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
25    {
26        #[inline]
27        fn encode(
28            self,
29            encoder_: &mut ___E,
30            out_: &mut ::core::mem::MaybeUninit<crate::wire::Time>,
31            _: (),
32        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
33            ::fidl_next::munge! {
34                let crate::wire::Time {
35                    seconds,
36                    minutes,
37                    hours,
38                    day,
39                    month,
40                    year,
41
42                } = out_;
43            }
44
45            ::fidl_next::Encode::encode(self.seconds, encoder_, seconds, ())?;
46
47            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(seconds.as_mut_ptr()) };
48
49            ::fidl_next::Encode::encode(self.minutes, encoder_, minutes, ())?;
50
51            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(minutes.as_mut_ptr()) };
52
53            ::fidl_next::Encode::encode(self.hours, encoder_, hours, ())?;
54
55            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(hours.as_mut_ptr()) };
56
57            ::fidl_next::Encode::encode(self.day, encoder_, day, ())?;
58
59            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(day.as_mut_ptr()) };
60
61            ::fidl_next::Encode::encode(self.month, encoder_, month, ())?;
62
63            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(month.as_mut_ptr()) };
64
65            ::fidl_next::Encode::encode(self.year, encoder_, year, ())?;
66
67            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(year.as_mut_ptr()) };
68
69            Ok(())
70        }
71    }
72
73    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Time, ___E> for &'a Time
74    where
75        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
76    {
77        #[inline]
78        fn encode(
79            self,
80            encoder_: &mut ___E,
81            out_: &mut ::core::mem::MaybeUninit<crate::wire::Time>,
82            _: (),
83        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
84            ::fidl_next::munge! {
85                let crate::wire::Time {
86                    seconds,
87                    minutes,
88                    hours,
89                    day,
90                    month,
91                    year,
92
93                } = out_;
94            }
95
96            ::fidl_next::Encode::encode(&self.seconds, encoder_, seconds, ())?;
97
98            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(seconds.as_mut_ptr()) };
99
100            ::fidl_next::Encode::encode(&self.minutes, encoder_, minutes, ())?;
101
102            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(minutes.as_mut_ptr()) };
103
104            ::fidl_next::Encode::encode(&self.hours, encoder_, hours, ())?;
105
106            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(hours.as_mut_ptr()) };
107
108            ::fidl_next::Encode::encode(&self.day, encoder_, day, ())?;
109
110            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(day.as_mut_ptr()) };
111
112            ::fidl_next::Encode::encode(&self.month, encoder_, month, ())?;
113
114            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(month.as_mut_ptr()) };
115
116            ::fidl_next::Encode::encode(&self.year, encoder_, year, ())?;
117
118            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(year.as_mut_ptr()) };
119
120            Ok(())
121        }
122    }
123
124    unsafe impl<___E>
125        ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Time>, ___E> for Time
126    where
127        ___E: ::fidl_next::Encoder + ?Sized,
128        Time: ::fidl_next::Encode<crate::wire::Time, ___E>,
129    {
130        #[inline]
131        fn encode_option(
132            this: ::core::option::Option<Self>,
133            encoder: &mut ___E,
134            out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Time>>,
135            _: (),
136        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
137            if let Some(inner) = this {
138                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
139                ::fidl_next::wire::Box::encode_present(out);
140            } else {
141                ::fidl_next::wire::Box::encode_absent(out);
142            }
143
144            Ok(())
145        }
146    }
147
148    unsafe impl<'a, ___E>
149        ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Time>, ___E>
150        for &'a Time
151    where
152        ___E: ::fidl_next::Encoder + ?Sized,
153        &'a Time: ::fidl_next::Encode<crate::wire::Time, ___E>,
154    {
155        #[inline]
156        fn encode_option(
157            this: ::core::option::Option<Self>,
158            encoder: &mut ___E,
159            out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Time>>,
160            _: (),
161        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
162            if let Some(inner) = this {
163                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
164                ::fidl_next::wire::Box::encode_present(out);
165            } else {
166                ::fidl_next::wire::Box::encode_absent(out);
167            }
168
169            Ok(())
170        }
171    }
172
173    impl ::fidl_next::FromWire<crate::wire::Time> for Time {
174        #[inline]
175        fn from_wire(wire: crate::wire::Time) -> Self {
176            Self {
177                seconds: ::fidl_next::FromWire::from_wire(wire.seconds),
178
179                minutes: ::fidl_next::FromWire::from_wire(wire.minutes),
180
181                hours: ::fidl_next::FromWire::from_wire(wire.hours),
182
183                day: ::fidl_next::FromWire::from_wire(wire.day),
184
185                month: ::fidl_next::FromWire::from_wire(wire.month),
186
187                year: ::fidl_next::FromWire::from_wire(wire.year),
188            }
189        }
190    }
191
192    impl ::fidl_next::FromWireRef<crate::wire::Time> for Time {
193        #[inline]
194        fn from_wire_ref(wire: &crate::wire::Time) -> Self {
195            Self {
196                seconds: ::fidl_next::FromWireRef::from_wire_ref(&wire.seconds),
197
198                minutes: ::fidl_next::FromWireRef::from_wire_ref(&wire.minutes),
199
200                hours: ::fidl_next::FromWireRef::from_wire_ref(&wire.hours),
201
202                day: ::fidl_next::FromWireRef::from_wire_ref(&wire.day),
203
204                month: ::fidl_next::FromWireRef::from_wire_ref(&wire.month),
205
206                year: ::fidl_next::FromWireRef::from_wire_ref(&wire.year),
207            }
208        }
209    }
210
211    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
212    pub struct DeviceGetResponse {
213        pub rtc: crate::natural::Time,
214    }
215
216    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetResponse, ___E> for DeviceGetResponse
217    where
218        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
219    {
220        #[inline]
221        fn encode(
222            self,
223            encoder_: &mut ___E,
224            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetResponse>,
225            _: (),
226        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
227            ::fidl_next::munge! {
228                let crate::wire::DeviceGetResponse {
229                    rtc,
230
231                } = out_;
232            }
233
234            ::fidl_next::Encode::encode(self.rtc, encoder_, rtc, ())?;
235
236            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rtc.as_mut_ptr()) };
237
238            Ok(())
239        }
240    }
241
242    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceGetResponse, ___E>
243        for &'a DeviceGetResponse
244    where
245        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
246    {
247        #[inline]
248        fn encode(
249            self,
250            encoder_: &mut ___E,
251            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetResponse>,
252            _: (),
253        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
254            ::fidl_next::munge! {
255                let crate::wire::DeviceGetResponse {
256                    rtc,
257
258                } = out_;
259            }
260
261            ::fidl_next::Encode::encode(&self.rtc, encoder_, rtc, ())?;
262
263            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rtc.as_mut_ptr()) };
264
265            Ok(())
266        }
267    }
268
269    unsafe impl<___E>
270        ::fidl_next::EncodeOption<
271            ::fidl_next::wire::Box<'static, crate::wire::DeviceGetResponse>,
272            ___E,
273        > for DeviceGetResponse
274    where
275        ___E: ::fidl_next::Encoder + ?Sized,
276        DeviceGetResponse: ::fidl_next::Encode<crate::wire::DeviceGetResponse, ___E>,
277    {
278        #[inline]
279        fn encode_option(
280            this: ::core::option::Option<Self>,
281            encoder: &mut ___E,
282            out: &mut ::core::mem::MaybeUninit<
283                ::fidl_next::wire::Box<'static, crate::wire::DeviceGetResponse>,
284            >,
285            _: (),
286        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
287            if let Some(inner) = this {
288                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
289                ::fidl_next::wire::Box::encode_present(out);
290            } else {
291                ::fidl_next::wire::Box::encode_absent(out);
292            }
293
294            Ok(())
295        }
296    }
297
298    unsafe impl<'a, ___E>
299        ::fidl_next::EncodeOption<
300            ::fidl_next::wire::Box<'static, crate::wire::DeviceGetResponse>,
301            ___E,
302        > for &'a DeviceGetResponse
303    where
304        ___E: ::fidl_next::Encoder + ?Sized,
305        &'a DeviceGetResponse: ::fidl_next::Encode<crate::wire::DeviceGetResponse, ___E>,
306    {
307        #[inline]
308        fn encode_option(
309            this: ::core::option::Option<Self>,
310            encoder: &mut ___E,
311            out: &mut ::core::mem::MaybeUninit<
312                ::fidl_next::wire::Box<'static, crate::wire::DeviceGetResponse>,
313            >,
314            _: (),
315        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
316            if let Some(inner) = this {
317                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
318                ::fidl_next::wire::Box::encode_present(out);
319            } else {
320                ::fidl_next::wire::Box::encode_absent(out);
321            }
322
323            Ok(())
324        }
325    }
326
327    impl ::fidl_next::FromWire<crate::wire::DeviceGetResponse> for DeviceGetResponse {
328        #[inline]
329        fn from_wire(wire: crate::wire::DeviceGetResponse) -> Self {
330            Self { rtc: ::fidl_next::FromWire::from_wire(wire.rtc) }
331        }
332    }
333
334    impl ::fidl_next::FromWireRef<crate::wire::DeviceGetResponse> for DeviceGetResponse {
335        #[inline]
336        fn from_wire_ref(wire: &crate::wire::DeviceGetResponse) -> Self {
337            Self { rtc: ::fidl_next::FromWireRef::from_wire_ref(&wire.rtc) }
338        }
339    }
340
341    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
342    pub struct DeviceSet2Request {
343        pub rtc: crate::natural::Time,
344    }
345
346    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceSet2Request, ___E> for DeviceSet2Request
347    where
348        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
349    {
350        #[inline]
351        fn encode(
352            self,
353            encoder_: &mut ___E,
354            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSet2Request>,
355            _: (),
356        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
357            ::fidl_next::munge! {
358                let crate::wire::DeviceSet2Request {
359                    rtc,
360
361                } = out_;
362            }
363
364            ::fidl_next::Encode::encode(self.rtc, encoder_, rtc, ())?;
365
366            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rtc.as_mut_ptr()) };
367
368            Ok(())
369        }
370    }
371
372    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeviceSet2Request, ___E>
373        for &'a DeviceSet2Request
374    where
375        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
376    {
377        #[inline]
378        fn encode(
379            self,
380            encoder_: &mut ___E,
381            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSet2Request>,
382            _: (),
383        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
384            ::fidl_next::munge! {
385                let crate::wire::DeviceSet2Request {
386                    rtc,
387
388                } = out_;
389            }
390
391            ::fidl_next::Encode::encode(&self.rtc, encoder_, rtc, ())?;
392
393            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rtc.as_mut_ptr()) };
394
395            Ok(())
396        }
397    }
398
399    unsafe impl<___E>
400        ::fidl_next::EncodeOption<
401            ::fidl_next::wire::Box<'static, crate::wire::DeviceSet2Request>,
402            ___E,
403        > for DeviceSet2Request
404    where
405        ___E: ::fidl_next::Encoder + ?Sized,
406        DeviceSet2Request: ::fidl_next::Encode<crate::wire::DeviceSet2Request, ___E>,
407    {
408        #[inline]
409        fn encode_option(
410            this: ::core::option::Option<Self>,
411            encoder: &mut ___E,
412            out: &mut ::core::mem::MaybeUninit<
413                ::fidl_next::wire::Box<'static, crate::wire::DeviceSet2Request>,
414            >,
415            _: (),
416        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
417            if let Some(inner) = this {
418                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
419                ::fidl_next::wire::Box::encode_present(out);
420            } else {
421                ::fidl_next::wire::Box::encode_absent(out);
422            }
423
424            Ok(())
425        }
426    }
427
428    unsafe impl<'a, ___E>
429        ::fidl_next::EncodeOption<
430            ::fidl_next::wire::Box<'static, crate::wire::DeviceSet2Request>,
431            ___E,
432        > for &'a DeviceSet2Request
433    where
434        ___E: ::fidl_next::Encoder + ?Sized,
435        &'a DeviceSet2Request: ::fidl_next::Encode<crate::wire::DeviceSet2Request, ___E>,
436    {
437        #[inline]
438        fn encode_option(
439            this: ::core::option::Option<Self>,
440            encoder: &mut ___E,
441            out: &mut ::core::mem::MaybeUninit<
442                ::fidl_next::wire::Box<'static, crate::wire::DeviceSet2Request>,
443            >,
444            _: (),
445        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
446            if let Some(inner) = this {
447                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
448                ::fidl_next::wire::Box::encode_present(out);
449            } else {
450                ::fidl_next::wire::Box::encode_absent(out);
451            }
452
453            Ok(())
454        }
455    }
456
457    impl ::fidl_next::FromWire<crate::wire::DeviceSet2Request> for DeviceSet2Request {
458        #[inline]
459        fn from_wire(wire: crate::wire::DeviceSet2Request) -> Self {
460            Self { rtc: ::fidl_next::FromWire::from_wire(wire.rtc) }
461        }
462    }
463
464    impl ::fidl_next::FromWireRef<crate::wire::DeviceSet2Request> for DeviceSet2Request {
465        #[inline]
466        fn from_wire_ref(wire: &crate::wire::DeviceSet2Request) -> Self {
467            Self { rtc: ::fidl_next::FromWireRef::from_wire_ref(&wire.rtc) }
468        }
469    }
470
471    pub type DeviceSet2Response = ();
472}
473
474pub mod wire {
475
476    /// The wire type corresponding to [`Time`].
477    #[derive(Clone, Debug)]
478    #[repr(C)]
479    pub struct Time {
480        pub seconds: u8,
481
482        pub minutes: u8,
483
484        pub hours: u8,
485
486        pub day: u8,
487
488        pub month: u8,
489
490        pub year: ::fidl_next::wire::Uint16,
491    }
492
493    static_assertions::const_assert_eq!(std::mem::size_of::<Time>(), 8);
494    static_assertions::const_assert_eq!(std::mem::align_of::<Time>(), 2);
495
496    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, seconds), 0);
497
498    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, minutes), 1);
499
500    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, hours), 2);
501
502    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, day), 3);
503
504    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, month), 4);
505
506    static_assertions::const_assert_eq!(std::mem::offset_of!(Time, year), 6);
507
508    impl ::fidl_next::Constrained for Time {
509        type Constraint = ();
510
511        fn validate(
512            _: ::fidl_next::Slot<'_, Self>,
513            _: Self::Constraint,
514        ) -> Result<(), ::fidl_next::ValidationError> {
515            Ok(())
516        }
517    }
518
519    unsafe impl ::fidl_next::Wire for Time {
520        type Narrowed<'de> = Time;
521
522        #[inline]
523        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
524            ::fidl_next::munge! {
525                let Self {
526                    seconds,
527                    minutes,
528                    hours,
529                    day,
530                    month,
531                    year,
532
533                } = &mut *out_;
534            }
535
536            ::fidl_next::Wire::zero_padding(seconds);
537
538            ::fidl_next::Wire::zero_padding(minutes);
539
540            ::fidl_next::Wire::zero_padding(hours);
541
542            ::fidl_next::Wire::zero_padding(day);
543
544            ::fidl_next::Wire::zero_padding(month);
545
546            ::fidl_next::Wire::zero_padding(year);
547
548            unsafe {
549                out_.as_mut_ptr().cast::<u8>().add(5).write_bytes(0, 1);
550            }
551        }
552    }
553
554    unsafe impl<___D> ::fidl_next::Decode<___D> for Time
555    where
556        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
557    {
558        fn decode(
559            slot_: ::fidl_next::Slot<'_, Self>,
560            decoder_: &mut ___D,
561            _: (),
562        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
563            if slot_.as_bytes()[5..6] != [0u8; 1] {
564                return Err(::fidl_next::DecodeError::InvalidPadding);
565            }
566
567            ::fidl_next::munge! {
568                let Self {
569                    mut seconds,
570                    mut minutes,
571                    mut hours,
572                    mut day,
573                    mut month,
574                    mut year,
575
576                } = slot_;
577            }
578
579            let _field = seconds.as_mut();
580
581            ::fidl_next::Decode::decode(seconds.as_mut(), decoder_, ())?;
582
583            let _field = minutes.as_mut();
584
585            ::fidl_next::Decode::decode(minutes.as_mut(), decoder_, ())?;
586
587            let _field = hours.as_mut();
588
589            ::fidl_next::Decode::decode(hours.as_mut(), decoder_, ())?;
590
591            let _field = day.as_mut();
592
593            ::fidl_next::Decode::decode(day.as_mut(), decoder_, ())?;
594
595            let _field = month.as_mut();
596
597            ::fidl_next::Decode::decode(month.as_mut(), decoder_, ())?;
598
599            let _field = year.as_mut();
600
601            ::fidl_next::Decode::decode(year.as_mut(), decoder_, ())?;
602
603            Ok(())
604        }
605    }
606
607    impl ::fidl_next::IntoNatural for Time {
608        type Natural = crate::natural::Time;
609    }
610
611    /// The wire type corresponding to [`DeviceGetResponse`].
612    #[derive(Clone, Debug)]
613    #[repr(C)]
614    pub struct DeviceGetResponse {
615        pub rtc: crate::wire::Time,
616    }
617
618    static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetResponse>(), 8);
619    static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetResponse>(), 2);
620
621    static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceGetResponse, rtc), 0);
622
623    impl ::fidl_next::Constrained for DeviceGetResponse {
624        type Constraint = ();
625
626        fn validate(
627            _: ::fidl_next::Slot<'_, Self>,
628            _: Self::Constraint,
629        ) -> Result<(), ::fidl_next::ValidationError> {
630            Ok(())
631        }
632    }
633
634    unsafe impl ::fidl_next::Wire for DeviceGetResponse {
635        type Narrowed<'de> = DeviceGetResponse;
636
637        #[inline]
638        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
639            ::fidl_next::munge! {
640                let Self {
641                    rtc,
642
643                } = &mut *out_;
644            }
645
646            ::fidl_next::Wire::zero_padding(rtc);
647        }
648    }
649
650    unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceGetResponse
651    where
652        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
653    {
654        fn decode(
655            slot_: ::fidl_next::Slot<'_, Self>,
656            decoder_: &mut ___D,
657            _: (),
658        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
659            ::fidl_next::munge! {
660                let Self {
661                    mut rtc,
662
663                } = slot_;
664            }
665
666            let _field = rtc.as_mut();
667
668            ::fidl_next::Decode::decode(rtc.as_mut(), decoder_, ())?;
669
670            Ok(())
671        }
672    }
673
674    impl ::fidl_next::IntoNatural for DeviceGetResponse {
675        type Natural = crate::natural::DeviceGetResponse;
676    }
677
678    /// The wire type corresponding to [`DeviceSet2Request`].
679    #[derive(Clone, Debug)]
680    #[repr(C)]
681    pub struct DeviceSet2Request {
682        pub rtc: crate::wire::Time,
683    }
684
685    static_assertions::const_assert_eq!(std::mem::size_of::<DeviceSet2Request>(), 8);
686    static_assertions::const_assert_eq!(std::mem::align_of::<DeviceSet2Request>(), 2);
687
688    static_assertions::const_assert_eq!(std::mem::offset_of!(DeviceSet2Request, rtc), 0);
689
690    impl ::fidl_next::Constrained for DeviceSet2Request {
691        type Constraint = ();
692
693        fn validate(
694            _: ::fidl_next::Slot<'_, Self>,
695            _: Self::Constraint,
696        ) -> Result<(), ::fidl_next::ValidationError> {
697            Ok(())
698        }
699    }
700
701    unsafe impl ::fidl_next::Wire for DeviceSet2Request {
702        type Narrowed<'de> = DeviceSet2Request;
703
704        #[inline]
705        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
706            ::fidl_next::munge! {
707                let Self {
708                    rtc,
709
710                } = &mut *out_;
711            }
712
713            ::fidl_next::Wire::zero_padding(rtc);
714        }
715    }
716
717    unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceSet2Request
718    where
719        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
720    {
721        fn decode(
722            slot_: ::fidl_next::Slot<'_, Self>,
723            decoder_: &mut ___D,
724            _: (),
725        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
726            ::fidl_next::munge! {
727                let Self {
728                    mut rtc,
729
730                } = slot_;
731            }
732
733            let _field = rtc.as_mut();
734
735            ::fidl_next::Decode::decode(rtc.as_mut(), decoder_, ())?;
736
737            Ok(())
738        }
739    }
740
741    impl ::fidl_next::IntoNatural for DeviceSet2Request {
742        type Natural = crate::natural::DeviceSet2Request;
743    }
744
745    /// The wire type corresponding to [`DeviceSet2Response`].
746    pub type DeviceSet2Response = ::fidl_next::wire::Unit;
747}
748
749pub mod wire_optional {}
750
751pub mod generic {
752
753    /// The generic type corresponding to [`Time`].
754    pub struct Time<T0, T1, T2, T3, T4, T5> {
755        pub seconds: T0,
756
757        pub minutes: T1,
758
759        pub hours: T2,
760
761        pub day: T3,
762
763        pub month: T4,
764
765        pub year: T5,
766    }
767
768    unsafe impl<___E, T0, T1, T2, T3, T4, T5> ::fidl_next::Encode<crate::wire::Time, ___E>
769        for Time<T0, T1, T2, T3, T4, T5>
770    where
771        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
772        T0: ::fidl_next::Encode<u8, ___E>,
773        T1: ::fidl_next::Encode<u8, ___E>,
774        T2: ::fidl_next::Encode<u8, ___E>,
775        T3: ::fidl_next::Encode<u8, ___E>,
776        T4: ::fidl_next::Encode<u8, ___E>,
777        T5: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
778    {
779        #[inline]
780        fn encode(
781            self,
782            encoder_: &mut ___E,
783            out_: &mut ::core::mem::MaybeUninit<crate::wire::Time>,
784            _: (),
785        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
786            ::fidl_next::munge! {
787                let crate::wire::Time {
788                    seconds,
789                    minutes,
790                    hours,
791                    day,
792                    month,
793                    year,
794
795                } = out_;
796            }
797
798            ::fidl_next::Encode::encode(self.seconds, encoder_, seconds, ())?;
799
800            ::fidl_next::Encode::encode(self.minutes, encoder_, minutes, ())?;
801
802            ::fidl_next::Encode::encode(self.hours, encoder_, hours, ())?;
803
804            ::fidl_next::Encode::encode(self.day, encoder_, day, ())?;
805
806            ::fidl_next::Encode::encode(self.month, encoder_, month, ())?;
807
808            ::fidl_next::Encode::encode(self.year, encoder_, year, ())?;
809
810            Ok(())
811        }
812    }
813
814    /// The generic type corresponding to [`DeviceGetResponse`].
815    pub struct DeviceGetResponse<T0> {
816        pub rtc: T0,
817    }
818
819    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetResponse, ___E>
820        for DeviceGetResponse<T0>
821    where
822        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
823        T0: ::fidl_next::Encode<crate::wire::Time, ___E>,
824    {
825        #[inline]
826        fn encode(
827            self,
828            encoder_: &mut ___E,
829            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetResponse>,
830            _: (),
831        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
832            ::fidl_next::munge! {
833                let crate::wire::DeviceGetResponse {
834                    rtc,
835
836                } = out_;
837            }
838
839            ::fidl_next::Encode::encode(self.rtc, encoder_, rtc, ())?;
840
841            Ok(())
842        }
843    }
844
845    /// The generic type corresponding to [`DeviceSet2Request`].
846    pub struct DeviceSet2Request<T0> {
847        pub rtc: T0,
848    }
849
850    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceSet2Request, ___E>
851        for DeviceSet2Request<T0>
852    where
853        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
854        T0: ::fidl_next::Encode<crate::wire::Time, ___E>,
855    {
856        #[inline]
857        fn encode(
858            self,
859            encoder_: &mut ___E,
860            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceSet2Request>,
861            _: (),
862        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
863            ::fidl_next::munge! {
864                let crate::wire::DeviceSet2Request {
865                    rtc,
866
867                } = out_;
868            }
869
870            ::fidl_next::Encode::encode(self.rtc, encoder_, rtc, ())?;
871
872            Ok(())
873        }
874    }
875
876    /// The generic type corresponding to [`DeviceSet2Response`].
877    pub type DeviceSet2Response = ();
878}
879
880pub use self::natural::*;
881
882/// The type corresponding to the Device protocol.
883#[derive(PartialEq, Debug)]
884pub struct Device;
885
886impl ::fidl_next::Discoverable for Device {
887    const PROTOCOL_NAME: &'static str = "fuchsia.hardware.rtc.Device";
888}
889
890#[cfg(target_os = "fuchsia")]
891impl ::fidl_next::HasTransport for Device {
892    type Transport = ::fidl_next::fuchsia::zx::Channel;
893}
894
895pub mod device {
896    pub mod prelude {
897        pub use crate::{
898            Device, DeviceClientHandler, DeviceLocalClientHandler, DeviceLocalServerHandler,
899            DeviceServerHandler, device,
900        };
901
902        pub use crate::natural::DeviceSet2Request;
903
904        pub use crate::natural::DeviceGetResponse;
905
906        pub use crate::natural::DeviceSet2Response;
907    }
908
909    pub struct Get;
910
911    impl ::fidl_next::Method for Get {
912        const ORDINAL: u64 = 2881649623829671924;
913        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
914            ::fidl_next::protocol::Flexibility::Flexible;
915
916        type Protocol = crate::Device;
917
918        type Request = ::fidl_next::wire::EmptyMessageBody;
919    }
920
921    impl ::fidl_next::TwoWayMethod for Get {
922        type Response = ::fidl_next::wire::Result<
923            'static,
924            crate::wire::DeviceGetResponse,
925            ::fidl_next::wire::fuchsia::Status,
926        >;
927    }
928
929    impl<___R> ::fidl_next::Respond<___R> for Get {
930        type Output = ::core::result::Result<
931            crate::generic::DeviceGetResponse<___R>,
932            ::fidl_next::never::Never,
933        >;
934
935        fn respond(response: ___R) -> Self::Output {
936            ::core::result::Result::Ok(crate::generic::DeviceGetResponse { rtc: response })
937        }
938    }
939
940    impl<___R> ::fidl_next::RespondErr<___R> for Get {
941        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
942
943        fn respond_err(response: ___R) -> Self::Output {
944            ::core::result::Result::Err(response)
945        }
946    }
947
948    pub struct Set2;
949
950    impl ::fidl_next::Method for Set2 {
951        const ORDINAL: u64 = 1614978035535395557;
952        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
953            ::fidl_next::protocol::Flexibility::Flexible;
954
955        type Protocol = crate::Device;
956
957        type Request = crate::wire::DeviceSet2Request;
958    }
959
960    impl ::fidl_next::TwoWayMethod for Set2 {
961        type Response = ::fidl_next::wire::Result<
962            'static,
963            crate::wire::DeviceSet2Response,
964            ::fidl_next::wire::fuchsia::Status,
965        >;
966    }
967
968    impl<___R> ::fidl_next::Respond<___R> for Set2 {
969        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
970
971        fn respond(response: ___R) -> Self::Output {
972            ::core::result::Result::Ok(response)
973        }
974    }
975
976    impl<___R> ::fidl_next::RespondErr<___R> for Set2 {
977        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
978
979        fn respond_err(response: ___R) -> Self::Output {
980            ::core::result::Result::Err(response)
981        }
982    }
983
984    mod ___detail {
985        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Device
986        where
987            ___T: ::fidl_next::Transport,
988        {
989            type Client = DeviceClient<___T>;
990            type Server = DeviceServer<___T>;
991        }
992
993        /// The client for the `Device` protocol.
994        #[repr(transparent)]
995        pub struct DeviceClient<___T: ::fidl_next::Transport> {
996            #[allow(dead_code)]
997            client: ::fidl_next::protocol::Client<___T>,
998        }
999
1000        impl<___T> DeviceClient<___T>
1001        where
1002            ___T: ::fidl_next::Transport,
1003        {
1004            #[doc = " Get the current RTC time.\n If the driver detects that it does not have a valid time to report, then it will return an\n `ZX_ERR_INTERNAL` error.\n"]
1005            pub fn get(&self) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T> {
1006                ::fidl_next::TwoWayFuture::from_untyped(
1007                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
1008                        2881649623829671924,
1009                        <super::Get as ::fidl_next::Method>::FLEXIBILITY,
1010                        (),
1011                    ),
1012                )
1013            }
1014
1015            #[doc = " Set the RTC time.\n If the RTC time is not valid, the driver will return an `ZX_ERR_OUT_OF_RANGE` error.\n"]
1016            pub fn set2(
1017                &self,
1018
1019                rtc: impl ::fidl_next::Encode<
1020                    crate::wire::Time,
1021                    <___T as ::fidl_next::Transport>::SendBuffer,
1022                >,
1023            ) -> ::fidl_next::TwoWayFuture<'_, super::Set2, ___T>
1024            where
1025                <___T as ::fidl_next::Transport>::SendBuffer:
1026                    ::fidl_next::encoder::InternalHandleEncoder,
1027            {
1028                self.set2_with(crate::generic::DeviceSet2Request { rtc })
1029            }
1030
1031            #[doc = " Set the RTC time.\n If the RTC time is not valid, the driver will return an `ZX_ERR_OUT_OF_RANGE` error.\n"]
1032            pub fn set2_with<___R>(
1033                &self,
1034                request: ___R,
1035            ) -> ::fidl_next::TwoWayFuture<'_, super::Set2, ___T>
1036            where
1037                ___R: ::fidl_next::Encode<
1038                        crate::wire::DeviceSet2Request,
1039                        <___T as ::fidl_next::Transport>::SendBuffer,
1040                    >,
1041            {
1042                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
1043                    1614978035535395557,
1044                    <super::Set2 as ::fidl_next::Method>::FLEXIBILITY,
1045                    request,
1046                ))
1047            }
1048        }
1049
1050        /// The server for the `Device` protocol.
1051        #[repr(transparent)]
1052        pub struct DeviceServer<___T: ::fidl_next::Transport> {
1053            server: ::fidl_next::protocol::Server<___T>,
1054        }
1055
1056        impl<___T> DeviceServer<___T> where ___T: ::fidl_next::Transport {}
1057    }
1058}
1059
1060#[diagnostic::on_unimplemented(
1061    note = "If {Self} implements the non-local DeviceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
1062)]
1063
1064/// A client handler for the Device protocol.
1065///
1066/// See [`Device`] for more details.
1067pub trait DeviceLocalClientHandler<
1068    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1069    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1070>
1071{
1072    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
1073        ::core::future::ready(())
1074    }
1075}
1076
1077impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Device
1078where
1079    ___H: DeviceLocalClientHandler<___T>,
1080    ___T: ::fidl_next::Transport,
1081{
1082    async fn on_event(
1083        handler: &mut ___H,
1084        mut message: ::fidl_next::Message<___T>,
1085    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
1086        match *message.header().ordinal {
1087            ordinal => {
1088                handler.on_unknown_interaction(ordinal).await;
1089                if ::core::matches!(
1090                    message.header().flexibility(),
1091                    ::fidl_next::protocol::Flexibility::Strict
1092                ) {
1093                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1094                } else {
1095                    Ok(())
1096                }
1097            }
1098        }
1099    }
1100}
1101
1102#[diagnostic::on_unimplemented(
1103    note = "If {Self} implements the non-local DeviceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
1104)]
1105
1106/// A server handler for the Device protocol.
1107///
1108/// See [`Device`] for more details.
1109pub trait DeviceLocalServerHandler<
1110    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1111    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1112>
1113{
1114    #[doc = " Get the current RTC time.\n If the driver detects that it does not have a valid time to report, then it will return an\n `ZX_ERR_INTERNAL` error.\n"]
1115    fn get(
1116        &mut self,
1117
1118        responder: ::fidl_next::Responder<device::Get, ___T>,
1119    ) -> impl ::core::future::Future<Output = ()>;
1120
1121    #[doc = " Set the RTC time.\n If the RTC time is not valid, the driver will return an `ZX_ERR_OUT_OF_RANGE` error.\n"]
1122    fn set2(
1123        &mut self,
1124
1125        request: ::fidl_next::Request<device::Set2, ___T>,
1126
1127        responder: ::fidl_next::Responder<device::Set2, ___T>,
1128    ) -> impl ::core::future::Future<Output = ()>;
1129
1130    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
1131        ::core::future::ready(())
1132    }
1133}
1134
1135impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Device
1136where
1137    ___H: DeviceLocalServerHandler<___T>,
1138    ___T: ::fidl_next::Transport,
1139    for<'de> crate::wire::DeviceSet2Request: ::fidl_next::Decode<
1140            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
1141            Constraint = (),
1142        >,
1143{
1144    async fn on_one_way(
1145        handler: &mut ___H,
1146        mut message: ::fidl_next::Message<___T>,
1147    ) -> ::core::result::Result<
1148        (),
1149        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1150    > {
1151        match *message.header().ordinal {
1152            ordinal => {
1153                handler.on_unknown_interaction(ordinal).await;
1154                if ::core::matches!(
1155                    message.header().flexibility(),
1156                    ::fidl_next::protocol::Flexibility::Strict
1157                ) {
1158                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1159                } else {
1160                    Ok(())
1161                }
1162            }
1163        }
1164    }
1165
1166    async fn on_two_way(
1167        handler: &mut ___H,
1168        mut message: ::fidl_next::Message<___T>,
1169        responder: ::fidl_next::protocol::Responder<___T>,
1170    ) -> ::core::result::Result<
1171        (),
1172        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1173    > {
1174        match *message.header().ordinal {
1175            2881649623829671924 => {
1176                let responder = ::fidl_next::Responder::from_untyped(responder);
1177
1178                handler.get(responder).await;
1179                Ok(())
1180            }
1181
1182            1614978035535395557 => {
1183                let responder = ::fidl_next::Responder::from_untyped(responder);
1184
1185                match ::fidl_next::AsDecoderExt::into_decoded(message) {
1186                    Ok(decoded) => {
1187                        handler.set2(::fidl_next::Request::from_decoded(decoded), responder).await;
1188                        Ok(())
1189                    }
1190                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1191                        ordinal: 1614978035535395557,
1192                        error,
1193                    }),
1194                }
1195            }
1196
1197            ordinal => {
1198                handler.on_unknown_interaction(ordinal).await;
1199                if ::core::matches!(
1200                    message.header().flexibility(),
1201                    ::fidl_next::protocol::Flexibility::Strict
1202                ) {
1203                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1204                } else {
1205                    responder
1206                        .respond_framework_error(
1207                            ordinal,
1208                            ::fidl_next::FrameworkError::UnknownMethod,
1209                        )
1210                        .expect("encoding a framework error should never fail")
1211                        .await?;
1212                    Ok(())
1213                }
1214            }
1215        }
1216    }
1217}
1218
1219/// A client handler for the Device protocol.
1220///
1221/// See [`Device`] for more details.
1222pub trait DeviceClientHandler<
1223    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1224    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1225>
1226{
1227    fn on_unknown_interaction(
1228        &mut self,
1229        ordinal: u64,
1230    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1231        ::core::future::ready(())
1232    }
1233}
1234
1235impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Device
1236where
1237    ___H: DeviceClientHandler<___T> + ::core::marker::Send,
1238    ___T: ::fidl_next::Transport,
1239{
1240    async fn on_event(
1241        handler: &mut ___H,
1242        mut message: ::fidl_next::Message<___T>,
1243    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
1244        match *message.header().ordinal {
1245            ordinal => {
1246                handler.on_unknown_interaction(ordinal).await;
1247                if ::core::matches!(
1248                    message.header().flexibility(),
1249                    ::fidl_next::protocol::Flexibility::Strict
1250                ) {
1251                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1252                } else {
1253                    Ok(())
1254                }
1255            }
1256        }
1257    }
1258}
1259
1260/// A server handler for the Device protocol.
1261///
1262/// See [`Device`] for more details.
1263pub trait DeviceServerHandler<
1264    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1265    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1266>
1267{
1268    #[doc = " Get the current RTC time.\n If the driver detects that it does not have a valid time to report, then it will return an\n `ZX_ERR_INTERNAL` error.\n"]
1269    fn get(
1270        &mut self,
1271
1272        responder: ::fidl_next::Responder<device::Get, ___T>,
1273    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1274
1275    #[doc = " Set the RTC time.\n If the RTC time is not valid, the driver will return an `ZX_ERR_OUT_OF_RANGE` error.\n"]
1276    fn set2(
1277        &mut self,
1278
1279        request: ::fidl_next::Request<device::Set2, ___T>,
1280
1281        responder: ::fidl_next::Responder<device::Set2, ___T>,
1282    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1283
1284    fn on_unknown_interaction(
1285        &mut self,
1286        ordinal: u64,
1287    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1288        ::core::future::ready(())
1289    }
1290}
1291
1292impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Device
1293where
1294    ___H: DeviceServerHandler<___T> + ::core::marker::Send,
1295    ___T: ::fidl_next::Transport,
1296    for<'de> crate::wire::DeviceSet2Request: ::fidl_next::Decode<
1297            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
1298            Constraint = (),
1299        >,
1300{
1301    async fn on_one_way(
1302        handler: &mut ___H,
1303        mut message: ::fidl_next::Message<___T>,
1304    ) -> ::core::result::Result<
1305        (),
1306        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1307    > {
1308        match *message.header().ordinal {
1309            ordinal => {
1310                handler.on_unknown_interaction(ordinal).await;
1311                if ::core::matches!(
1312                    message.header().flexibility(),
1313                    ::fidl_next::protocol::Flexibility::Strict
1314                ) {
1315                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1316                } else {
1317                    Ok(())
1318                }
1319            }
1320        }
1321    }
1322
1323    async fn on_two_way(
1324        handler: &mut ___H,
1325        mut message: ::fidl_next::Message<___T>,
1326        responder: ::fidl_next::protocol::Responder<___T>,
1327    ) -> ::core::result::Result<
1328        (),
1329        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1330    > {
1331        match *message.header().ordinal {
1332            2881649623829671924 => {
1333                let responder = ::fidl_next::Responder::from_untyped(responder);
1334
1335                handler.get(responder).await;
1336                Ok(())
1337            }
1338
1339            1614978035535395557 => {
1340                let responder = ::fidl_next::Responder::from_untyped(responder);
1341
1342                match ::fidl_next::AsDecoderExt::into_decoded(message) {
1343                    Ok(decoded) => {
1344                        handler.set2(::fidl_next::Request::from_decoded(decoded), responder).await;
1345                        Ok(())
1346                    }
1347                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1348                        ordinal: 1614978035535395557,
1349                        error,
1350                    }),
1351                }
1352            }
1353
1354            ordinal => {
1355                handler.on_unknown_interaction(ordinal).await;
1356                if ::core::matches!(
1357                    message.header().flexibility(),
1358                    ::fidl_next::protocol::Flexibility::Strict
1359                ) {
1360                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1361                } else {
1362                    responder
1363                        .respond_framework_error(
1364                            ordinal,
1365                            ::fidl_next::FrameworkError::UnknownMethod,
1366                        )
1367                        .expect("encoding a framework error should never fail")
1368                        .await?;
1369                    Ok(())
1370                }
1371            }
1372        }
1373    }
1374}
1375
1376impl<___T> DeviceClientHandler<___T> for ::fidl_next::IgnoreEvents
1377where
1378    ___T: ::fidl_next::Transport,
1379{
1380    async fn on_unknown_interaction(&mut self, _: u64) {}
1381}
1382
1383impl<___H, ___T> DeviceLocalClientHandler<___T> for ::fidl_next::Local<___H>
1384where
1385    ___H: DeviceClientHandler<___T>,
1386    ___T: ::fidl_next::Transport,
1387{
1388    async fn on_unknown_interaction(&mut self, ordinal: u64) {
1389        ___H::on_unknown_interaction(&mut self.0, ordinal).await
1390    }
1391}
1392
1393impl<___H, ___T> DeviceLocalServerHandler<___T> for ::fidl_next::Local<___H>
1394where
1395    ___H: DeviceServerHandler<___T>,
1396    ___T: ::fidl_next::Transport,
1397{
1398    async fn get(&mut self, responder: ::fidl_next::Responder<device::Get, ___T>) {
1399        ___H::get(&mut self.0, responder).await
1400    }
1401
1402    async fn set2(
1403        &mut self,
1404
1405        request: ::fidl_next::Request<device::Set2, ___T>,
1406
1407        responder: ::fidl_next::Responder<device::Set2, ___T>,
1408    ) {
1409        ___H::set2(&mut self.0, request, responder).await
1410    }
1411
1412    async fn on_unknown_interaction(&mut self, ordinal: u64) {
1413        ___H::on_unknown_interaction(&mut self.0, ordinal).await
1414    }
1415}
fidl_next_common_fuchsia_hardware_rtc/fidl_next_common_fuchsia_hardware_rtc.rs

fidl_next_common_fuchsia_hardware_rtc/
fidl_next_common_fuchsia_hardware_rtc.rs
