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

fidl_fuchsia_power_topology_test__common/
fidl_fuchsia_power_topology_test__common.rs
