1#![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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
29#[repr(u32)]
30pub enum CreateTopologyGraphError {
31 Internal = 1,
33 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57#[repr(u32)]
58pub enum LeaseControlError {
59 Internal = 1,
61 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
84#[repr(u32)]
85pub enum OpenStatusChannelError {
86 Internal = 1,
88 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
111#[repr(u32)]
112pub enum SystemActivityControlError {
113 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#[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#[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 pub level: u8,
159}
160
161impl fidl::Persistable for TopologyControlAcquireLeaseRequest {}
162
163#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
164pub struct TopologyControlCreateRequest {
165 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 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 unsafe {
532 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
533 (ptr as *mut u64).write_unaligned(0);
534 }
535 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 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 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 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 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 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 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 unsafe {
794 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
795 (ptr as *mut u64).write_unaligned(0);
796 }
797 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 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 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 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 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 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 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 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}