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

fidl_next_common_fuchsia_hardware_powerdomain/
fidl_next_common_fuchsia_hardware_powerdomain.rs
