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