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
178pub mod system_activity_control_ordinals {
179    pub const START_APPLICATION_ACTIVITY: u64 = 0x61de6f5d5285a4e3;
180    pub const STOP_APPLICATION_ACTIVITY: u64 = 0x294ea5c8d0e2e0c0;
181}
182
183pub mod topology_control_ordinals {
184    pub const CREATE: u64 = 0x12033976b88716fa;
185    pub const ACQUIRE_LEASE: u64 = 0x1bedc35d9b68bac8;
186    pub const DROP_LEASE: u64 = 0x7107f8f1080faddc;
187    pub const OPEN_STATUS_CHANNEL: u64 = 0x69fba616c3ee2e90;
188}
189
190mod internal {
191    use super::*;
192    unsafe impl fidl::encoding::TypeMarker for CreateTopologyGraphError {
193        type Owned = Self;
194
195        #[inline(always)]
196        fn inline_align(_context: fidl::encoding::Context) -> usize {
197            std::mem::align_of::<u32>()
198        }
199
200        #[inline(always)]
201        fn inline_size(_context: fidl::encoding::Context) -> usize {
202            std::mem::size_of::<u32>()
203        }
204
205        #[inline(always)]
206        fn encode_is_copy() -> bool {
207            true
208        }
209
210        #[inline(always)]
211        fn decode_is_copy() -> bool {
212            false
213        }
214    }
215
216    impl fidl::encoding::ValueTypeMarker for CreateTopologyGraphError {
217        type Borrowed<'a> = Self;
218        #[inline(always)]
219        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
220            *value
221        }
222    }
223
224    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
225        for CreateTopologyGraphError
226    {
227        #[inline]
228        unsafe fn encode(
229            self,
230            encoder: &mut fidl::encoding::Encoder<'_, D>,
231            offset: usize,
232            _depth: fidl::encoding::Depth,
233        ) -> fidl::Result<()> {
234            encoder.debug_check_bounds::<Self>(offset);
235            encoder.write_num(self.into_primitive(), offset);
236            Ok(())
237        }
238    }
239
240    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
241        for CreateTopologyGraphError
242    {
243        #[inline(always)]
244        fn new_empty() -> Self {
245            Self::Internal
246        }
247
248        #[inline]
249        unsafe fn decode(
250            &mut self,
251            decoder: &mut fidl::encoding::Decoder<'_, D>,
252            offset: usize,
253            _depth: fidl::encoding::Depth,
254        ) -> fidl::Result<()> {
255            decoder.debug_check_bounds::<Self>(offset);
256            let prim = decoder.read_num::<u32>(offset);
257
258            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
259            Ok(())
260        }
261    }
262    unsafe impl fidl::encoding::TypeMarker for LeaseControlError {
263        type Owned = Self;
264
265        #[inline(always)]
266        fn inline_align(_context: fidl::encoding::Context) -> usize {
267            std::mem::align_of::<u32>()
268        }
269
270        #[inline(always)]
271        fn inline_size(_context: fidl::encoding::Context) -> usize {
272            std::mem::size_of::<u32>()
273        }
274
275        #[inline(always)]
276        fn encode_is_copy() -> bool {
277            true
278        }
279
280        #[inline(always)]
281        fn decode_is_copy() -> bool {
282            false
283        }
284    }
285
286    impl fidl::encoding::ValueTypeMarker for LeaseControlError {
287        type Borrowed<'a> = Self;
288        #[inline(always)]
289        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
290            *value
291        }
292    }
293
294    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
295        for LeaseControlError
296    {
297        #[inline]
298        unsafe fn encode(
299            self,
300            encoder: &mut fidl::encoding::Encoder<'_, D>,
301            offset: usize,
302            _depth: fidl::encoding::Depth,
303        ) -> fidl::Result<()> {
304            encoder.debug_check_bounds::<Self>(offset);
305            encoder.write_num(self.into_primitive(), offset);
306            Ok(())
307        }
308    }
309
310    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaseControlError {
311        #[inline(always)]
312        fn new_empty() -> Self {
313            Self::Internal
314        }
315
316        #[inline]
317        unsafe fn decode(
318            &mut self,
319            decoder: &mut fidl::encoding::Decoder<'_, D>,
320            offset: usize,
321            _depth: fidl::encoding::Depth,
322        ) -> fidl::Result<()> {
323            decoder.debug_check_bounds::<Self>(offset);
324            let prim = decoder.read_num::<u32>(offset);
325
326            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
327            Ok(())
328        }
329    }
330    unsafe impl fidl::encoding::TypeMarker for OpenStatusChannelError {
331        type Owned = Self;
332
333        #[inline(always)]
334        fn inline_align(_context: fidl::encoding::Context) -> usize {
335            std::mem::align_of::<u32>()
336        }
337
338        #[inline(always)]
339        fn inline_size(_context: fidl::encoding::Context) -> usize {
340            std::mem::size_of::<u32>()
341        }
342
343        #[inline(always)]
344        fn encode_is_copy() -> bool {
345            true
346        }
347
348        #[inline(always)]
349        fn decode_is_copy() -> bool {
350            false
351        }
352    }
353
354    impl fidl::encoding::ValueTypeMarker for OpenStatusChannelError {
355        type Borrowed<'a> = Self;
356        #[inline(always)]
357        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
358            *value
359        }
360    }
361
362    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
363        for OpenStatusChannelError
364    {
365        #[inline]
366        unsafe fn encode(
367            self,
368            encoder: &mut fidl::encoding::Encoder<'_, D>,
369            offset: usize,
370            _depth: fidl::encoding::Depth,
371        ) -> fidl::Result<()> {
372            encoder.debug_check_bounds::<Self>(offset);
373            encoder.write_num(self.into_primitive(), offset);
374            Ok(())
375        }
376    }
377
378    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
379        for OpenStatusChannelError
380    {
381        #[inline(always)]
382        fn new_empty() -> Self {
383            Self::Internal
384        }
385
386        #[inline]
387        unsafe fn decode(
388            &mut self,
389            decoder: &mut fidl::encoding::Decoder<'_, D>,
390            offset: usize,
391            _depth: fidl::encoding::Depth,
392        ) -> fidl::Result<()> {
393            decoder.debug_check_bounds::<Self>(offset);
394            let prim = decoder.read_num::<u32>(offset);
395
396            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
397            Ok(())
398        }
399    }
400    unsafe impl fidl::encoding::TypeMarker for SystemActivityControlError {
401        type Owned = Self;
402
403        #[inline(always)]
404        fn inline_align(_context: fidl::encoding::Context) -> usize {
405            std::mem::align_of::<u32>()
406        }
407
408        #[inline(always)]
409        fn inline_size(_context: fidl::encoding::Context) -> usize {
410            std::mem::size_of::<u32>()
411        }
412
413        #[inline(always)]
414        fn encode_is_copy() -> bool {
415            true
416        }
417
418        #[inline(always)]
419        fn decode_is_copy() -> bool {
420            false
421        }
422    }
423
424    impl fidl::encoding::ValueTypeMarker for SystemActivityControlError {
425        type Borrowed<'a> = Self;
426        #[inline(always)]
427        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
428            *value
429        }
430    }
431
432    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
433        for SystemActivityControlError
434    {
435        #[inline]
436        unsafe fn encode(
437            self,
438            encoder: &mut fidl::encoding::Encoder<'_, D>,
439            offset: usize,
440            _depth: fidl::encoding::Depth,
441        ) -> fidl::Result<()> {
442            encoder.debug_check_bounds::<Self>(offset);
443            encoder.write_num(self.into_primitive(), offset);
444            Ok(())
445        }
446    }
447
448    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
449        for SystemActivityControlError
450    {
451        #[inline(always)]
452        fn new_empty() -> Self {
453            Self::Internal
454        }
455
456        #[inline]
457        unsafe fn decode(
458            &mut self,
459            decoder: &mut fidl::encoding::Decoder<'_, D>,
460            offset: usize,
461            _depth: fidl::encoding::Depth,
462        ) -> fidl::Result<()> {
463            decoder.debug_check_bounds::<Self>(offset);
464            let prim = decoder.read_num::<u32>(offset);
465
466            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
467            Ok(())
468        }
469    }
470
471    impl fidl::encoding::ValueTypeMarker for Element {
472        type Borrowed<'a> = &'a Self;
473        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
474            value
475        }
476    }
477
478    unsafe impl fidl::encoding::TypeMarker for Element {
479        type Owned = Self;
480
481        #[inline(always)]
482        fn inline_align(_context: fidl::encoding::Context) -> usize {
483            8
484        }
485
486        #[inline(always)]
487        fn inline_size(_context: fidl::encoding::Context) -> usize {
488            56
489        }
490    }
491
492    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Element, D> for &Element {
493        #[inline]
494        unsafe fn encode(
495            self,
496            encoder: &mut fidl::encoding::Encoder<'_, D>,
497            offset: usize,
498            _depth: fidl::encoding::Depth,
499        ) -> fidl::Result<()> {
500            encoder.debug_check_bounds::<Element>(offset);
501            // Delegate to tuple encoding.
502            fidl::encoding::Encode::<Element, D>::encode(
503                (
504                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.element_name),
505                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.initial_current_level),
506                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.valid_levels),
507                    <fidl::encoding::Vector<LevelDependency, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.dependencies),
508                ),
509                encoder, offset, _depth
510            )
511        }
512    }
513    unsafe impl<
514            D: fidl::encoding::ResourceDialect,
515            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
516            T1: fidl::encoding::Encode<u8, D>,
517            T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
518            T3: fidl::encoding::Encode<fidl::encoding::Vector<LevelDependency, 256>, D>,
519        > fidl::encoding::Encode<Element, D> for (T0, T1, T2, T3)
520    {
521        #[inline]
522        unsafe fn encode(
523            self,
524            encoder: &mut fidl::encoding::Encoder<'_, D>,
525            offset: usize,
526            depth: fidl::encoding::Depth,
527        ) -> fidl::Result<()> {
528            encoder.debug_check_bounds::<Element>(offset);
529            // Zero out padding regions. There's no need to apply masks
530            // because the unmasked parts will be overwritten by fields.
531            unsafe {
532                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
533                (ptr as *mut u64).write_unaligned(0);
534            }
535            // Write the fields.
536            self.0.encode(encoder, offset + 0, depth)?;
537            self.1.encode(encoder, offset + 16, depth)?;
538            self.2.encode(encoder, offset + 24, depth)?;
539            self.3.encode(encoder, offset + 40, depth)?;
540            Ok(())
541        }
542    }
543
544    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Element {
545        #[inline(always)]
546        fn new_empty() -> Self {
547            Self {
548                element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
549                initial_current_level: fidl::new_empty!(u8, D),
550                valid_levels: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
551                dependencies: fidl::new_empty!(fidl::encoding::Vector<LevelDependency, 256>, D),
552            }
553        }
554
555        #[inline]
556        unsafe fn decode(
557            &mut self,
558            decoder: &mut fidl::encoding::Decoder<'_, D>,
559            offset: usize,
560            _depth: fidl::encoding::Depth,
561        ) -> fidl::Result<()> {
562            decoder.debug_check_bounds::<Self>(offset);
563            // Verify that padding bytes are zero.
564            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
565            let padval = unsafe { (ptr as *const u64).read_unaligned() };
566            let mask = 0xffffffffffffff00u64;
567            let maskedval = padval & mask;
568            if maskedval != 0 {
569                return Err(fidl::Error::NonZeroPadding {
570                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
571                });
572            }
573            fidl::decode!(
574                fidl::encoding::BoundedString<64>,
575                D,
576                &mut self.element_name,
577                decoder,
578                offset + 0,
579                _depth
580            )?;
581            fidl::decode!(u8, D, &mut self.initial_current_level, decoder, offset + 16, _depth)?;
582            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.valid_levels, decoder, offset + 24, _depth)?;
583            fidl::decode!(fidl::encoding::Vector<LevelDependency, 256>, D, &mut self.dependencies, decoder, offset + 40, _depth)?;
584            Ok(())
585        }
586    }
587
588    impl fidl::encoding::ValueTypeMarker for LevelDependency {
589        type Borrowed<'a> = &'a Self;
590        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
591            value
592        }
593    }
594
595    unsafe impl fidl::encoding::TypeMarker for LevelDependency {
596        type Owned = Self;
597
598        #[inline(always)]
599        fn inline_align(_context: fidl::encoding::Context) -> usize {
600            8
601        }
602
603        #[inline(always)]
604        fn inline_size(_context: fidl::encoding::Context) -> usize {
605            32
606        }
607    }
608
609    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LevelDependency, D>
610        for &LevelDependency
611    {
612        #[inline]
613        unsafe fn encode(
614            self,
615            encoder: &mut fidl::encoding::Encoder<'_, D>,
616            offset: usize,
617            _depth: fidl::encoding::Depth,
618        ) -> fidl::Result<()> {
619            encoder.debug_check_bounds::<LevelDependency>(offset);
620            // Delegate to tuple encoding.
621            fidl::encoding::Encode::<LevelDependency, D>::encode(
622                (
623                    <fidl_fuchsia_power_broker__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow(&self.dependency_type),
624                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.dependent_level),
625                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.requires_element),
626                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.requires_level),
627                ),
628                encoder, offset, _depth
629            )
630        }
631    }
632    unsafe impl<
633            D: fidl::encoding::ResourceDialect,
634            T0: fidl::encoding::Encode<fidl_fuchsia_power_broker__common::DependencyType, D>,
635            T1: fidl::encoding::Encode<u8, D>,
636            T2: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
637            T3: fidl::encoding::Encode<u8, D>,
638        > fidl::encoding::Encode<LevelDependency, D> for (T0, T1, T2, T3)
639    {
640        #[inline]
641        unsafe fn encode(
642            self,
643            encoder: &mut fidl::encoding::Encoder<'_, D>,
644            offset: usize,
645            depth: fidl::encoding::Depth,
646        ) -> fidl::Result<()> {
647            encoder.debug_check_bounds::<LevelDependency>(offset);
648            // Zero out padding regions. There's no need to apply masks
649            // because the unmasked parts will be overwritten by fields.
650            unsafe {
651                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
652                (ptr as *mut u64).write_unaligned(0);
653            }
654            unsafe {
655                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
656                (ptr as *mut u64).write_unaligned(0);
657            }
658            // Write the fields.
659            self.0.encode(encoder, offset + 0, depth)?;
660            self.1.encode(encoder, offset + 4, depth)?;
661            self.2.encode(encoder, offset + 8, depth)?;
662            self.3.encode(encoder, offset + 24, depth)?;
663            Ok(())
664        }
665    }
666
667    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelDependency {
668        #[inline(always)]
669        fn new_empty() -> Self {
670            Self {
671                dependency_type: fidl::new_empty!(
672                    fidl_fuchsia_power_broker__common::DependencyType,
673                    D
674                ),
675                dependent_level: fidl::new_empty!(u8, D),
676                requires_element: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
677                requires_level: fidl::new_empty!(u8, D),
678            }
679        }
680
681        #[inline]
682        unsafe fn decode(
683            &mut self,
684            decoder: &mut fidl::encoding::Decoder<'_, D>,
685            offset: usize,
686            _depth: fidl::encoding::Depth,
687        ) -> fidl::Result<()> {
688            decoder.debug_check_bounds::<Self>(offset);
689            // Verify that padding bytes are zero.
690            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
691            let padval = unsafe { (ptr as *const u64).read_unaligned() };
692            let mask = 0xffffff0000000000u64;
693            let maskedval = padval & mask;
694            if maskedval != 0 {
695                return Err(fidl::Error::NonZeroPadding {
696                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
697                });
698            }
699            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
700            let padval = unsafe { (ptr as *const u64).read_unaligned() };
701            let mask = 0xffffffffffffff00u64;
702            let maskedval = padval & mask;
703            if maskedval != 0 {
704                return Err(fidl::Error::NonZeroPadding {
705                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
706                });
707            }
708            fidl::decode!(
709                fidl_fuchsia_power_broker__common::DependencyType,
710                D,
711                &mut self.dependency_type,
712                decoder,
713                offset + 0,
714                _depth
715            )?;
716            fidl::decode!(u8, D, &mut self.dependent_level, decoder, offset + 4, _depth)?;
717            fidl::decode!(
718                fidl::encoding::BoundedString<64>,
719                D,
720                &mut self.requires_element,
721                decoder,
722                offset + 8,
723                _depth
724            )?;
725            fidl::decode!(u8, D, &mut self.requires_level, decoder, offset + 24, _depth)?;
726            Ok(())
727        }
728    }
729
730    impl fidl::encoding::ValueTypeMarker for TopologyControlAcquireLeaseRequest {
731        type Borrowed<'a> = &'a Self;
732        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
733            value
734        }
735    }
736
737    unsafe impl fidl::encoding::TypeMarker for TopologyControlAcquireLeaseRequest {
738        type Owned = Self;
739
740        #[inline(always)]
741        fn inline_align(_context: fidl::encoding::Context) -> usize {
742            8
743        }
744
745        #[inline(always)]
746        fn inline_size(_context: fidl::encoding::Context) -> usize {
747            24
748        }
749    }
750
751    unsafe impl<D: fidl::encoding::ResourceDialect>
752        fidl::encoding::Encode<TopologyControlAcquireLeaseRequest, D>
753        for &TopologyControlAcquireLeaseRequest
754    {
755        #[inline]
756        unsafe fn encode(
757            self,
758            encoder: &mut fidl::encoding::Encoder<'_, D>,
759            offset: usize,
760            _depth: fidl::encoding::Depth,
761        ) -> fidl::Result<()> {
762            encoder.debug_check_bounds::<TopologyControlAcquireLeaseRequest>(offset);
763            // Delegate to tuple encoding.
764            fidl::encoding::Encode::<TopologyControlAcquireLeaseRequest, D>::encode(
765                (
766                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
767                        &self.element_name,
768                    ),
769                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.level),
770                ),
771                encoder,
772                offset,
773                _depth,
774            )
775        }
776    }
777    unsafe impl<
778            D: fidl::encoding::ResourceDialect,
779            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
780            T1: fidl::encoding::Encode<u8, D>,
781        > fidl::encoding::Encode<TopologyControlAcquireLeaseRequest, D> for (T0, T1)
782    {
783        #[inline]
784        unsafe fn encode(
785            self,
786            encoder: &mut fidl::encoding::Encoder<'_, D>,
787            offset: usize,
788            depth: fidl::encoding::Depth,
789        ) -> fidl::Result<()> {
790            encoder.debug_check_bounds::<TopologyControlAcquireLeaseRequest>(offset);
791            // Zero out padding regions. There's no need to apply masks
792            // because the unmasked parts will be overwritten by fields.
793            unsafe {
794                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
795                (ptr as *mut u64).write_unaligned(0);
796            }
797            // Write the fields.
798            self.0.encode(encoder, offset + 0, depth)?;
799            self.1.encode(encoder, offset + 16, depth)?;
800            Ok(())
801        }
802    }
803
804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
805        for TopologyControlAcquireLeaseRequest
806    {
807        #[inline(always)]
808        fn new_empty() -> Self {
809            Self {
810                element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
811                level: fidl::new_empty!(u8, D),
812            }
813        }
814
815        #[inline]
816        unsafe fn decode(
817            &mut self,
818            decoder: &mut fidl::encoding::Decoder<'_, D>,
819            offset: usize,
820            _depth: fidl::encoding::Depth,
821        ) -> fidl::Result<()> {
822            decoder.debug_check_bounds::<Self>(offset);
823            // Verify that padding bytes are zero.
824            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
825            let padval = unsafe { (ptr as *const u64).read_unaligned() };
826            let mask = 0xffffffffffffff00u64;
827            let maskedval = padval & mask;
828            if maskedval != 0 {
829                return Err(fidl::Error::NonZeroPadding {
830                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
831                });
832            }
833            fidl::decode!(
834                fidl::encoding::BoundedString<64>,
835                D,
836                &mut self.element_name,
837                decoder,
838                offset + 0,
839                _depth
840            )?;
841            fidl::decode!(u8, D, &mut self.level, decoder, offset + 16, _depth)?;
842            Ok(())
843        }
844    }
845
846    impl fidl::encoding::ValueTypeMarker for TopologyControlCreateRequest {
847        type Borrowed<'a> = &'a Self;
848        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
849            value
850        }
851    }
852
853    unsafe impl fidl::encoding::TypeMarker for TopologyControlCreateRequest {
854        type Owned = Self;
855
856        #[inline(always)]
857        fn inline_align(_context: fidl::encoding::Context) -> usize {
858            8
859        }
860
861        #[inline(always)]
862        fn inline_size(_context: fidl::encoding::Context) -> usize {
863            16
864        }
865    }
866
867    unsafe impl<D: fidl::encoding::ResourceDialect>
868        fidl::encoding::Encode<TopologyControlCreateRequest, D> for &TopologyControlCreateRequest
869    {
870        #[inline]
871        unsafe fn encode(
872            self,
873            encoder: &mut fidl::encoding::Encoder<'_, D>,
874            offset: usize,
875            _depth: fidl::encoding::Depth,
876        ) -> fidl::Result<()> {
877            encoder.debug_check_bounds::<TopologyControlCreateRequest>(offset);
878            // Delegate to tuple encoding.
879            fidl::encoding::Encode::<TopologyControlCreateRequest, D>::encode(
880                (
881                    <fidl::encoding::Vector<Element, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.elements),
882                ),
883                encoder, offset, _depth
884            )
885        }
886    }
887    unsafe impl<
888            D: fidl::encoding::ResourceDialect,
889            T0: fidl::encoding::Encode<fidl::encoding::Vector<Element, 256>, D>,
890        > fidl::encoding::Encode<TopologyControlCreateRequest, D> for (T0,)
891    {
892        #[inline]
893        unsafe fn encode(
894            self,
895            encoder: &mut fidl::encoding::Encoder<'_, D>,
896            offset: usize,
897            depth: fidl::encoding::Depth,
898        ) -> fidl::Result<()> {
899            encoder.debug_check_bounds::<TopologyControlCreateRequest>(offset);
900            // Zero out padding regions. There's no need to apply masks
901            // because the unmasked parts will be overwritten by fields.
902            // Write the fields.
903            self.0.encode(encoder, offset + 0, depth)?;
904            Ok(())
905        }
906    }
907
908    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
909        for TopologyControlCreateRequest
910    {
911        #[inline(always)]
912        fn new_empty() -> Self {
913            Self { elements: fidl::new_empty!(fidl::encoding::Vector<Element, 256>, D) }
914        }
915
916        #[inline]
917        unsafe fn decode(
918            &mut self,
919            decoder: &mut fidl::encoding::Decoder<'_, D>,
920            offset: usize,
921            _depth: fidl::encoding::Depth,
922        ) -> fidl::Result<()> {
923            decoder.debug_check_bounds::<Self>(offset);
924            // Verify that padding bytes are zero.
925            fidl::decode!(fidl::encoding::Vector<Element, 256>, D, &mut self.elements, decoder, offset + 0, _depth)?;
926            Ok(())
927        }
928    }
929
930    impl fidl::encoding::ValueTypeMarker for TopologyControlDropLeaseRequest {
931        type Borrowed<'a> = &'a Self;
932        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
933            value
934        }
935    }
936
937    unsafe impl fidl::encoding::TypeMarker for TopologyControlDropLeaseRequest {
938        type Owned = Self;
939
940        #[inline(always)]
941        fn inline_align(_context: fidl::encoding::Context) -> usize {
942            8
943        }
944
945        #[inline(always)]
946        fn inline_size(_context: fidl::encoding::Context) -> usize {
947            16
948        }
949    }
950
951    unsafe impl<D: fidl::encoding::ResourceDialect>
952        fidl::encoding::Encode<TopologyControlDropLeaseRequest, D>
953        for &TopologyControlDropLeaseRequest
954    {
955        #[inline]
956        unsafe fn encode(
957            self,
958            encoder: &mut fidl::encoding::Encoder<'_, D>,
959            offset: usize,
960            _depth: fidl::encoding::Depth,
961        ) -> fidl::Result<()> {
962            encoder.debug_check_bounds::<TopologyControlDropLeaseRequest>(offset);
963            // Delegate to tuple encoding.
964            fidl::encoding::Encode::<TopologyControlDropLeaseRequest, D>::encode(
965                (<fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
966                    &self.element_name,
967                ),),
968                encoder,
969                offset,
970                _depth,
971            )
972        }
973    }
974    unsafe impl<
975            D: fidl::encoding::ResourceDialect,
976            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
977        > fidl::encoding::Encode<TopologyControlDropLeaseRequest, D> for (T0,)
978    {
979        #[inline]
980        unsafe fn encode(
981            self,
982            encoder: &mut fidl::encoding::Encoder<'_, D>,
983            offset: usize,
984            depth: fidl::encoding::Depth,
985        ) -> fidl::Result<()> {
986            encoder.debug_check_bounds::<TopologyControlDropLeaseRequest>(offset);
987            // Zero out padding regions. There's no need to apply masks
988            // because the unmasked parts will be overwritten by fields.
989            // Write the fields.
990            self.0.encode(encoder, offset + 0, depth)?;
991            Ok(())
992        }
993    }
994
995    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
996        for TopologyControlDropLeaseRequest
997    {
998        #[inline(always)]
999        fn new_empty() -> Self {
1000            Self { element_name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D) }
1001        }
1002
1003        #[inline]
1004        unsafe fn decode(
1005            &mut self,
1006            decoder: &mut fidl::encoding::Decoder<'_, D>,
1007            offset: usize,
1008            _depth: fidl::encoding::Depth,
1009        ) -> fidl::Result<()> {
1010            decoder.debug_check_bounds::<Self>(offset);
1011            // Verify that padding bytes are zero.
1012            fidl::decode!(
1013                fidl::encoding::BoundedString<64>,
1014                D,
1015                &mut self.element_name,
1016                decoder,
1017                offset + 0,
1018                _depth
1019            )?;
1020            Ok(())
1021        }
1022    }
1023}