fidl_fuchsia_power_topology_test__common/
fidl_fuchsia_power_topology_test__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type DependencyType = fidl_fuchsia_power_broker__common::DependencyType;
12
13pub type ElementName = String;
14
15pub type PowerLevel = u8;
16
17pub const MAX_DEPENDENCIES: u16 = MAX_VALID_POWER_LEVELS as u16;
18
19pub const MAX_ELEMENTS: u16 = 256;
20
21pub const MAX_ELEMENT_NAME_LEN: u16 =
22    fidl_fuchsia_power_broker__common::MAX_ELEMENT_NAME_LEN as u16;
23
24pub const MAX_VALID_POWER_LEVELS: u16 =
25    fidl_fuchsia_power_broker__common::MAX_VALID_POWER_LEVELS as u16;
26
27/// Errors associated with TopologyControl.Create method.
28#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
29#[repr(u32)]
30pub enum CreateTopologyGraphError {
31    /// Indicates that the request failed due to an internal error.
32    Internal = 1,
33    /// Indicates that the element topology provided in Create command is
34    /// invalid.
35    InvalidTopology = 2,
36}
37
38impl CreateTopologyGraphError {
39    #[inline]
40    pub fn from_primitive(prim: u32) -> Option<Self> {
41        match prim {
42            1 => Some(Self::Internal),
43            2 => Some(Self::InvalidTopology),
44            _ => None,
45        }
46    }
47
48    #[inline]
49    pub const fn into_primitive(self) -> u32 {
50        self as u32
51    }
52}
53
54/// Errors associated with TopologyControl.AcquireLease and
55/// TopologyControl.DropLease methods.
56#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57#[repr(u32)]
58pub enum LeaseControlError {
59    /// Indicates that the request failed due to an internal error.
60    Internal = 1,
61    /// Indicates that an invalid power element name was provided in
62    /// AcquireLease or DropLease.
63    InvalidElement = 2,
64}
65
66impl LeaseControlError {
67    #[inline]
68    pub fn from_primitive(prim: u32) -> Option<Self> {
69        match prim {
70            1 => Some(Self::Internal),
71            2 => Some(Self::InvalidElement),
72            _ => None,
73        }
74    }
75
76    #[inline]
77    pub const fn into_primitive(self) -> u32 {
78        self as u32
79    }
80}
81
82/// Errors associated with TopologyControl.OpenStatusChannel method.
83#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
84#[repr(u32)]
85pub enum OpenStatusChannelError {
86    /// Indicates that the request failed due to an internal error.
87    Internal = 1,
88    /// Indicates that an invalid power element name was provided in
89    /// OpenStatusChannel
90    InvalidElement = 2,
91}
92
93impl OpenStatusChannelError {
94    #[inline]
95    pub fn from_primitive(prim: u32) -> Option<Self> {
96        match prim {
97            1 => Some(Self::Internal),
98            2 => Some(Self::InvalidElement),
99            _ => None,
100        }
101    }
102
103    #[inline]
104    pub const fn into_primitive(self) -> u32 {
105        self as u32
106    }
107}
108
109/// Errors associated with SystemActivityControl methods.
110#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
111#[repr(u32)]
112pub enum SystemActivityControlError {
113    /// Indicates that the request failed due to an internal error.
114    Internal = 1,
115}
116
117impl SystemActivityControlError {
118    #[inline]
119    pub fn from_primitive(prim: u32) -> Option<Self> {
120        match prim {
121            1 => Some(Self::Internal),
122            _ => None,
123        }
124    }
125
126    #[inline]
127    pub const fn into_primitive(self) -> u32 {
128        self as u32
129    }
130}
131
132/// Passed to TopologyControl.Create to construct power topology.
133#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
134pub struct Element {
135    pub element_name: String,
136    pub initial_current_level: u8,
137    pub valid_levels: Vec<u8>,
138    pub dependencies: Vec<LevelDependency>,
139}
140
141impl fidl::Persistable for Element {}
142
143/// Power Dependency information in Element. Used by a client to construct power topology.
144#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
145pub struct LevelDependency {
146    pub dependency_type: fidl_fuchsia_power_broker__common::DependencyType,
147    pub dependent_level: u8,
148    pub requires_element: String,
149    pub requires_level: u8,
150}
151
152impl fidl::Persistable for LevelDependency {}
153
154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155pub struct TopologyControlAcquireLeaseRequest {
156    pub element_name: String,
157    /// Power level of this element to be raised to.
158    pub level: u8,
159}
160
161impl fidl::Persistable for TopologyControlAcquireLeaseRequest {}
162
163#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
164pub struct TopologyControlCreateRequest {
165    /// List of elements to create.
166    pub elements: Vec<Element>,
167}
168
169impl fidl::Persistable for TopologyControlCreateRequest {}
170
171#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
172pub struct TopologyControlDropLeaseRequest {
173    pub element_name: String,
174}
175
176impl fidl::Persistable for TopologyControlDropLeaseRequest {}
177
178mod internal {
179    use super::*;
180    unsafe impl fidl::encoding::TypeMarker for CreateTopologyGraphError {
181        type Owned = Self;
182
183        #[inline(always)]
184        fn inline_align(_context: fidl::encoding::Context) -> usize {
185            std::mem::align_of::<u32>()
186        }
187
188        #[inline(always)]
189        fn inline_size(_context: fidl::encoding::Context) -> usize {
190            std::mem::size_of::<u32>()
191        }
192
193        #[inline(always)]
194        fn encode_is_copy() -> bool {
195            true
196        }
197
198        #[inline(always)]
199        fn decode_is_copy() -> bool {
200            false
201        }
202    }
203
204    impl fidl::encoding::ValueTypeMarker for CreateTopologyGraphError {
205        type Borrowed<'a> = Self;
206        #[inline(always)]
207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
208            *value
209        }
210    }
211
212    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
213        for CreateTopologyGraphError
214    {
215        #[inline]
216        unsafe fn encode(
217            self,
218            encoder: &mut fidl::encoding::Encoder<'_, D>,
219            offset: usize,
220            _depth: fidl::encoding::Depth,
221        ) -> fidl::Result<()> {
222            encoder.debug_check_bounds::<Self>(offset);
223            encoder.write_num(self.into_primitive(), offset);
224            Ok(())
225        }
226    }
227
228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
229        for CreateTopologyGraphError
230    {
231        #[inline(always)]
232        fn new_empty() -> Self {
233            Self::Internal
234        }
235
236        #[inline]
237        unsafe fn decode(
238            &mut self,
239            decoder: &mut fidl::encoding::Decoder<'_, D>,
240            offset: usize,
241            _depth: fidl::encoding::Depth,
242        ) -> fidl::Result<()> {
243            decoder.debug_check_bounds::<Self>(offset);
244            let prim = decoder.read_num::<u32>(offset);
245
246            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
247            Ok(())
248        }
249    }
250    unsafe impl fidl::encoding::TypeMarker for LeaseControlError {
251        type Owned = Self;
252
253        #[inline(always)]
254        fn inline_align(_context: fidl::encoding::Context) -> usize {
255            std::mem::align_of::<u32>()
256        }
257
258        #[inline(always)]
259        fn inline_size(_context: fidl::encoding::Context) -> usize {
260            std::mem::size_of::<u32>()
261        }
262
263        #[inline(always)]
264        fn encode_is_copy() -> bool {
265            true
266        }
267
268        #[inline(always)]
269        fn decode_is_copy() -> bool {
270            false
271        }
272    }
273
274    impl fidl::encoding::ValueTypeMarker for LeaseControlError {
275        type Borrowed<'a> = Self;
276        #[inline(always)]
277        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
278            *value
279        }
280    }
281
282    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
283        for LeaseControlError
284    {
285        #[inline]
286        unsafe fn encode(
287            self,
288            encoder: &mut fidl::encoding::Encoder<'_, D>,
289            offset: usize,
290            _depth: fidl::encoding::Depth,
291        ) -> fidl::Result<()> {
292            encoder.debug_check_bounds::<Self>(offset);
293            encoder.write_num(self.into_primitive(), offset);
294            Ok(())
295        }
296    }
297
298    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaseControlError {
299        #[inline(always)]
300        fn new_empty() -> Self {
301            Self::Internal
302        }
303
304        #[inline]
305        unsafe fn decode(
306            &mut self,
307            decoder: &mut fidl::encoding::Decoder<'_, D>,
308            offset: usize,
309            _depth: fidl::encoding::Depth,
310        ) -> fidl::Result<()> {
311            decoder.debug_check_bounds::<Self>(offset);
312            let prim = decoder.read_num::<u32>(offset);
313
314            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
315            Ok(())
316        }
317    }
318    unsafe impl fidl::encoding::TypeMarker for OpenStatusChannelError {
319        type Owned = Self;
320
321        #[inline(always)]
322        fn inline_align(_context: fidl::encoding::Context) -> usize {
323            std::mem::align_of::<u32>()
324        }
325
326        #[inline(always)]
327        fn inline_size(_context: fidl::encoding::Context) -> usize {
328            std::mem::size_of::<u32>()
329        }
330
331        #[inline(always)]
332        fn encode_is_copy() -> bool {
333            true
334        }
335
336        #[inline(always)]
337        fn decode_is_copy() -> bool {
338            false
339        }
340    }
341
342    impl fidl::encoding::ValueTypeMarker for OpenStatusChannelError {
343        type Borrowed<'a> = Self;
344        #[inline(always)]
345        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
346            *value
347        }
348    }
349
350    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
351        for OpenStatusChannelError
352    {
353        #[inline]
354        unsafe fn encode(
355            self,
356            encoder: &mut fidl::encoding::Encoder<'_, D>,
357            offset: usize,
358            _depth: fidl::encoding::Depth,
359        ) -> fidl::Result<()> {
360            encoder.debug_check_bounds::<Self>(offset);
361            encoder.write_num(self.into_primitive(), offset);
362            Ok(())
363        }
364    }
365
366    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
367        for OpenStatusChannelError
368    {
369        #[inline(always)]
370        fn new_empty() -> Self {
371            Self::Internal
372        }
373
374        #[inline]
375        unsafe fn decode(
376            &mut self,
377            decoder: &mut fidl::encoding::Decoder<'_, D>,
378            offset: usize,
379            _depth: fidl::encoding::Depth,
380        ) -> fidl::Result<()> {
381            decoder.debug_check_bounds::<Self>(offset);
382            let prim = decoder.read_num::<u32>(offset);
383
384            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
385            Ok(())
386        }
387    }
388    unsafe impl fidl::encoding::TypeMarker for SystemActivityControlError {
389        type Owned = Self;
390
391        #[inline(always)]
392        fn inline_align(_context: fidl::encoding::Context) -> usize {
393            std::mem::align_of::<u32>()
394        }
395
396        #[inline(always)]
397        fn inline_size(_context: fidl::encoding::Context) -> usize {
398            std::mem::size_of::<u32>()
399        }
400
401        #[inline(always)]
402        fn encode_is_copy() -> bool {
403            true
404        }
405
406        #[inline(always)]
407        fn decode_is_copy() -> bool {
408            false
409        }
410    }
411
412    impl fidl::encoding::ValueTypeMarker for SystemActivityControlError {
413        type Borrowed<'a> = Self;
414        #[inline(always)]
415        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
416            *value
417        }
418    }
419
420    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
421        for SystemActivityControlError
422    {
423        #[inline]
424        unsafe fn encode(
425            self,
426            encoder: &mut fidl::encoding::Encoder<'_, D>,
427            offset: usize,
428            _depth: fidl::encoding::Depth,
429        ) -> fidl::Result<()> {
430            encoder.debug_check_bounds::<Self>(offset);
431            encoder.write_num(self.into_primitive(), offset);
432            Ok(())
433        }
434    }
435
436    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
437        for SystemActivityControlError
438    {
439        #[inline(always)]
440        fn new_empty() -> Self {
441            Self::Internal
442        }
443
444        #[inline]
445        unsafe fn decode(
446            &mut self,
447            decoder: &mut fidl::encoding::Decoder<'_, D>,
448            offset: usize,
449            _depth: fidl::encoding::Depth,
450        ) -> fidl::Result<()> {
451            decoder.debug_check_bounds::<Self>(offset);
452            let prim = decoder.read_num::<u32>(offset);
453
454            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
455            Ok(())
456        }
457    }
458
459    impl fidl::encoding::ValueTypeMarker for Element {
460        type Borrowed<'a> = &'a Self;
461        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
462            value
463        }
464    }
465
466    unsafe impl fidl::encoding::TypeMarker for Element {
467        type Owned = Self;
468
469        #[inline(always)]
470        fn inline_align(_context: fidl::encoding::Context) -> usize {
471            8
472        }
473
474        #[inline(always)]
475        fn inline_size(_context: fidl::encoding::Context) -> usize {
476            56
477        }
478    }
479
480    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Element, D> for &Element {
481        #[inline]
482        unsafe fn encode(
483            self,
484            encoder: &mut fidl::encoding::Encoder<'_, D>,
485            offset: usize,
486            _depth: fidl::encoding::Depth,
487        ) -> fidl::Result<()> {
488            encoder.debug_check_bounds::<Element>(offset);
489            // Delegate to tuple encoding.
490            fidl::encoding::Encode::<Element, D>::encode(
491                (
492                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.element_name),
493                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.initial_current_level),
494                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.valid_levels),
495                    <fidl::encoding::Vector<LevelDependency, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.dependencies),
496                ),
497                encoder, offset, _depth
498            )
499        }
500    }
501    unsafe impl<
502            D: fidl::encoding::ResourceDialect,
503            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
504            T1: fidl::encoding::Encode<u8, D>,
505            T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
506            T3: fidl::encoding::Encode<fidl::encoding::Vector<LevelDependency, 256>, D>,
507        > fidl::encoding::Encode<Element, D> for (T0, T1, T2, T3)
508    {
509        #[inline]
510        unsafe fn encode(
511            self,
512            encoder: &mut fidl::encoding::Encoder<'_, D>,
513            offset: usize,
514            depth: fidl::encoding::Depth,
515        ) -> fidl::Result<()> {
516            encoder.debug_check_bounds::<Element>(offset);
517            // Zero out padding regions. There's no need to apply masks
518            // because the unmasked parts will be overwritten by fields.
519            unsafe {
520                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
521                (ptr as *mut u64).write_unaligned(0);
522            }
523            // Write the fields.
524            self.0.encode(encoder, offset + 0, depth)?;
525            self.1.encode(encoder, offset + 16, depth)?;
526            self.2.encode(encoder, offset + 24, depth)?;
527            self.3.encode(encoder, offset + 40, depth)?;
528            Ok(())
529        }
530    }
531
532    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Element {
533        #[inline(always)]
534        fn new_empty() -> Self {
535            Self {
536                element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
537                initial_current_level: fidl::new_empty!(u8, D),
538                valid_levels: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
539                dependencies: fidl::new_empty!(fidl::encoding::Vector<LevelDependency, 256>, D),
540            }
541        }
542
543        #[inline]
544        unsafe fn decode(
545            &mut self,
546            decoder: &mut fidl::encoding::Decoder<'_, D>,
547            offset: usize,
548            _depth: fidl::encoding::Depth,
549        ) -> fidl::Result<()> {
550            decoder.debug_check_bounds::<Self>(offset);
551            // Verify that padding bytes are zero.
552            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
553            let padval = unsafe { (ptr as *const u64).read_unaligned() };
554            let mask = 0xffffffffffffff00u64;
555            let maskedval = padval & mask;
556            if maskedval != 0 {
557                return Err(fidl::Error::NonZeroPadding {
558                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
559                });
560            }
561            fidl::decode!(
562                fidl::encoding::BoundedString<64>,
563                D,
564                &mut self.element_name,
565                decoder,
566                offset + 0,
567                _depth
568            )?;
569            fidl::decode!(u8, D, &mut self.initial_current_level, decoder, offset + 16, _depth)?;
570            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.valid_levels, decoder, offset + 24, _depth)?;
571            fidl::decode!(fidl::encoding::Vector<LevelDependency, 256>, D, &mut self.dependencies, decoder, offset + 40, _depth)?;
572            Ok(())
573        }
574    }
575
576    impl fidl::encoding::ValueTypeMarker for LevelDependency {
577        type Borrowed<'a> = &'a Self;
578        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
579            value
580        }
581    }
582
583    unsafe impl fidl::encoding::TypeMarker for LevelDependency {
584        type Owned = Self;
585
586        #[inline(always)]
587        fn inline_align(_context: fidl::encoding::Context) -> usize {
588            8
589        }
590
591        #[inline(always)]
592        fn inline_size(_context: fidl::encoding::Context) -> usize {
593            32
594        }
595    }
596
597    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LevelDependency, D>
598        for &LevelDependency
599    {
600        #[inline]
601        unsafe fn encode(
602            self,
603            encoder: &mut fidl::encoding::Encoder<'_, D>,
604            offset: usize,
605            _depth: fidl::encoding::Depth,
606        ) -> fidl::Result<()> {
607            encoder.debug_check_bounds::<LevelDependency>(offset);
608            // Delegate to tuple encoding.
609            fidl::encoding::Encode::<LevelDependency, D>::encode(
610                (
611                    <fidl_fuchsia_power_broker__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow(&self.dependency_type),
612                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.dependent_level),
613                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.requires_element),
614                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.requires_level),
615                ),
616                encoder, offset, _depth
617            )
618        }
619    }
620    unsafe impl<
621            D: fidl::encoding::ResourceDialect,
622            T0: fidl::encoding::Encode<fidl_fuchsia_power_broker__common::DependencyType, D>,
623            T1: fidl::encoding::Encode<u8, D>,
624            T2: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
625            T3: fidl::encoding::Encode<u8, D>,
626        > fidl::encoding::Encode<LevelDependency, D> for (T0, T1, T2, T3)
627    {
628        #[inline]
629        unsafe fn encode(
630            self,
631            encoder: &mut fidl::encoding::Encoder<'_, D>,
632            offset: usize,
633            depth: fidl::encoding::Depth,
634        ) -> fidl::Result<()> {
635            encoder.debug_check_bounds::<LevelDependency>(offset);
636            // Zero out padding regions. There's no need to apply masks
637            // because the unmasked parts will be overwritten by fields.
638            unsafe {
639                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
640                (ptr as *mut u64).write_unaligned(0);
641            }
642            unsafe {
643                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
644                (ptr as *mut u64).write_unaligned(0);
645            }
646            // Write the fields.
647            self.0.encode(encoder, offset + 0, depth)?;
648            self.1.encode(encoder, offset + 4, depth)?;
649            self.2.encode(encoder, offset + 8, depth)?;
650            self.3.encode(encoder, offset + 24, depth)?;
651            Ok(())
652        }
653    }
654
655    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelDependency {
656        #[inline(always)]
657        fn new_empty() -> Self {
658            Self {
659                dependency_type: fidl::new_empty!(
660                    fidl_fuchsia_power_broker__common::DependencyType,
661                    D
662                ),
663                dependent_level: fidl::new_empty!(u8, D),
664                requires_element: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
665                requires_level: fidl::new_empty!(u8, D),
666            }
667        }
668
669        #[inline]
670        unsafe fn decode(
671            &mut self,
672            decoder: &mut fidl::encoding::Decoder<'_, D>,
673            offset: usize,
674            _depth: fidl::encoding::Depth,
675        ) -> fidl::Result<()> {
676            decoder.debug_check_bounds::<Self>(offset);
677            // Verify that padding bytes are zero.
678            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
679            let padval = unsafe { (ptr as *const u64).read_unaligned() };
680            let mask = 0xffffff0000000000u64;
681            let maskedval = padval & mask;
682            if maskedval != 0 {
683                return Err(fidl::Error::NonZeroPadding {
684                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
685                });
686            }
687            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
688            let padval = unsafe { (ptr as *const u64).read_unaligned() };
689            let mask = 0xffffffffffffff00u64;
690            let maskedval = padval & mask;
691            if maskedval != 0 {
692                return Err(fidl::Error::NonZeroPadding {
693                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
694                });
695            }
696            fidl::decode!(
697                fidl_fuchsia_power_broker__common::DependencyType,
698                D,
699                &mut self.dependency_type,
700                decoder,
701                offset + 0,
702                _depth
703            )?;
704            fidl::decode!(u8, D, &mut self.dependent_level, decoder, offset + 4, _depth)?;
705            fidl::decode!(
706                fidl::encoding::BoundedString<64>,
707                D,
708                &mut self.requires_element,
709                decoder,
710                offset + 8,
711                _depth
712            )?;
713            fidl::decode!(u8, D, &mut self.requires_level, decoder, offset + 24, _depth)?;
714            Ok(())
715        }
716    }
717
718    impl fidl::encoding::ValueTypeMarker for TopologyControlAcquireLeaseRequest {
719        type Borrowed<'a> = &'a Self;
720        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
721            value
722        }
723    }
724
725    unsafe impl fidl::encoding::TypeMarker for TopologyControlAcquireLeaseRequest {
726        type Owned = Self;
727
728        #[inline(always)]
729        fn inline_align(_context: fidl::encoding::Context) -> usize {
730            8
731        }
732
733        #[inline(always)]
734        fn inline_size(_context: fidl::encoding::Context) -> usize {
735            24
736        }
737    }
738
739    unsafe impl<D: fidl::encoding::ResourceDialect>
740        fidl::encoding::Encode<TopologyControlAcquireLeaseRequest, D>
741        for &TopologyControlAcquireLeaseRequest
742    {
743        #[inline]
744        unsafe fn encode(
745            self,
746            encoder: &mut fidl::encoding::Encoder<'_, D>,
747            offset: usize,
748            _depth: fidl::encoding::Depth,
749        ) -> fidl::Result<()> {
750            encoder.debug_check_bounds::<TopologyControlAcquireLeaseRequest>(offset);
751            // Delegate to tuple encoding.
752            fidl::encoding::Encode::<TopologyControlAcquireLeaseRequest, D>::encode(
753                (
754                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
755                        &self.element_name,
756                    ),
757                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.level),
758                ),
759                encoder,
760                offset,
761                _depth,
762            )
763        }
764    }
765    unsafe impl<
766            D: fidl::encoding::ResourceDialect,
767            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
768            T1: fidl::encoding::Encode<u8, D>,
769        > fidl::encoding::Encode<TopologyControlAcquireLeaseRequest, D> for (T0, T1)
770    {
771        #[inline]
772        unsafe fn encode(
773            self,
774            encoder: &mut fidl::encoding::Encoder<'_, D>,
775            offset: usize,
776            depth: fidl::encoding::Depth,
777        ) -> fidl::Result<()> {
778            encoder.debug_check_bounds::<TopologyControlAcquireLeaseRequest>(offset);
779            // Zero out padding regions. There's no need to apply masks
780            // because the unmasked parts will be overwritten by fields.
781            unsafe {
782                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
783                (ptr as *mut u64).write_unaligned(0);
784            }
785            // Write the fields.
786            self.0.encode(encoder, offset + 0, depth)?;
787            self.1.encode(encoder, offset + 16, depth)?;
788            Ok(())
789        }
790    }
791
792    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
793        for TopologyControlAcquireLeaseRequest
794    {
795        #[inline(always)]
796        fn new_empty() -> Self {
797            Self {
798                element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
799                level: fidl::new_empty!(u8, D),
800            }
801        }
802
803        #[inline]
804        unsafe fn decode(
805            &mut self,
806            decoder: &mut fidl::encoding::Decoder<'_, D>,
807            offset: usize,
808            _depth: fidl::encoding::Depth,
809        ) -> fidl::Result<()> {
810            decoder.debug_check_bounds::<Self>(offset);
811            // Verify that padding bytes are zero.
812            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
813            let padval = unsafe { (ptr as *const u64).read_unaligned() };
814            let mask = 0xffffffffffffff00u64;
815            let maskedval = padval & mask;
816            if maskedval != 0 {
817                return Err(fidl::Error::NonZeroPadding {
818                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
819                });
820            }
821            fidl::decode!(
822                fidl::encoding::BoundedString<64>,
823                D,
824                &mut self.element_name,
825                decoder,
826                offset + 0,
827                _depth
828            )?;
829            fidl::decode!(u8, D, &mut self.level, decoder, offset + 16, _depth)?;
830            Ok(())
831        }
832    }
833
834    impl fidl::encoding::ValueTypeMarker for TopologyControlCreateRequest {
835        type Borrowed<'a> = &'a Self;
836        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
837            value
838        }
839    }
840
841    unsafe impl fidl::encoding::TypeMarker for TopologyControlCreateRequest {
842        type Owned = Self;
843
844        #[inline(always)]
845        fn inline_align(_context: fidl::encoding::Context) -> usize {
846            8
847        }
848
849        #[inline(always)]
850        fn inline_size(_context: fidl::encoding::Context) -> usize {
851            16
852        }
853    }
854
855    unsafe impl<D: fidl::encoding::ResourceDialect>
856        fidl::encoding::Encode<TopologyControlCreateRequest, D> for &TopologyControlCreateRequest
857    {
858        #[inline]
859        unsafe fn encode(
860            self,
861            encoder: &mut fidl::encoding::Encoder<'_, D>,
862            offset: usize,
863            _depth: fidl::encoding::Depth,
864        ) -> fidl::Result<()> {
865            encoder.debug_check_bounds::<TopologyControlCreateRequest>(offset);
866            // Delegate to tuple encoding.
867            fidl::encoding::Encode::<TopologyControlCreateRequest, D>::encode(
868                (
869                    <fidl::encoding::Vector<Element, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.elements),
870                ),
871                encoder, offset, _depth
872            )
873        }
874    }
875    unsafe impl<
876            D: fidl::encoding::ResourceDialect,
877            T0: fidl::encoding::Encode<fidl::encoding::Vector<Element, 256>, D>,
878        > fidl::encoding::Encode<TopologyControlCreateRequest, D> for (T0,)
879    {
880        #[inline]
881        unsafe fn encode(
882            self,
883            encoder: &mut fidl::encoding::Encoder<'_, D>,
884            offset: usize,
885            depth: fidl::encoding::Depth,
886        ) -> fidl::Result<()> {
887            encoder.debug_check_bounds::<TopologyControlCreateRequest>(offset);
888            // Zero out padding regions. There's no need to apply masks
889            // because the unmasked parts will be overwritten by fields.
890            // Write the fields.
891            self.0.encode(encoder, offset + 0, depth)?;
892            Ok(())
893        }
894    }
895
896    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
897        for TopologyControlCreateRequest
898    {
899        #[inline(always)]
900        fn new_empty() -> Self {
901            Self { elements: fidl::new_empty!(fidl::encoding::Vector<Element, 256>, D) }
902        }
903
904        #[inline]
905        unsafe fn decode(
906            &mut self,
907            decoder: &mut fidl::encoding::Decoder<'_, D>,
908            offset: usize,
909            _depth: fidl::encoding::Depth,
910        ) -> fidl::Result<()> {
911            decoder.debug_check_bounds::<Self>(offset);
912            // Verify that padding bytes are zero.
913            fidl::decode!(fidl::encoding::Vector<Element, 256>, D, &mut self.elements, decoder, offset + 0, _depth)?;
914            Ok(())
915        }
916    }
917
918    impl fidl::encoding::ValueTypeMarker for TopologyControlDropLeaseRequest {
919        type Borrowed<'a> = &'a Self;
920        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
921            value
922        }
923    }
924
925    unsafe impl fidl::encoding::TypeMarker for TopologyControlDropLeaseRequest {
926        type Owned = Self;
927
928        #[inline(always)]
929        fn inline_align(_context: fidl::encoding::Context) -> usize {
930            8
931        }
932
933        #[inline(always)]
934        fn inline_size(_context: fidl::encoding::Context) -> usize {
935            16
936        }
937    }
938
939    unsafe impl<D: fidl::encoding::ResourceDialect>
940        fidl::encoding::Encode<TopologyControlDropLeaseRequest, D>
941        for &TopologyControlDropLeaseRequest
942    {
943        #[inline]
944        unsafe fn encode(
945            self,
946            encoder: &mut fidl::encoding::Encoder<'_, D>,
947            offset: usize,
948            _depth: fidl::encoding::Depth,
949        ) -> fidl::Result<()> {
950            encoder.debug_check_bounds::<TopologyControlDropLeaseRequest>(offset);
951            // Delegate to tuple encoding.
952            fidl::encoding::Encode::<TopologyControlDropLeaseRequest, D>::encode(
953                (<fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
954                    &self.element_name,
955                ),),
956                encoder,
957                offset,
958                _depth,
959            )
960        }
961    }
962    unsafe impl<
963            D: fidl::encoding::ResourceDialect,
964            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
965        > fidl::encoding::Encode<TopologyControlDropLeaseRequest, D> for (T0,)
966    {
967        #[inline]
968        unsafe fn encode(
969            self,
970            encoder: &mut fidl::encoding::Encoder<'_, D>,
971            offset: usize,
972            depth: fidl::encoding::Depth,
973        ) -> fidl::Result<()> {
974            encoder.debug_check_bounds::<TopologyControlDropLeaseRequest>(offset);
975            // Zero out padding regions. There's no need to apply masks
976            // because the unmasked parts will be overwritten by fields.
977            // Write the fields.
978            self.0.encode(encoder, offset + 0, depth)?;
979            Ok(())
980        }
981    }
982
983    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
984        for TopologyControlDropLeaseRequest
985    {
986        #[inline(always)]
987        fn new_empty() -> Self {
988            Self { element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D) }
989        }
990
991        #[inline]
992        unsafe fn decode(
993            &mut self,
994            decoder: &mut fidl::encoding::Decoder<'_, D>,
995            offset: usize,
996            _depth: fidl::encoding::Depth,
997        ) -> fidl::Result<()> {
998            decoder.debug_check_bounds::<Self>(offset);
999            // Verify that padding bytes are zero.
1000            fidl::decode!(
1001                fidl::encoding::BoundedString<64>,
1002                D,
1003                &mut self.element_name,
1004                decoder,
1005                offset + 0,
1006                _depth
1007            )?;
1008            Ok(())
1009        }
1010    }
1011}