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 take_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
734            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
735        }
736
737        pub fn node_id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
738            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
739        }
740
741        pub fn take_node_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
742            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
743        }
744
745        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
746            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
747        }
748
749        pub fn take_name(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
750            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
751        }
752    }
753
754    impl<'de> ::core::fmt::Debug for PowerDomain<'de> {
755        fn fmt(
756            &self,
757            f: &mut ::core::fmt::Formatter<'_>,
758        ) -> ::core::result::Result<(), ::core::fmt::Error> {
759            f.debug_struct("PowerDomain")
760                .field("id", &self.id())
761                .field("node_id", &self.node_id())
762                .field("name", &self.name())
763                .finish()
764        }
765    }
766
767    impl<'de> ::fidl_next::IntoNatural for PowerDomain<'de> {
768        type Natural = crate::natural::PowerDomain;
769    }
770
771    /// The wire type corresponding to [`DomainMetadata`].
772    #[repr(C)]
773    pub struct DomainMetadata<'de> {
774        pub(crate) table: ::fidl_next::wire::Table<'de>,
775    }
776
777    impl<'de> Drop for DomainMetadata<'de> {
778        fn drop(&mut self) {
779            let _ = self.table.get(1)
780                .map(|envelope| unsafe {
781                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::PowerDomain<'de>>>()
782                });
783        }
784    }
785
786    impl ::fidl_next::Constrained for DomainMetadata<'_> {
787        type Constraint = ();
788
789        fn validate(
790            _: ::fidl_next::Slot<'_, Self>,
791            _: Self::Constraint,
792        ) -> Result<(), ::fidl_next::ValidationError> {
793            Ok(())
794        }
795    }
796
797    unsafe impl ::fidl_next::Wire for DomainMetadata<'static> {
798        type Narrowed<'de> = DomainMetadata<'de>;
799
800        #[inline]
801        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
802            ::fidl_next::munge!(let Self { table } = out);
803            ::fidl_next::wire::Table::zero_padding(table);
804        }
805    }
806
807    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DomainMetadata<'de>
808    where
809        ___D: ::fidl_next::Decoder<'de> + ?Sized,
810    {
811        fn decode(
812            slot: ::fidl_next::Slot<'_, Self>,
813            decoder: &mut ___D,
814            _: (),
815        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
816            ::fidl_next::munge!(let Self { table } = slot);
817
818            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
819                match ordinal {
820                    0 => unsafe { ::core::hint::unreachable_unchecked() },
821
822                    1 => {
823                        ::fidl_next::wire::Envelope::decode_as::<
824                            ___D,
825                            ::fidl_next::wire::Vector<'de, crate::wire::PowerDomain<'de>>,
826                        >(slot.as_mut(), decoder, (4294967295, ()))?;
827
828                        Ok(())
829                    }
830
831                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
832                }
833            })
834        }
835    }
836
837    impl<'de> DomainMetadata<'de> {
838        pub fn domains(
839            &self,
840        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::PowerDomain<'de>>>
841        {
842            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
843        }
844
845        pub fn take_domains(
846            &mut self,
847        ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::PowerDomain<'de>>>
848        {
849            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
850        }
851    }
852
853    impl<'de> ::core::fmt::Debug for DomainMetadata<'de> {
854        fn fmt(
855            &self,
856            f: &mut ::core::fmt::Formatter<'_>,
857        ) -> ::core::result::Result<(), ::core::fmt::Error> {
858            f.debug_struct("DomainMetadata").field("domains", &self.domains()).finish()
859        }
860    }
861
862    impl<'de> ::fidl_next::IntoNatural for DomainMetadata<'de> {
863        type Natural = crate::natural::DomainMetadata;
864    }
865}
866
867pub mod wire_optional {}
868
869pub mod generic {
870
871    /// The generic type corresponding to [`DomainEnableResponse`].
872    pub type DomainEnableResponse = ();
873
874    /// The generic type corresponding to [`DomainDisableResponse`].
875    pub type DomainDisableResponse = ();
876
877    /// The generic type corresponding to [`DomainIsEnabledResponse`].
878    pub struct DomainIsEnabledResponse<T0> {
879        pub enabled: T0,
880    }
881
882    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DomainIsEnabledResponse, ___E>
883        for DomainIsEnabledResponse<T0>
884    where
885        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
886        T0: ::fidl_next::Encode<bool, ___E>,
887    {
888        #[inline]
889        fn encode(
890            self,
891            encoder_: &mut ___E,
892            out_: &mut ::core::mem::MaybeUninit<crate::wire::DomainIsEnabledResponse>,
893            _: (),
894        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
895            ::fidl_next::munge! {
896                let crate::wire::DomainIsEnabledResponse {
897                    enabled,
898
899                } = out_;
900            }
901
902            ::fidl_next::Encode::encode(self.enabled, encoder_, enabled, ())?;
903
904            Ok(())
905        }
906    }
907}
908
909pub use self::natural::*;
910
911/// The type corresponding to the Domain protocol.
912#[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"]
913#[derive(PartialEq, Debug)]
914pub struct Domain;
915
916#[cfg(target_os = "fuchsia")]
917impl ::fidl_next::HasTransport for Domain {
918    type Transport = ::fidl_next::fuchsia::zx::Channel;
919}
920
921pub mod domain {
922    pub mod prelude {
923        pub use crate::{
924            Domain, DomainClientHandler, DomainLocalClientHandler, DomainLocalServerHandler,
925            DomainServerHandler, domain,
926        };
927
928        pub use crate::natural::DomainDisableResponse;
929
930        pub use crate::natural::DomainEnableResponse;
931
932        pub use crate::natural::DomainIsEnabledResponse;
933    }
934
935    pub struct Enable;
936
937    impl ::fidl_next::Method for Enable {
938        const ORDINAL: u64 = 2070181937608286071;
939        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
940            ::fidl_next::protocol::Flexibility::Flexible;
941
942        type Protocol = crate::Domain;
943
944        type Request = ::fidl_next::wire::EmptyMessageBody;
945    }
946
947    impl ::fidl_next::TwoWayMethod for Enable {
948        type Response = ::fidl_next::wire::Result<
949            'static,
950            crate::wire::DomainEnableResponse,
951            ::fidl_next::wire::fuchsia::Status,
952        >;
953    }
954
955    impl<___R> ::fidl_next::Respond<___R> for Enable {
956        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
957
958        fn respond(response: ___R) -> Self::Output {
959            ::core::result::Result::Ok(response)
960        }
961    }
962
963    impl<___R> ::fidl_next::RespondErr<___R> for Enable {
964        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
965
966        fn respond_err(response: ___R) -> Self::Output {
967            ::core::result::Result::Err(response)
968        }
969    }
970
971    pub struct Disable;
972
973    impl ::fidl_next::Method for Disable {
974        const ORDINAL: u64 = 764136726546827899;
975        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
976            ::fidl_next::protocol::Flexibility::Flexible;
977
978        type Protocol = crate::Domain;
979
980        type Request = ::fidl_next::wire::EmptyMessageBody;
981    }
982
983    impl ::fidl_next::TwoWayMethod for Disable {
984        type Response = ::fidl_next::wire::Result<
985            'static,
986            crate::wire::DomainDisableResponse,
987            ::fidl_next::wire::fuchsia::Status,
988        >;
989    }
990
991    impl<___R> ::fidl_next::Respond<___R> for Disable {
992        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
993
994        fn respond(response: ___R) -> Self::Output {
995            ::core::result::Result::Ok(response)
996        }
997    }
998
999    impl<___R> ::fidl_next::RespondErr<___R> for Disable {
1000        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
1001
1002        fn respond_err(response: ___R) -> Self::Output {
1003            ::core::result::Result::Err(response)
1004        }
1005    }
1006
1007    pub struct IsEnabled;
1008
1009    impl ::fidl_next::Method for IsEnabled {
1010        const ORDINAL: u64 = 6531400635744256917;
1011        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
1012            ::fidl_next::protocol::Flexibility::Flexible;
1013
1014        type Protocol = crate::Domain;
1015
1016        type Request = ::fidl_next::wire::EmptyMessageBody;
1017    }
1018
1019    impl ::fidl_next::TwoWayMethod for IsEnabled {
1020        type Response = ::fidl_next::wire::Result<
1021            'static,
1022            crate::wire::DomainIsEnabledResponse,
1023            ::fidl_next::wire::fuchsia::Status,
1024        >;
1025    }
1026
1027    impl<___R> ::fidl_next::Respond<___R> for IsEnabled {
1028        type Output = ::core::result::Result<
1029            crate::generic::DomainIsEnabledResponse<___R>,
1030            ::fidl_next::never::Never,
1031        >;
1032
1033        fn respond(response: ___R) -> Self::Output {
1034            ::core::result::Result::Ok(crate::generic::DomainIsEnabledResponse {
1035                enabled: response,
1036            })
1037        }
1038    }
1039
1040    impl<___R> ::fidl_next::RespondErr<___R> for IsEnabled {
1041        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
1042
1043        fn respond_err(response: ___R) -> Self::Output {
1044            ::core::result::Result::Err(response)
1045        }
1046    }
1047
1048    mod ___detail {
1049        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Domain
1050        where
1051            ___T: ::fidl_next::Transport,
1052        {
1053            type Client = DomainClient<___T>;
1054            type Server = DomainServer<___T>;
1055        }
1056
1057        /// The client for the `Domain` protocol.
1058        #[repr(transparent)]
1059        pub struct DomainClient<___T: ::fidl_next::Transport> {
1060            #[allow(dead_code)]
1061            client: ::fidl_next::protocol::Client<___T>,
1062        }
1063
1064        impl<___T> DomainClient<___T>
1065        where
1066            ___T: ::fidl_next::Transport,
1067        {
1068            #[doc = " Enable the power domain.\n"]
1069            pub fn enable(&self) -> ::fidl_next::TwoWayFuture<'_, super::Enable, ___T> {
1070                ::fidl_next::TwoWayFuture::from_untyped(
1071                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
1072                        2070181937608286071,
1073                        <super::Enable as ::fidl_next::Method>::FLEXIBILITY,
1074                        (),
1075                    ),
1076                )
1077            }
1078
1079            #[doc = " Disable the power domain.\n"]
1080            pub fn disable(&self) -> ::fidl_next::TwoWayFuture<'_, super::Disable, ___T> {
1081                ::fidl_next::TwoWayFuture::from_untyped(
1082                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
1083                        764136726546827899,
1084                        <super::Disable as ::fidl_next::Method>::FLEXIBILITY,
1085                        (),
1086                    ),
1087                )
1088            }
1089
1090            #[doc = " Returns `true` if the power domain is enabled.\n"]
1091            pub fn is_enabled(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsEnabled, ___T> {
1092                ::fidl_next::TwoWayFuture::from_untyped(
1093                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
1094                        6531400635744256917,
1095                        <super::IsEnabled as ::fidl_next::Method>::FLEXIBILITY,
1096                        (),
1097                    ),
1098                )
1099            }
1100        }
1101
1102        /// The server for the `Domain` protocol.
1103        #[repr(transparent)]
1104        pub struct DomainServer<___T: ::fidl_next::Transport> {
1105            server: ::fidl_next::protocol::Server<___T>,
1106        }
1107
1108        impl<___T> DomainServer<___T> where ___T: ::fidl_next::Transport {}
1109    }
1110}
1111
1112#[diagnostic::on_unimplemented(
1113    note = "If {Self} implements the non-local DomainClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
1114)]
1115
1116/// A client handler for the Domain protocol.
1117///
1118/// See [`Domain`] for more details.
1119pub trait DomainLocalClientHandler<
1120    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1121    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1122>
1123{
1124    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
1125        ::core::future::ready(())
1126    }
1127}
1128
1129impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Domain
1130where
1131    ___H: DomainLocalClientHandler<___T>,
1132    ___T: ::fidl_next::Transport,
1133{
1134    async fn on_event(
1135        handler: &mut ___H,
1136        mut message: ::fidl_next::Message<___T>,
1137    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
1138        match *message.header().ordinal {
1139            ordinal => {
1140                handler.on_unknown_interaction(ordinal).await;
1141                if ::core::matches!(
1142                    message.header().flexibility(),
1143                    ::fidl_next::protocol::Flexibility::Strict
1144                ) {
1145                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1146                } else {
1147                    Ok(())
1148                }
1149            }
1150        }
1151    }
1152}
1153
1154#[diagnostic::on_unimplemented(
1155    note = "If {Self} implements the non-local DomainServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
1156)]
1157
1158/// A server handler for the Domain protocol.
1159///
1160/// See [`Domain`] for more details.
1161pub trait DomainLocalServerHandler<
1162    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1163    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1164>
1165{
1166    #[doc = " Enable the power domain.\n"]
1167    fn enable(
1168        &mut self,
1169
1170        responder: ::fidl_next::Responder<domain::Enable, ___T>,
1171    ) -> impl ::core::future::Future<Output = ()>;
1172
1173    #[doc = " Disable the power domain.\n"]
1174    fn disable(
1175        &mut self,
1176
1177        responder: ::fidl_next::Responder<domain::Disable, ___T>,
1178    ) -> impl ::core::future::Future<Output = ()>;
1179
1180    #[doc = " Returns `true` if the power domain is enabled.\n"]
1181    fn is_enabled(
1182        &mut self,
1183
1184        responder: ::fidl_next::Responder<domain::IsEnabled, ___T>,
1185    ) -> impl ::core::future::Future<Output = ()>;
1186
1187    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
1188        ::core::future::ready(())
1189    }
1190}
1191
1192impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Domain
1193where
1194    ___H: DomainLocalServerHandler<___T>,
1195    ___T: ::fidl_next::Transport,
1196{
1197    async fn on_one_way(
1198        handler: &mut ___H,
1199        mut message: ::fidl_next::Message<___T>,
1200    ) -> ::core::result::Result<
1201        (),
1202        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1203    > {
1204        match *message.header().ordinal {
1205            ordinal => {
1206                handler.on_unknown_interaction(ordinal).await;
1207                if ::core::matches!(
1208                    message.header().flexibility(),
1209                    ::fidl_next::protocol::Flexibility::Strict
1210                ) {
1211                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1212                } else {
1213                    Ok(())
1214                }
1215            }
1216        }
1217    }
1218
1219    async fn on_two_way(
1220        handler: &mut ___H,
1221        mut message: ::fidl_next::Message<___T>,
1222        responder: ::fidl_next::protocol::Responder<___T>,
1223    ) -> ::core::result::Result<
1224        (),
1225        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1226    > {
1227        match *message.header().ordinal {
1228            2070181937608286071 => {
1229                let responder = ::fidl_next::Responder::from_untyped(responder);
1230
1231                handler.enable(responder).await;
1232                Ok(())
1233            }
1234
1235            764136726546827899 => {
1236                let responder = ::fidl_next::Responder::from_untyped(responder);
1237
1238                handler.disable(responder).await;
1239                Ok(())
1240            }
1241
1242            6531400635744256917 => {
1243                let responder = ::fidl_next::Responder::from_untyped(responder);
1244
1245                handler.is_enabled(responder).await;
1246                Ok(())
1247            }
1248
1249            ordinal => {
1250                handler.on_unknown_interaction(ordinal).await;
1251                if ::core::matches!(
1252                    message.header().flexibility(),
1253                    ::fidl_next::protocol::Flexibility::Strict
1254                ) {
1255                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1256                } else {
1257                    responder
1258                        .respond_framework_error(
1259                            ordinal,
1260                            ::fidl_next::FrameworkError::UnknownMethod,
1261                        )
1262                        .expect("encoding a framework error should never fail")
1263                        .await?;
1264                    Ok(())
1265                }
1266            }
1267        }
1268    }
1269}
1270
1271/// A client handler for the Domain protocol.
1272///
1273/// See [`Domain`] for more details.
1274pub trait DomainClientHandler<
1275    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1276    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1277>
1278{
1279    fn on_unknown_interaction(
1280        &mut self,
1281        ordinal: u64,
1282    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1283        ::core::future::ready(())
1284    }
1285}
1286
1287impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Domain
1288where
1289    ___H: DomainClientHandler<___T> + ::core::marker::Send,
1290    ___T: ::fidl_next::Transport,
1291{
1292    async fn on_event(
1293        handler: &mut ___H,
1294        mut message: ::fidl_next::Message<___T>,
1295    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
1296        match *message.header().ordinal {
1297            ordinal => {
1298                handler.on_unknown_interaction(ordinal).await;
1299                if ::core::matches!(
1300                    message.header().flexibility(),
1301                    ::fidl_next::protocol::Flexibility::Strict
1302                ) {
1303                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1304                } else {
1305                    Ok(())
1306                }
1307            }
1308        }
1309    }
1310}
1311
1312/// A server handler for the Domain protocol.
1313///
1314/// See [`Domain`] for more details.
1315pub trait DomainServerHandler<
1316    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1317    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1318>
1319{
1320    #[doc = " Enable the power domain.\n"]
1321    fn enable(
1322        &mut self,
1323
1324        responder: ::fidl_next::Responder<domain::Enable, ___T>,
1325    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1326
1327    #[doc = " Disable the power domain.\n"]
1328    fn disable(
1329        &mut self,
1330
1331        responder: ::fidl_next::Responder<domain::Disable, ___T>,
1332    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1333
1334    #[doc = " Returns `true` if the power domain is enabled.\n"]
1335    fn is_enabled(
1336        &mut self,
1337
1338        responder: ::fidl_next::Responder<domain::IsEnabled, ___T>,
1339    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1340
1341    fn on_unknown_interaction(
1342        &mut self,
1343        ordinal: u64,
1344    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1345        ::core::future::ready(())
1346    }
1347}
1348
1349impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Domain
1350where
1351    ___H: DomainServerHandler<___T> + ::core::marker::Send,
1352    ___T: ::fidl_next::Transport,
1353{
1354    async fn on_one_way(
1355        handler: &mut ___H,
1356        mut message: ::fidl_next::Message<___T>,
1357    ) -> ::core::result::Result<
1358        (),
1359        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1360    > {
1361        match *message.header().ordinal {
1362            ordinal => {
1363                handler.on_unknown_interaction(ordinal).await;
1364                if ::core::matches!(
1365                    message.header().flexibility(),
1366                    ::fidl_next::protocol::Flexibility::Strict
1367                ) {
1368                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1369                } else {
1370                    Ok(())
1371                }
1372            }
1373        }
1374    }
1375
1376    async fn on_two_way(
1377        handler: &mut ___H,
1378        mut message: ::fidl_next::Message<___T>,
1379        responder: ::fidl_next::protocol::Responder<___T>,
1380    ) -> ::core::result::Result<
1381        (),
1382        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1383    > {
1384        match *message.header().ordinal {
1385            2070181937608286071 => {
1386                let responder = ::fidl_next::Responder::from_untyped(responder);
1387
1388                handler.enable(responder).await;
1389                Ok(())
1390            }
1391
1392            764136726546827899 => {
1393                let responder = ::fidl_next::Responder::from_untyped(responder);
1394
1395                handler.disable(responder).await;
1396                Ok(())
1397            }
1398
1399            6531400635744256917 => {
1400                let responder = ::fidl_next::Responder::from_untyped(responder);
1401
1402                handler.is_enabled(responder).await;
1403                Ok(())
1404            }
1405
1406            ordinal => {
1407                handler.on_unknown_interaction(ordinal).await;
1408                if ::core::matches!(
1409                    message.header().flexibility(),
1410                    ::fidl_next::protocol::Flexibility::Strict
1411                ) {
1412                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1413                } else {
1414                    responder
1415                        .respond_framework_error(
1416                            ordinal,
1417                            ::fidl_next::FrameworkError::UnknownMethod,
1418                        )
1419                        .expect("encoding a framework error should never fail")
1420                        .await?;
1421                    Ok(())
1422                }
1423            }
1424        }
1425    }
1426}
1427
1428impl<___T> DomainClientHandler<___T> for ::fidl_next::IgnoreEvents
1429where
1430    ___T: ::fidl_next::Transport,
1431{
1432    async fn on_unknown_interaction(&mut self, _: u64) {}
1433}
1434
1435impl<___H, ___T> DomainLocalClientHandler<___T> for ::fidl_next::Local<___H>
1436where
1437    ___H: DomainClientHandler<___T>,
1438    ___T: ::fidl_next::Transport,
1439{
1440    async fn on_unknown_interaction(&mut self, ordinal: u64) {
1441        ___H::on_unknown_interaction(&mut self.0, ordinal).await
1442    }
1443}
1444
1445impl<___H, ___T> DomainLocalServerHandler<___T> for ::fidl_next::Local<___H>
1446where
1447    ___H: DomainServerHandler<___T>,
1448    ___T: ::fidl_next::Transport,
1449{
1450    async fn enable(&mut self, responder: ::fidl_next::Responder<domain::Enable, ___T>) {
1451        ___H::enable(&mut self.0, responder).await
1452    }
1453
1454    async fn disable(&mut self, responder: ::fidl_next::Responder<domain::Disable, ___T>) {
1455        ___H::disable(&mut self.0, responder).await
1456    }
1457
1458    async fn is_enabled(&mut self, responder: ::fidl_next::Responder<domain::IsEnabled, ___T>) {
1459        ___H::is_enabled(&mut self.0, responder).await
1460    }
1461
1462    async fn on_unknown_interaction(&mut self, ordinal: u64) {
1463        ___H::on_unknown_interaction(&mut self.0, ordinal).await
1464    }
1465}
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
