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 const BINDING_RESULT_MAX: u8 = 10;
12
13pub const HASH_LENGTH: u8 = 64;
14
15pub const MAX_SEGMENTS: u32 = 20;
16
17pub const NODE_MONIKER_MAX: u32 = 1024;
18
19bitflags! {
20 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
24 pub struct RestartRematchFlags: u32 {
25 const REQUESTED = 1;
28 const NON_REQUESTED = 2;
32 const COMPOSITE_SPEC = 8;
34 }
35}
36
37impl RestartRematchFlags {
38 #[inline(always)]
39 pub fn from_bits_allow_unknown(bits: u32) -> Self {
40 Self::from_bits_retain(bits)
41 }
42
43 #[inline(always)]
44 pub fn has_unknown_bits(&self) -> bool {
45 self.get_unknown_bits() != 0
46 }
47
48 #[inline(always)]
49 pub fn get_unknown_bits(&self) -> u32 {
50 self.bits() & !Self::all().bits()
51 }
52}
53
54#[derive(Clone, Debug, PartialEq)]
55pub struct CompositeInfoIteratorGetNextResponse {
56 pub composites: Vec<CompositeNodeInfo>,
57}
58
59impl fidl::Persistable for CompositeInfoIteratorGetNextResponse {}
60
61#[derive(Clone, Debug, PartialEq)]
62pub struct CompositeNodeSpecIteratorGetNextResponse {
63 pub specs: Vec<fidl_fuchsia_driver_framework__common::CompositeInfo>,
64}
65
66impl fidl::Persistable for CompositeNodeSpecIteratorGetNextResponse {}
67
68#[derive(Clone, Debug, PartialEq)]
69pub struct DriverHostInfoIteratorGetNextResponse {
70 pub driver_hosts: Vec<DriverHostInfo>,
71}
72
73impl fidl::Persistable for DriverHostInfoIteratorGetNextResponse {}
74
75#[derive(Clone, Debug, PartialEq)]
76pub struct DriverInfoIteratorGetNextResponse {
77 pub drivers: Vec<fidl_fuchsia_driver_framework__common::DriverInfo>,
78}
79
80impl fidl::Persistable for DriverInfoIteratorGetNextResponse {}
81
82#[derive(Clone, Debug, PartialEq)]
83pub struct ManagerAddTestNodeRequest {
84 pub args: TestNodeAddArgs,
85}
86
87impl fidl::Persistable for ManagerAddTestNodeRequest {}
88
89#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
90pub struct ManagerDisableDriverRequest {
91 pub driver_url: String,
92 pub package_hash: Option<String>,
93}
94
95impl fidl::Persistable for ManagerDisableDriverRequest {}
96
97#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
98pub struct ManagerEnableDriverRequest {
99 pub driver_url: String,
100 pub package_hash: Option<String>,
101}
102
103impl fidl::Persistable for ManagerEnableDriverRequest {}
104
105#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
106pub struct ManagerRebindCompositesWithDriverRequest {
107 pub driver_url: String,
108}
109
110impl fidl::Persistable for ManagerRebindCompositesWithDriverRequest {}
111
112#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
113pub struct ManagerRemoveTestNodeRequest {
114 pub name: String,
115}
116
117impl fidl::Persistable for ManagerRemoveTestNodeRequest {}
118
119#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
120pub struct ManagerRestartDriverHostsRequest {
121 pub driver_url: String,
122 pub rematch_flags: RestartRematchFlags,
123}
124
125impl fidl::Persistable for ManagerRestartDriverHostsRequest {}
126
127#[derive(Clone, Debug, PartialEq)]
128pub struct ManagerBindAllUnboundNodesResponse {
129 pub binding_result: Vec<NodeBindingInfo>,
131}
132
133impl fidl::Persistable for ManagerBindAllUnboundNodesResponse {}
134
135#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
136#[repr(C)]
137pub struct ManagerRebindCompositesWithDriverResponse {
138 pub count: u32,
139}
140
141impl fidl::Persistable for ManagerRebindCompositesWithDriverResponse {}
142
143#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
144#[repr(C)]
145pub struct ManagerRestartDriverHostsResponse {
146 pub count: u32,
147}
148
149impl fidl::Persistable for ManagerRestartDriverHostsResponse {}
150
151#[derive(Clone, Debug, PartialEq)]
152pub struct NodeInfoIteratorGetNextResponse {
153 pub nodes: Vec<NodeInfo>,
154}
155
156impl fidl::Persistable for NodeInfoIteratorGetNextResponse {}
157
158#[derive(Clone, Debug, Default, PartialEq)]
160pub struct CompositeNodeInfo {
161 pub parent_topological_paths: Option<Vec<Option<String>>>,
163 pub topological_path: Option<String>,
165 pub composite: Option<CompositeInfo>,
166 #[doc(hidden)]
167 pub __source_breaking: fidl::marker::SourceBreaking,
168}
169
170impl fidl::Persistable for CompositeNodeInfo {}
171
172#[derive(Clone, Debug, Default, PartialEq)]
174pub struct DispatcherInfo {
175 pub driver: Option<String>,
177 pub name: Option<String>,
179 pub options: Option<u32>,
181 pub scheduler_role: Option<String>,
183 #[doc(hidden)]
184 pub __source_breaking: fidl::marker::SourceBreaking,
185}
186
187impl fidl::Persistable for DispatcherInfo {}
188
189#[derive(Clone, Debug, Default, PartialEq)]
191pub struct DriverHostInfo {
192 pub process_koid: Option<u64>,
194 pub threads: Option<Vec<ThreadInfo>>,
196 pub drivers: Option<Vec<String>>,
198 pub dispatchers: Option<Vec<DispatcherInfo>>,
200 #[doc(hidden)]
201 pub __source_breaking: fidl::marker::SourceBreaking,
202}
203
204impl fidl::Persistable for DriverHostInfo {}
205
206#[derive(Clone, Debug, Default, PartialEq)]
208pub struct NodeBindingInfo {
209 pub node_name: Option<String>,
211 pub driver_url: Option<String>,
214 pub composite_parents: Option<Vec<fidl_fuchsia_driver_framework__common::CompositeParent>>,
217 #[doc(hidden)]
218 pub __source_breaking: fidl::marker::SourceBreaking,
219}
220
221impl fidl::Persistable for NodeBindingInfo {}
222
223#[derive(Clone, Debug, Default, PartialEq)]
224pub struct NodeInfo {
225 pub id: Option<u64>,
227 pub parent_ids: Option<Vec<u64>>,
229 pub child_ids: Option<Vec<u64>>,
231 pub driver_host_koid: Option<u64>,
233 pub bound_driver_url: Option<String>,
235 pub moniker: Option<String>,
237 pub node_property_list: Option<Vec<fidl_fuchsia_driver_framework__common::NodeProperty>>,
239 pub offer_list: Option<Vec<fidl_fuchsia_component_decl__common::Offer>>,
241 pub quarantined: Option<bool>,
244 pub bus_topology: Option<Vec<fidl_fuchsia_driver_framework__common::BusInfo>>,
246 #[doc(hidden)]
247 pub __source_breaking: fidl::marker::SourceBreaking,
248}
249
250impl fidl::Persistable for NodeInfo {}
251
252#[derive(Clone, Debug, Default, PartialEq)]
253pub struct TestNodeAddArgs {
254 pub name: Option<String>,
256 pub properties: Option<Vec<fidl_fuchsia_driver_framework__common::NodeProperty>>,
258 #[doc(hidden)]
259 pub __source_breaking: fidl::marker::SourceBreaking,
260}
261
262impl fidl::Persistable for TestNodeAddArgs {}
263
264#[derive(Clone, Debug, Default, PartialEq)]
266pub struct ThreadInfo {
267 pub koid: Option<u64>,
269 pub name: Option<String>,
271 pub scheduler_role: Option<String>,
273 #[doc(hidden)]
274 pub __source_breaking: fidl::marker::SourceBreaking,
275}
276
277impl fidl::Persistable for ThreadInfo {}
278
279#[derive(Clone, Debug, PartialEq)]
281pub enum CompositeInfo {
282 Composite(fidl_fuchsia_driver_framework__common::CompositeInfo),
283}
284
285impl CompositeInfo {
286 #[inline]
287 pub fn ordinal(&self) -> u64 {
288 match *self {
289 Self::Composite(_) => 2,
290 }
291 }
292}
293
294impl fidl::Persistable for CompositeInfo {}
295
296mod internal {
297 use super::*;
298 unsafe impl fidl::encoding::TypeMarker for RestartRematchFlags {
299 type Owned = Self;
300
301 #[inline(always)]
302 fn inline_align(_context: fidl::encoding::Context) -> usize {
303 4
304 }
305
306 #[inline(always)]
307 fn inline_size(_context: fidl::encoding::Context) -> usize {
308 4
309 }
310 }
311
312 impl fidl::encoding::ValueTypeMarker for RestartRematchFlags {
313 type Borrowed<'a> = Self;
314 #[inline(always)]
315 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
316 *value
317 }
318 }
319
320 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
321 for RestartRematchFlags
322 {
323 #[inline]
324 unsafe fn encode(
325 self,
326 encoder: &mut fidl::encoding::Encoder<'_, D>,
327 offset: usize,
328 _depth: fidl::encoding::Depth,
329 ) -> fidl::Result<()> {
330 encoder.debug_check_bounds::<Self>(offset);
331 encoder.write_num(self.bits(), offset);
332 Ok(())
333 }
334 }
335
336 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RestartRematchFlags {
337 #[inline(always)]
338 fn new_empty() -> Self {
339 Self::empty()
340 }
341
342 #[inline]
343 unsafe fn decode(
344 &mut self,
345 decoder: &mut fidl::encoding::Decoder<'_, D>,
346 offset: usize,
347 _depth: fidl::encoding::Depth,
348 ) -> fidl::Result<()> {
349 decoder.debug_check_bounds::<Self>(offset);
350 let prim = decoder.read_num::<u32>(offset);
351 *self = Self::from_bits_allow_unknown(prim);
352 Ok(())
353 }
354 }
355
356 impl fidl::encoding::ValueTypeMarker for CompositeInfoIteratorGetNextResponse {
357 type Borrowed<'a> = &'a Self;
358 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
359 value
360 }
361 }
362
363 unsafe impl fidl::encoding::TypeMarker for CompositeInfoIteratorGetNextResponse {
364 type Owned = Self;
365
366 #[inline(always)]
367 fn inline_align(_context: fidl::encoding::Context) -> usize {
368 8
369 }
370
371 #[inline(always)]
372 fn inline_size(_context: fidl::encoding::Context) -> usize {
373 16
374 }
375 }
376
377 unsafe impl<D: fidl::encoding::ResourceDialect>
378 fidl::encoding::Encode<CompositeInfoIteratorGetNextResponse, D>
379 for &CompositeInfoIteratorGetNextResponse
380 {
381 #[inline]
382 unsafe fn encode(
383 self,
384 encoder: &mut fidl::encoding::Encoder<'_, D>,
385 offset: usize,
386 _depth: fidl::encoding::Depth,
387 ) -> fidl::Result<()> {
388 encoder.debug_check_bounds::<CompositeInfoIteratorGetNextResponse>(offset);
389 fidl::encoding::Encode::<CompositeInfoIteratorGetNextResponse, D>::encode(
391 (
392 <fidl::encoding::UnboundedVector<CompositeNodeInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.composites),
393 ),
394 encoder, offset, _depth
395 )
396 }
397 }
398 unsafe impl<
399 D: fidl::encoding::ResourceDialect,
400 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<CompositeNodeInfo>, D>,
401 > fidl::encoding::Encode<CompositeInfoIteratorGetNextResponse, D> for (T0,)
402 {
403 #[inline]
404 unsafe fn encode(
405 self,
406 encoder: &mut fidl::encoding::Encoder<'_, D>,
407 offset: usize,
408 depth: fidl::encoding::Depth,
409 ) -> fidl::Result<()> {
410 encoder.debug_check_bounds::<CompositeInfoIteratorGetNextResponse>(offset);
411 self.0.encode(encoder, offset + 0, depth)?;
415 Ok(())
416 }
417 }
418
419 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
420 for CompositeInfoIteratorGetNextResponse
421 {
422 #[inline(always)]
423 fn new_empty() -> Self {
424 Self {
425 composites: fidl::new_empty!(fidl::encoding::UnboundedVector<CompositeNodeInfo>, D),
426 }
427 }
428
429 #[inline]
430 unsafe fn decode(
431 &mut self,
432 decoder: &mut fidl::encoding::Decoder<'_, D>,
433 offset: usize,
434 _depth: fidl::encoding::Depth,
435 ) -> fidl::Result<()> {
436 decoder.debug_check_bounds::<Self>(offset);
437 fidl::decode!(
439 fidl::encoding::UnboundedVector<CompositeNodeInfo>,
440 D,
441 &mut self.composites,
442 decoder,
443 offset + 0,
444 _depth
445 )?;
446 Ok(())
447 }
448 }
449
450 impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecIteratorGetNextResponse {
451 type Borrowed<'a> = &'a Self;
452 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
453 value
454 }
455 }
456
457 unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecIteratorGetNextResponse {
458 type Owned = Self;
459
460 #[inline(always)]
461 fn inline_align(_context: fidl::encoding::Context) -> usize {
462 8
463 }
464
465 #[inline(always)]
466 fn inline_size(_context: fidl::encoding::Context) -> usize {
467 16
468 }
469 }
470
471 unsafe impl<D: fidl::encoding::ResourceDialect>
472 fidl::encoding::Encode<CompositeNodeSpecIteratorGetNextResponse, D>
473 for &CompositeNodeSpecIteratorGetNextResponse
474 {
475 #[inline]
476 unsafe fn encode(
477 self,
478 encoder: &mut fidl::encoding::Encoder<'_, D>,
479 offset: usize,
480 _depth: fidl::encoding::Depth,
481 ) -> fidl::Result<()> {
482 encoder.debug_check_bounds::<CompositeNodeSpecIteratorGetNextResponse>(offset);
483 fidl::encoding::Encode::<CompositeNodeSpecIteratorGetNextResponse, D>::encode(
485 (<fidl::encoding::UnboundedVector<
486 fidl_fuchsia_driver_framework__common::CompositeInfo,
487 > as fidl::encoding::ValueTypeMarker>::borrow(&self.specs),),
488 encoder,
489 offset,
490 _depth,
491 )
492 }
493 }
494 unsafe impl<
495 D: fidl::encoding::ResourceDialect,
496 T0: fidl::encoding::Encode<
497 fidl::encoding::UnboundedVector<
498 fidl_fuchsia_driver_framework__common::CompositeInfo,
499 >,
500 D,
501 >,
502 > fidl::encoding::Encode<CompositeNodeSpecIteratorGetNextResponse, D> for (T0,)
503 {
504 #[inline]
505 unsafe fn encode(
506 self,
507 encoder: &mut fidl::encoding::Encoder<'_, D>,
508 offset: usize,
509 depth: fidl::encoding::Depth,
510 ) -> fidl::Result<()> {
511 encoder.debug_check_bounds::<CompositeNodeSpecIteratorGetNextResponse>(offset);
512 self.0.encode(encoder, offset + 0, depth)?;
516 Ok(())
517 }
518 }
519
520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
521 for CompositeNodeSpecIteratorGetNextResponse
522 {
523 #[inline(always)]
524 fn new_empty() -> Self {
525 Self {
526 specs: fidl::new_empty!(
527 fidl::encoding::UnboundedVector<
528 fidl_fuchsia_driver_framework__common::CompositeInfo,
529 >,
530 D
531 ),
532 }
533 }
534
535 #[inline]
536 unsafe fn decode(
537 &mut self,
538 decoder: &mut fidl::encoding::Decoder<'_, D>,
539 offset: usize,
540 _depth: fidl::encoding::Depth,
541 ) -> fidl::Result<()> {
542 decoder.debug_check_bounds::<Self>(offset);
543 fidl::decode!(
545 fidl::encoding::UnboundedVector<
546 fidl_fuchsia_driver_framework__common::CompositeInfo,
547 >,
548 D,
549 &mut self.specs,
550 decoder,
551 offset + 0,
552 _depth
553 )?;
554 Ok(())
555 }
556 }
557
558 impl fidl::encoding::ValueTypeMarker for DriverHostInfoIteratorGetNextResponse {
559 type Borrowed<'a> = &'a Self;
560 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
561 value
562 }
563 }
564
565 unsafe impl fidl::encoding::TypeMarker for DriverHostInfoIteratorGetNextResponse {
566 type Owned = Self;
567
568 #[inline(always)]
569 fn inline_align(_context: fidl::encoding::Context) -> usize {
570 8
571 }
572
573 #[inline(always)]
574 fn inline_size(_context: fidl::encoding::Context) -> usize {
575 16
576 }
577 }
578
579 unsafe impl<D: fidl::encoding::ResourceDialect>
580 fidl::encoding::Encode<DriverHostInfoIteratorGetNextResponse, D>
581 for &DriverHostInfoIteratorGetNextResponse
582 {
583 #[inline]
584 unsafe fn encode(
585 self,
586 encoder: &mut fidl::encoding::Encoder<'_, D>,
587 offset: usize,
588 _depth: fidl::encoding::Depth,
589 ) -> fidl::Result<()> {
590 encoder.debug_check_bounds::<DriverHostInfoIteratorGetNextResponse>(offset);
591 fidl::encoding::Encode::<DriverHostInfoIteratorGetNextResponse, D>::encode(
593 (
594 <fidl::encoding::UnboundedVector<DriverHostInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_hosts),
595 ),
596 encoder, offset, _depth
597 )
598 }
599 }
600 unsafe impl<
601 D: fidl::encoding::ResourceDialect,
602 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DriverHostInfo>, D>,
603 > fidl::encoding::Encode<DriverHostInfoIteratorGetNextResponse, D> for (T0,)
604 {
605 #[inline]
606 unsafe fn encode(
607 self,
608 encoder: &mut fidl::encoding::Encoder<'_, D>,
609 offset: usize,
610 depth: fidl::encoding::Depth,
611 ) -> fidl::Result<()> {
612 encoder.debug_check_bounds::<DriverHostInfoIteratorGetNextResponse>(offset);
613 self.0.encode(encoder, offset + 0, depth)?;
617 Ok(())
618 }
619 }
620
621 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
622 for DriverHostInfoIteratorGetNextResponse
623 {
624 #[inline(always)]
625 fn new_empty() -> Self {
626 Self {
627 driver_hosts: fidl::new_empty!(fidl::encoding::UnboundedVector<DriverHostInfo>, D),
628 }
629 }
630
631 #[inline]
632 unsafe fn decode(
633 &mut self,
634 decoder: &mut fidl::encoding::Decoder<'_, D>,
635 offset: usize,
636 _depth: fidl::encoding::Depth,
637 ) -> fidl::Result<()> {
638 decoder.debug_check_bounds::<Self>(offset);
639 fidl::decode!(
641 fidl::encoding::UnboundedVector<DriverHostInfo>,
642 D,
643 &mut self.driver_hosts,
644 decoder,
645 offset + 0,
646 _depth
647 )?;
648 Ok(())
649 }
650 }
651
652 impl fidl::encoding::ValueTypeMarker for DriverInfoIteratorGetNextResponse {
653 type Borrowed<'a> = &'a Self;
654 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
655 value
656 }
657 }
658
659 unsafe impl fidl::encoding::TypeMarker for DriverInfoIteratorGetNextResponse {
660 type Owned = Self;
661
662 #[inline(always)]
663 fn inline_align(_context: fidl::encoding::Context) -> usize {
664 8
665 }
666
667 #[inline(always)]
668 fn inline_size(_context: fidl::encoding::Context) -> usize {
669 16
670 }
671 }
672
673 unsafe impl<D: fidl::encoding::ResourceDialect>
674 fidl::encoding::Encode<DriverInfoIteratorGetNextResponse, D>
675 for &DriverInfoIteratorGetNextResponse
676 {
677 #[inline]
678 unsafe fn encode(
679 self,
680 encoder: &mut fidl::encoding::Encoder<'_, D>,
681 offset: usize,
682 _depth: fidl::encoding::Depth,
683 ) -> fidl::Result<()> {
684 encoder.debug_check_bounds::<DriverInfoIteratorGetNextResponse>(offset);
685 fidl::encoding::Encode::<DriverInfoIteratorGetNextResponse, D>::encode(
687 (<fidl::encoding::UnboundedVector<
688 fidl_fuchsia_driver_framework__common::DriverInfo,
689 > as fidl::encoding::ValueTypeMarker>::borrow(&self.drivers),),
690 encoder,
691 offset,
692 _depth,
693 )
694 }
695 }
696 unsafe impl<
697 D: fidl::encoding::ResourceDialect,
698 T0: fidl::encoding::Encode<
699 fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework__common::DriverInfo>,
700 D,
701 >,
702 > fidl::encoding::Encode<DriverInfoIteratorGetNextResponse, D> for (T0,)
703 {
704 #[inline]
705 unsafe fn encode(
706 self,
707 encoder: &mut fidl::encoding::Encoder<'_, D>,
708 offset: usize,
709 depth: fidl::encoding::Depth,
710 ) -> fidl::Result<()> {
711 encoder.debug_check_bounds::<DriverInfoIteratorGetNextResponse>(offset);
712 self.0.encode(encoder, offset + 0, depth)?;
716 Ok(())
717 }
718 }
719
720 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
721 for DriverInfoIteratorGetNextResponse
722 {
723 #[inline(always)]
724 fn new_empty() -> Self {
725 Self {
726 drivers: fidl::new_empty!(
727 fidl::encoding::UnboundedVector<
728 fidl_fuchsia_driver_framework__common::DriverInfo,
729 >,
730 D
731 ),
732 }
733 }
734
735 #[inline]
736 unsafe fn decode(
737 &mut self,
738 decoder: &mut fidl::encoding::Decoder<'_, D>,
739 offset: usize,
740 _depth: fidl::encoding::Depth,
741 ) -> fidl::Result<()> {
742 decoder.debug_check_bounds::<Self>(offset);
743 fidl::decode!(
745 fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework__common::DriverInfo>,
746 D,
747 &mut self.drivers,
748 decoder,
749 offset + 0,
750 _depth
751 )?;
752 Ok(())
753 }
754 }
755
756 impl fidl::encoding::ValueTypeMarker for ManagerAddTestNodeRequest {
757 type Borrowed<'a> = &'a Self;
758 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
759 value
760 }
761 }
762
763 unsafe impl fidl::encoding::TypeMarker for ManagerAddTestNodeRequest {
764 type Owned = Self;
765
766 #[inline(always)]
767 fn inline_align(_context: fidl::encoding::Context) -> usize {
768 8
769 }
770
771 #[inline(always)]
772 fn inline_size(_context: fidl::encoding::Context) -> usize {
773 16
774 }
775 }
776
777 unsafe impl<D: fidl::encoding::ResourceDialect>
778 fidl::encoding::Encode<ManagerAddTestNodeRequest, D> for &ManagerAddTestNodeRequest
779 {
780 #[inline]
781 unsafe fn encode(
782 self,
783 encoder: &mut fidl::encoding::Encoder<'_, D>,
784 offset: usize,
785 _depth: fidl::encoding::Depth,
786 ) -> fidl::Result<()> {
787 encoder.debug_check_bounds::<ManagerAddTestNodeRequest>(offset);
788 fidl::encoding::Encode::<ManagerAddTestNodeRequest, D>::encode(
790 (<TestNodeAddArgs as fidl::encoding::ValueTypeMarker>::borrow(&self.args),),
791 encoder,
792 offset,
793 _depth,
794 )
795 }
796 }
797 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<TestNodeAddArgs, D>>
798 fidl::encoding::Encode<ManagerAddTestNodeRequest, D> for (T0,)
799 {
800 #[inline]
801 unsafe fn encode(
802 self,
803 encoder: &mut fidl::encoding::Encoder<'_, D>,
804 offset: usize,
805 depth: fidl::encoding::Depth,
806 ) -> fidl::Result<()> {
807 encoder.debug_check_bounds::<ManagerAddTestNodeRequest>(offset);
808 self.0.encode(encoder, offset + 0, depth)?;
812 Ok(())
813 }
814 }
815
816 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
817 for ManagerAddTestNodeRequest
818 {
819 #[inline(always)]
820 fn new_empty() -> Self {
821 Self { args: fidl::new_empty!(TestNodeAddArgs, D) }
822 }
823
824 #[inline]
825 unsafe fn decode(
826 &mut self,
827 decoder: &mut fidl::encoding::Decoder<'_, D>,
828 offset: usize,
829 _depth: fidl::encoding::Depth,
830 ) -> fidl::Result<()> {
831 decoder.debug_check_bounds::<Self>(offset);
832 fidl::decode!(TestNodeAddArgs, D, &mut self.args, decoder, offset + 0, _depth)?;
834 Ok(())
835 }
836 }
837
838 impl fidl::encoding::ValueTypeMarker for ManagerDisableDriverRequest {
839 type Borrowed<'a> = &'a Self;
840 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
841 value
842 }
843 }
844
845 unsafe impl fidl::encoding::TypeMarker for ManagerDisableDriverRequest {
846 type Owned = Self;
847
848 #[inline(always)]
849 fn inline_align(_context: fidl::encoding::Context) -> usize {
850 8
851 }
852
853 #[inline(always)]
854 fn inline_size(_context: fidl::encoding::Context) -> usize {
855 32
856 }
857 }
858
859 unsafe impl<D: fidl::encoding::ResourceDialect>
860 fidl::encoding::Encode<ManagerDisableDriverRequest, D> for &ManagerDisableDriverRequest
861 {
862 #[inline]
863 unsafe fn encode(
864 self,
865 encoder: &mut fidl::encoding::Encoder<'_, D>,
866 offset: usize,
867 _depth: fidl::encoding::Depth,
868 ) -> fidl::Result<()> {
869 encoder.debug_check_bounds::<ManagerDisableDriverRequest>(offset);
870 fidl::encoding::Encode::<ManagerDisableDriverRequest, D>::encode(
872 (
873 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_url),
874 <fidl::encoding::Optional<fidl::encoding::BoundedString<64>> as fidl::encoding::ValueTypeMarker>::borrow(&self.package_hash),
875 ),
876 encoder, offset, _depth
877 )
878 }
879 }
880 unsafe impl<
881 D: fidl::encoding::ResourceDialect,
882 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
883 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<64>>, D>,
884 > fidl::encoding::Encode<ManagerDisableDriverRequest, D> for (T0, T1)
885 {
886 #[inline]
887 unsafe fn encode(
888 self,
889 encoder: &mut fidl::encoding::Encoder<'_, D>,
890 offset: usize,
891 depth: fidl::encoding::Depth,
892 ) -> fidl::Result<()> {
893 encoder.debug_check_bounds::<ManagerDisableDriverRequest>(offset);
894 self.0.encode(encoder, offset + 0, depth)?;
898 self.1.encode(encoder, offset + 16, depth)?;
899 Ok(())
900 }
901 }
902
903 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
904 for ManagerDisableDriverRequest
905 {
906 #[inline(always)]
907 fn new_empty() -> Self {
908 Self {
909 driver_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
910 package_hash: fidl::new_empty!(
911 fidl::encoding::Optional<fidl::encoding::BoundedString<64>>,
912 D
913 ),
914 }
915 }
916
917 #[inline]
918 unsafe fn decode(
919 &mut self,
920 decoder: &mut fidl::encoding::Decoder<'_, D>,
921 offset: usize,
922 _depth: fidl::encoding::Depth,
923 ) -> fidl::Result<()> {
924 decoder.debug_check_bounds::<Self>(offset);
925 fidl::decode!(
927 fidl::encoding::BoundedString<4096>,
928 D,
929 &mut self.driver_url,
930 decoder,
931 offset + 0,
932 _depth
933 )?;
934 fidl::decode!(
935 fidl::encoding::Optional<fidl::encoding::BoundedString<64>>,
936 D,
937 &mut self.package_hash,
938 decoder,
939 offset + 16,
940 _depth
941 )?;
942 Ok(())
943 }
944 }
945
946 impl fidl::encoding::ValueTypeMarker for ManagerEnableDriverRequest {
947 type Borrowed<'a> = &'a Self;
948 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
949 value
950 }
951 }
952
953 unsafe impl fidl::encoding::TypeMarker for ManagerEnableDriverRequest {
954 type Owned = Self;
955
956 #[inline(always)]
957 fn inline_align(_context: fidl::encoding::Context) -> usize {
958 8
959 }
960
961 #[inline(always)]
962 fn inline_size(_context: fidl::encoding::Context) -> usize {
963 32
964 }
965 }
966
967 unsafe impl<D: fidl::encoding::ResourceDialect>
968 fidl::encoding::Encode<ManagerEnableDriverRequest, D> for &ManagerEnableDriverRequest
969 {
970 #[inline]
971 unsafe fn encode(
972 self,
973 encoder: &mut fidl::encoding::Encoder<'_, D>,
974 offset: usize,
975 _depth: fidl::encoding::Depth,
976 ) -> fidl::Result<()> {
977 encoder.debug_check_bounds::<ManagerEnableDriverRequest>(offset);
978 fidl::encoding::Encode::<ManagerEnableDriverRequest, D>::encode(
980 (
981 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_url),
982 <fidl::encoding::Optional<fidl::encoding::BoundedString<64>> as fidl::encoding::ValueTypeMarker>::borrow(&self.package_hash),
983 ),
984 encoder, offset, _depth
985 )
986 }
987 }
988 unsafe impl<
989 D: fidl::encoding::ResourceDialect,
990 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
991 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<64>>, D>,
992 > fidl::encoding::Encode<ManagerEnableDriverRequest, D> for (T0, T1)
993 {
994 #[inline]
995 unsafe fn encode(
996 self,
997 encoder: &mut fidl::encoding::Encoder<'_, D>,
998 offset: usize,
999 depth: fidl::encoding::Depth,
1000 ) -> fidl::Result<()> {
1001 encoder.debug_check_bounds::<ManagerEnableDriverRequest>(offset);
1002 self.0.encode(encoder, offset + 0, depth)?;
1006 self.1.encode(encoder, offset + 16, depth)?;
1007 Ok(())
1008 }
1009 }
1010
1011 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1012 for ManagerEnableDriverRequest
1013 {
1014 #[inline(always)]
1015 fn new_empty() -> Self {
1016 Self {
1017 driver_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
1018 package_hash: fidl::new_empty!(
1019 fidl::encoding::Optional<fidl::encoding::BoundedString<64>>,
1020 D
1021 ),
1022 }
1023 }
1024
1025 #[inline]
1026 unsafe fn decode(
1027 &mut self,
1028 decoder: &mut fidl::encoding::Decoder<'_, D>,
1029 offset: usize,
1030 _depth: fidl::encoding::Depth,
1031 ) -> fidl::Result<()> {
1032 decoder.debug_check_bounds::<Self>(offset);
1033 fidl::decode!(
1035 fidl::encoding::BoundedString<4096>,
1036 D,
1037 &mut self.driver_url,
1038 decoder,
1039 offset + 0,
1040 _depth
1041 )?;
1042 fidl::decode!(
1043 fidl::encoding::Optional<fidl::encoding::BoundedString<64>>,
1044 D,
1045 &mut self.package_hash,
1046 decoder,
1047 offset + 16,
1048 _depth
1049 )?;
1050 Ok(())
1051 }
1052 }
1053
1054 impl fidl::encoding::ValueTypeMarker for ManagerRebindCompositesWithDriverRequest {
1055 type Borrowed<'a> = &'a Self;
1056 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1057 value
1058 }
1059 }
1060
1061 unsafe impl fidl::encoding::TypeMarker for ManagerRebindCompositesWithDriverRequest {
1062 type Owned = Self;
1063
1064 #[inline(always)]
1065 fn inline_align(_context: fidl::encoding::Context) -> usize {
1066 8
1067 }
1068
1069 #[inline(always)]
1070 fn inline_size(_context: fidl::encoding::Context) -> usize {
1071 16
1072 }
1073 }
1074
1075 unsafe impl<D: fidl::encoding::ResourceDialect>
1076 fidl::encoding::Encode<ManagerRebindCompositesWithDriverRequest, D>
1077 for &ManagerRebindCompositesWithDriverRequest
1078 {
1079 #[inline]
1080 unsafe fn encode(
1081 self,
1082 encoder: &mut fidl::encoding::Encoder<'_, D>,
1083 offset: usize,
1084 _depth: fidl::encoding::Depth,
1085 ) -> fidl::Result<()> {
1086 encoder.debug_check_bounds::<ManagerRebindCompositesWithDriverRequest>(offset);
1087 fidl::encoding::Encode::<ManagerRebindCompositesWithDriverRequest, D>::encode(
1089 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1090 &self.driver_url,
1091 ),),
1092 encoder,
1093 offset,
1094 _depth,
1095 )
1096 }
1097 }
1098 unsafe impl<
1099 D: fidl::encoding::ResourceDialect,
1100 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1101 > fidl::encoding::Encode<ManagerRebindCompositesWithDriverRequest, D> for (T0,)
1102 {
1103 #[inline]
1104 unsafe fn encode(
1105 self,
1106 encoder: &mut fidl::encoding::Encoder<'_, D>,
1107 offset: usize,
1108 depth: fidl::encoding::Depth,
1109 ) -> fidl::Result<()> {
1110 encoder.debug_check_bounds::<ManagerRebindCompositesWithDriverRequest>(offset);
1111 self.0.encode(encoder, offset + 0, depth)?;
1115 Ok(())
1116 }
1117 }
1118
1119 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1120 for ManagerRebindCompositesWithDriverRequest
1121 {
1122 #[inline(always)]
1123 fn new_empty() -> Self {
1124 Self { driver_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1125 }
1126
1127 #[inline]
1128 unsafe fn decode(
1129 &mut self,
1130 decoder: &mut fidl::encoding::Decoder<'_, D>,
1131 offset: usize,
1132 _depth: fidl::encoding::Depth,
1133 ) -> fidl::Result<()> {
1134 decoder.debug_check_bounds::<Self>(offset);
1135 fidl::decode!(
1137 fidl::encoding::BoundedString<4096>,
1138 D,
1139 &mut self.driver_url,
1140 decoder,
1141 offset + 0,
1142 _depth
1143 )?;
1144 Ok(())
1145 }
1146 }
1147
1148 impl fidl::encoding::ValueTypeMarker for ManagerRemoveTestNodeRequest {
1149 type Borrowed<'a> = &'a Self;
1150 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1151 value
1152 }
1153 }
1154
1155 unsafe impl fidl::encoding::TypeMarker for ManagerRemoveTestNodeRequest {
1156 type Owned = Self;
1157
1158 #[inline(always)]
1159 fn inline_align(_context: fidl::encoding::Context) -> usize {
1160 8
1161 }
1162
1163 #[inline(always)]
1164 fn inline_size(_context: fidl::encoding::Context) -> usize {
1165 16
1166 }
1167 }
1168
1169 unsafe impl<D: fidl::encoding::ResourceDialect>
1170 fidl::encoding::Encode<ManagerRemoveTestNodeRequest, D> for &ManagerRemoveTestNodeRequest
1171 {
1172 #[inline]
1173 unsafe fn encode(
1174 self,
1175 encoder: &mut fidl::encoding::Encoder<'_, D>,
1176 offset: usize,
1177 _depth: fidl::encoding::Depth,
1178 ) -> fidl::Result<()> {
1179 encoder.debug_check_bounds::<ManagerRemoveTestNodeRequest>(offset);
1180 fidl::encoding::Encode::<ManagerRemoveTestNodeRequest, D>::encode(
1182 (<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
1183 &self.name,
1184 ),),
1185 encoder,
1186 offset,
1187 _depth,
1188 )
1189 }
1190 }
1191 unsafe impl<
1192 D: fidl::encoding::ResourceDialect,
1193 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1194 > fidl::encoding::Encode<ManagerRemoveTestNodeRequest, D> for (T0,)
1195 {
1196 #[inline]
1197 unsafe fn encode(
1198 self,
1199 encoder: &mut fidl::encoding::Encoder<'_, D>,
1200 offset: usize,
1201 depth: fidl::encoding::Depth,
1202 ) -> fidl::Result<()> {
1203 encoder.debug_check_bounds::<ManagerRemoveTestNodeRequest>(offset);
1204 self.0.encode(encoder, offset + 0, depth)?;
1208 Ok(())
1209 }
1210 }
1211
1212 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1213 for ManagerRemoveTestNodeRequest
1214 {
1215 #[inline(always)]
1216 fn new_empty() -> Self {
1217 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D) }
1218 }
1219
1220 #[inline]
1221 unsafe fn decode(
1222 &mut self,
1223 decoder: &mut fidl::encoding::Decoder<'_, D>,
1224 offset: usize,
1225 _depth: fidl::encoding::Depth,
1226 ) -> fidl::Result<()> {
1227 decoder.debug_check_bounds::<Self>(offset);
1228 fidl::decode!(
1230 fidl::encoding::BoundedString<1024>,
1231 D,
1232 &mut self.name,
1233 decoder,
1234 offset + 0,
1235 _depth
1236 )?;
1237 Ok(())
1238 }
1239 }
1240
1241 impl fidl::encoding::ValueTypeMarker for ManagerRestartDriverHostsRequest {
1242 type Borrowed<'a> = &'a Self;
1243 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1244 value
1245 }
1246 }
1247
1248 unsafe impl fidl::encoding::TypeMarker for ManagerRestartDriverHostsRequest {
1249 type Owned = Self;
1250
1251 #[inline(always)]
1252 fn inline_align(_context: fidl::encoding::Context) -> usize {
1253 8
1254 }
1255
1256 #[inline(always)]
1257 fn inline_size(_context: fidl::encoding::Context) -> usize {
1258 24
1259 }
1260 }
1261
1262 unsafe impl<D: fidl::encoding::ResourceDialect>
1263 fidl::encoding::Encode<ManagerRestartDriverHostsRequest, D>
1264 for &ManagerRestartDriverHostsRequest
1265 {
1266 #[inline]
1267 unsafe fn encode(
1268 self,
1269 encoder: &mut fidl::encoding::Encoder<'_, D>,
1270 offset: usize,
1271 _depth: fidl::encoding::Depth,
1272 ) -> fidl::Result<()> {
1273 encoder.debug_check_bounds::<ManagerRestartDriverHostsRequest>(offset);
1274 fidl::encoding::Encode::<ManagerRestartDriverHostsRequest, D>::encode(
1276 (
1277 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_url),
1278 <RestartRematchFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.rematch_flags),
1279 ),
1280 encoder, offset, _depth
1281 )
1282 }
1283 }
1284 unsafe impl<
1285 D: fidl::encoding::ResourceDialect,
1286 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1287 T1: fidl::encoding::Encode<RestartRematchFlags, D>,
1288 > fidl::encoding::Encode<ManagerRestartDriverHostsRequest, D> for (T0, T1)
1289 {
1290 #[inline]
1291 unsafe fn encode(
1292 self,
1293 encoder: &mut fidl::encoding::Encoder<'_, D>,
1294 offset: usize,
1295 depth: fidl::encoding::Depth,
1296 ) -> fidl::Result<()> {
1297 encoder.debug_check_bounds::<ManagerRestartDriverHostsRequest>(offset);
1298 unsafe {
1301 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1302 (ptr as *mut u64).write_unaligned(0);
1303 }
1304 self.0.encode(encoder, offset + 0, depth)?;
1306 self.1.encode(encoder, offset + 16, depth)?;
1307 Ok(())
1308 }
1309 }
1310
1311 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1312 for ManagerRestartDriverHostsRequest
1313 {
1314 #[inline(always)]
1315 fn new_empty() -> Self {
1316 Self {
1317 driver_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
1318 rematch_flags: fidl::new_empty!(RestartRematchFlags, D),
1319 }
1320 }
1321
1322 #[inline]
1323 unsafe fn decode(
1324 &mut self,
1325 decoder: &mut fidl::encoding::Decoder<'_, D>,
1326 offset: usize,
1327 _depth: fidl::encoding::Depth,
1328 ) -> fidl::Result<()> {
1329 decoder.debug_check_bounds::<Self>(offset);
1330 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1332 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1333 let mask = 0xffffffff00000000u64;
1334 let maskedval = padval & mask;
1335 if maskedval != 0 {
1336 return Err(fidl::Error::NonZeroPadding {
1337 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1338 });
1339 }
1340 fidl::decode!(
1341 fidl::encoding::BoundedString<4096>,
1342 D,
1343 &mut self.driver_url,
1344 decoder,
1345 offset + 0,
1346 _depth
1347 )?;
1348 fidl::decode!(
1349 RestartRematchFlags,
1350 D,
1351 &mut self.rematch_flags,
1352 decoder,
1353 offset + 16,
1354 _depth
1355 )?;
1356 Ok(())
1357 }
1358 }
1359
1360 impl fidl::encoding::ValueTypeMarker for ManagerBindAllUnboundNodesResponse {
1361 type Borrowed<'a> = &'a Self;
1362 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1363 value
1364 }
1365 }
1366
1367 unsafe impl fidl::encoding::TypeMarker for ManagerBindAllUnboundNodesResponse {
1368 type Owned = Self;
1369
1370 #[inline(always)]
1371 fn inline_align(_context: fidl::encoding::Context) -> usize {
1372 8
1373 }
1374
1375 #[inline(always)]
1376 fn inline_size(_context: fidl::encoding::Context) -> usize {
1377 16
1378 }
1379 }
1380
1381 unsafe impl<D: fidl::encoding::ResourceDialect>
1382 fidl::encoding::Encode<ManagerBindAllUnboundNodesResponse, D>
1383 for &ManagerBindAllUnboundNodesResponse
1384 {
1385 #[inline]
1386 unsafe fn encode(
1387 self,
1388 encoder: &mut fidl::encoding::Encoder<'_, D>,
1389 offset: usize,
1390 _depth: fidl::encoding::Depth,
1391 ) -> fidl::Result<()> {
1392 encoder.debug_check_bounds::<ManagerBindAllUnboundNodesResponse>(offset);
1393 fidl::encoding::Encode::<ManagerBindAllUnboundNodesResponse, D>::encode(
1395 (
1396 <fidl::encoding::Vector<NodeBindingInfo, 10> as fidl::encoding::ValueTypeMarker>::borrow(&self.binding_result),
1397 ),
1398 encoder, offset, _depth
1399 )
1400 }
1401 }
1402 unsafe impl<
1403 D: fidl::encoding::ResourceDialect,
1404 T0: fidl::encoding::Encode<fidl::encoding::Vector<NodeBindingInfo, 10>, D>,
1405 > fidl::encoding::Encode<ManagerBindAllUnboundNodesResponse, D> for (T0,)
1406 {
1407 #[inline]
1408 unsafe fn encode(
1409 self,
1410 encoder: &mut fidl::encoding::Encoder<'_, D>,
1411 offset: usize,
1412 depth: fidl::encoding::Depth,
1413 ) -> fidl::Result<()> {
1414 encoder.debug_check_bounds::<ManagerBindAllUnboundNodesResponse>(offset);
1415 self.0.encode(encoder, offset + 0, depth)?;
1419 Ok(())
1420 }
1421 }
1422
1423 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1424 for ManagerBindAllUnboundNodesResponse
1425 {
1426 #[inline(always)]
1427 fn new_empty() -> Self {
1428 Self {
1429 binding_result: fidl::new_empty!(fidl::encoding::Vector<NodeBindingInfo, 10>, D),
1430 }
1431 }
1432
1433 #[inline]
1434 unsafe fn decode(
1435 &mut self,
1436 decoder: &mut fidl::encoding::Decoder<'_, D>,
1437 offset: usize,
1438 _depth: fidl::encoding::Depth,
1439 ) -> fidl::Result<()> {
1440 decoder.debug_check_bounds::<Self>(offset);
1441 fidl::decode!(fidl::encoding::Vector<NodeBindingInfo, 10>, D, &mut self.binding_result, decoder, offset + 0, _depth)?;
1443 Ok(())
1444 }
1445 }
1446
1447 impl fidl::encoding::ValueTypeMarker for ManagerRebindCompositesWithDriverResponse {
1448 type Borrowed<'a> = &'a Self;
1449 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1450 value
1451 }
1452 }
1453
1454 unsafe impl fidl::encoding::TypeMarker for ManagerRebindCompositesWithDriverResponse {
1455 type Owned = Self;
1456
1457 #[inline(always)]
1458 fn inline_align(_context: fidl::encoding::Context) -> usize {
1459 4
1460 }
1461
1462 #[inline(always)]
1463 fn inline_size(_context: fidl::encoding::Context) -> usize {
1464 4
1465 }
1466 #[inline(always)]
1467 fn encode_is_copy() -> bool {
1468 true
1469 }
1470
1471 #[inline(always)]
1472 fn decode_is_copy() -> bool {
1473 true
1474 }
1475 }
1476
1477 unsafe impl<D: fidl::encoding::ResourceDialect>
1478 fidl::encoding::Encode<ManagerRebindCompositesWithDriverResponse, D>
1479 for &ManagerRebindCompositesWithDriverResponse
1480 {
1481 #[inline]
1482 unsafe fn encode(
1483 self,
1484 encoder: &mut fidl::encoding::Encoder<'_, D>,
1485 offset: usize,
1486 _depth: fidl::encoding::Depth,
1487 ) -> fidl::Result<()> {
1488 encoder.debug_check_bounds::<ManagerRebindCompositesWithDriverResponse>(offset);
1489 unsafe {
1490 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1492 (buf_ptr as *mut ManagerRebindCompositesWithDriverResponse).write_unaligned(
1493 (self as *const ManagerRebindCompositesWithDriverResponse).read(),
1494 );
1495 }
1498 Ok(())
1499 }
1500 }
1501 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1502 fidl::encoding::Encode<ManagerRebindCompositesWithDriverResponse, D> for (T0,)
1503 {
1504 #[inline]
1505 unsafe fn encode(
1506 self,
1507 encoder: &mut fidl::encoding::Encoder<'_, D>,
1508 offset: usize,
1509 depth: fidl::encoding::Depth,
1510 ) -> fidl::Result<()> {
1511 encoder.debug_check_bounds::<ManagerRebindCompositesWithDriverResponse>(offset);
1512 self.0.encode(encoder, offset + 0, depth)?;
1516 Ok(())
1517 }
1518 }
1519
1520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1521 for ManagerRebindCompositesWithDriverResponse
1522 {
1523 #[inline(always)]
1524 fn new_empty() -> Self {
1525 Self { count: fidl::new_empty!(u32, D) }
1526 }
1527
1528 #[inline]
1529 unsafe fn decode(
1530 &mut self,
1531 decoder: &mut fidl::encoding::Decoder<'_, D>,
1532 offset: usize,
1533 _depth: fidl::encoding::Depth,
1534 ) -> fidl::Result<()> {
1535 decoder.debug_check_bounds::<Self>(offset);
1536 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1537 unsafe {
1540 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1541 }
1542 Ok(())
1543 }
1544 }
1545
1546 impl fidl::encoding::ValueTypeMarker for ManagerRestartDriverHostsResponse {
1547 type Borrowed<'a> = &'a Self;
1548 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1549 value
1550 }
1551 }
1552
1553 unsafe impl fidl::encoding::TypeMarker for ManagerRestartDriverHostsResponse {
1554 type Owned = Self;
1555
1556 #[inline(always)]
1557 fn inline_align(_context: fidl::encoding::Context) -> usize {
1558 4
1559 }
1560
1561 #[inline(always)]
1562 fn inline_size(_context: fidl::encoding::Context) -> usize {
1563 4
1564 }
1565 #[inline(always)]
1566 fn encode_is_copy() -> bool {
1567 true
1568 }
1569
1570 #[inline(always)]
1571 fn decode_is_copy() -> bool {
1572 true
1573 }
1574 }
1575
1576 unsafe impl<D: fidl::encoding::ResourceDialect>
1577 fidl::encoding::Encode<ManagerRestartDriverHostsResponse, D>
1578 for &ManagerRestartDriverHostsResponse
1579 {
1580 #[inline]
1581 unsafe fn encode(
1582 self,
1583 encoder: &mut fidl::encoding::Encoder<'_, D>,
1584 offset: usize,
1585 _depth: fidl::encoding::Depth,
1586 ) -> fidl::Result<()> {
1587 encoder.debug_check_bounds::<ManagerRestartDriverHostsResponse>(offset);
1588 unsafe {
1589 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1591 (buf_ptr as *mut ManagerRestartDriverHostsResponse)
1592 .write_unaligned((self as *const ManagerRestartDriverHostsResponse).read());
1593 }
1596 Ok(())
1597 }
1598 }
1599 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1600 fidl::encoding::Encode<ManagerRestartDriverHostsResponse, D> for (T0,)
1601 {
1602 #[inline]
1603 unsafe fn encode(
1604 self,
1605 encoder: &mut fidl::encoding::Encoder<'_, D>,
1606 offset: usize,
1607 depth: fidl::encoding::Depth,
1608 ) -> fidl::Result<()> {
1609 encoder.debug_check_bounds::<ManagerRestartDriverHostsResponse>(offset);
1610 self.0.encode(encoder, offset + 0, depth)?;
1614 Ok(())
1615 }
1616 }
1617
1618 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1619 for ManagerRestartDriverHostsResponse
1620 {
1621 #[inline(always)]
1622 fn new_empty() -> Self {
1623 Self { count: fidl::new_empty!(u32, D) }
1624 }
1625
1626 #[inline]
1627 unsafe fn decode(
1628 &mut self,
1629 decoder: &mut fidl::encoding::Decoder<'_, D>,
1630 offset: usize,
1631 _depth: fidl::encoding::Depth,
1632 ) -> fidl::Result<()> {
1633 decoder.debug_check_bounds::<Self>(offset);
1634 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1635 unsafe {
1638 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1639 }
1640 Ok(())
1641 }
1642 }
1643
1644 impl fidl::encoding::ValueTypeMarker for NodeInfoIteratorGetNextResponse {
1645 type Borrowed<'a> = &'a Self;
1646 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1647 value
1648 }
1649 }
1650
1651 unsafe impl fidl::encoding::TypeMarker for NodeInfoIteratorGetNextResponse {
1652 type Owned = Self;
1653
1654 #[inline(always)]
1655 fn inline_align(_context: fidl::encoding::Context) -> usize {
1656 8
1657 }
1658
1659 #[inline(always)]
1660 fn inline_size(_context: fidl::encoding::Context) -> usize {
1661 16
1662 }
1663 }
1664
1665 unsafe impl<D: fidl::encoding::ResourceDialect>
1666 fidl::encoding::Encode<NodeInfoIteratorGetNextResponse, D>
1667 for &NodeInfoIteratorGetNextResponse
1668 {
1669 #[inline]
1670 unsafe fn encode(
1671 self,
1672 encoder: &mut fidl::encoding::Encoder<'_, D>,
1673 offset: usize,
1674 _depth: fidl::encoding::Depth,
1675 ) -> fidl::Result<()> {
1676 encoder.debug_check_bounds::<NodeInfoIteratorGetNextResponse>(offset);
1677 fidl::encoding::Encode::<NodeInfoIteratorGetNextResponse, D>::encode(
1679 (
1680 <fidl::encoding::UnboundedVector<NodeInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.nodes),
1681 ),
1682 encoder, offset, _depth
1683 )
1684 }
1685 }
1686 unsafe impl<
1687 D: fidl::encoding::ResourceDialect,
1688 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<NodeInfo>, D>,
1689 > fidl::encoding::Encode<NodeInfoIteratorGetNextResponse, D> for (T0,)
1690 {
1691 #[inline]
1692 unsafe fn encode(
1693 self,
1694 encoder: &mut fidl::encoding::Encoder<'_, D>,
1695 offset: usize,
1696 depth: fidl::encoding::Depth,
1697 ) -> fidl::Result<()> {
1698 encoder.debug_check_bounds::<NodeInfoIteratorGetNextResponse>(offset);
1699 self.0.encode(encoder, offset + 0, depth)?;
1703 Ok(())
1704 }
1705 }
1706
1707 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1708 for NodeInfoIteratorGetNextResponse
1709 {
1710 #[inline(always)]
1711 fn new_empty() -> Self {
1712 Self { nodes: fidl::new_empty!(fidl::encoding::UnboundedVector<NodeInfo>, D) }
1713 }
1714
1715 #[inline]
1716 unsafe fn decode(
1717 &mut self,
1718 decoder: &mut fidl::encoding::Decoder<'_, D>,
1719 offset: usize,
1720 _depth: fidl::encoding::Depth,
1721 ) -> fidl::Result<()> {
1722 decoder.debug_check_bounds::<Self>(offset);
1723 fidl::decode!(
1725 fidl::encoding::UnboundedVector<NodeInfo>,
1726 D,
1727 &mut self.nodes,
1728 decoder,
1729 offset + 0,
1730 _depth
1731 )?;
1732 Ok(())
1733 }
1734 }
1735
1736 impl CompositeNodeInfo {
1737 #[inline(always)]
1738 fn max_ordinal_present(&self) -> u64 {
1739 if let Some(_) = self.composite {
1740 return 3;
1741 }
1742 if let Some(_) = self.topological_path {
1743 return 2;
1744 }
1745 if let Some(_) = self.parent_topological_paths {
1746 return 1;
1747 }
1748 0
1749 }
1750 }
1751
1752 impl fidl::encoding::ValueTypeMarker for CompositeNodeInfo {
1753 type Borrowed<'a> = &'a Self;
1754 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1755 value
1756 }
1757 }
1758
1759 unsafe impl fidl::encoding::TypeMarker for CompositeNodeInfo {
1760 type Owned = Self;
1761
1762 #[inline(always)]
1763 fn inline_align(_context: fidl::encoding::Context) -> usize {
1764 8
1765 }
1766
1767 #[inline(always)]
1768 fn inline_size(_context: fidl::encoding::Context) -> usize {
1769 16
1770 }
1771 }
1772
1773 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeNodeInfo, D>
1774 for &CompositeNodeInfo
1775 {
1776 unsafe fn encode(
1777 self,
1778 encoder: &mut fidl::encoding::Encoder<'_, D>,
1779 offset: usize,
1780 mut depth: fidl::encoding::Depth,
1781 ) -> fidl::Result<()> {
1782 encoder.debug_check_bounds::<CompositeNodeInfo>(offset);
1783 let max_ordinal: u64 = self.max_ordinal_present();
1785 encoder.write_num(max_ordinal, offset);
1786 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1787 if max_ordinal == 0 {
1789 return Ok(());
1790 }
1791 depth.increment()?;
1792 let envelope_size = 8;
1793 let bytes_len = max_ordinal as usize * envelope_size;
1794 #[allow(unused_variables)]
1795 let offset = encoder.out_of_line_offset(bytes_len);
1796 let mut _prev_end_offset: usize = 0;
1797 if 1 > max_ordinal {
1798 return Ok(());
1799 }
1800
1801 let cur_offset: usize = (1 - 1) * envelope_size;
1804
1805 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1807
1808 fidl::encoding::encode_in_envelope_optional::<
1813 fidl::encoding::UnboundedVector<
1814 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1815 >,
1816 D,
1817 >(
1818 self.parent_topological_paths.as_ref().map(
1819 <fidl::encoding::UnboundedVector<
1820 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1821 > as fidl::encoding::ValueTypeMarker>::borrow,
1822 ),
1823 encoder,
1824 offset + cur_offset,
1825 depth,
1826 )?;
1827
1828 _prev_end_offset = cur_offset + envelope_size;
1829 if 2 > max_ordinal {
1830 return Ok(());
1831 }
1832
1833 let cur_offset: usize = (2 - 1) * envelope_size;
1836
1837 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1839
1840 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1845 self.topological_path.as_ref().map(
1846 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1847 ),
1848 encoder,
1849 offset + cur_offset,
1850 depth,
1851 )?;
1852
1853 _prev_end_offset = cur_offset + envelope_size;
1854 if 3 > max_ordinal {
1855 return Ok(());
1856 }
1857
1858 let cur_offset: usize = (3 - 1) * envelope_size;
1861
1862 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1864
1865 fidl::encoding::encode_in_envelope_optional::<CompositeInfo, D>(
1870 self.composite
1871 .as_ref()
1872 .map(<CompositeInfo as fidl::encoding::ValueTypeMarker>::borrow),
1873 encoder,
1874 offset + cur_offset,
1875 depth,
1876 )?;
1877
1878 _prev_end_offset = cur_offset + envelope_size;
1879
1880 Ok(())
1881 }
1882 }
1883
1884 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeNodeInfo {
1885 #[inline(always)]
1886 fn new_empty() -> Self {
1887 Self::default()
1888 }
1889
1890 unsafe fn decode(
1891 &mut self,
1892 decoder: &mut fidl::encoding::Decoder<'_, D>,
1893 offset: usize,
1894 mut depth: fidl::encoding::Depth,
1895 ) -> fidl::Result<()> {
1896 decoder.debug_check_bounds::<Self>(offset);
1897 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1898 None => return Err(fidl::Error::NotNullable),
1899 Some(len) => len,
1900 };
1901 if len == 0 {
1903 return Ok(());
1904 };
1905 depth.increment()?;
1906 let envelope_size = 8;
1907 let bytes_len = len * envelope_size;
1908 let offset = decoder.out_of_line_offset(bytes_len)?;
1909 let mut _next_ordinal_to_read = 0;
1911 let mut next_offset = offset;
1912 let end_offset = offset + bytes_len;
1913 _next_ordinal_to_read += 1;
1914 if next_offset >= end_offset {
1915 return Ok(());
1916 }
1917
1918 while _next_ordinal_to_read < 1 {
1920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1921 _next_ordinal_to_read += 1;
1922 next_offset += envelope_size;
1923 }
1924
1925 let next_out_of_line = decoder.next_out_of_line();
1926 let handles_before = decoder.remaining_handles();
1927 if let Some((inlined, num_bytes, num_handles)) =
1928 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1929 {
1930 let member_inline_size = <fidl::encoding::UnboundedVector<
1931 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1932 > as fidl::encoding::TypeMarker>::inline_size(
1933 decoder.context
1934 );
1935 if inlined != (member_inline_size <= 4) {
1936 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1937 }
1938 let inner_offset;
1939 let mut inner_depth = depth.clone();
1940 if inlined {
1941 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1942 inner_offset = next_offset;
1943 } else {
1944 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1945 inner_depth.increment()?;
1946 }
1947 let val_ref = self.parent_topological_paths.get_or_insert_with(|| {
1948 fidl::new_empty!(
1949 fidl::encoding::UnboundedVector<
1950 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1951 >,
1952 D
1953 )
1954 });
1955 fidl::decode!(
1956 fidl::encoding::UnboundedVector<
1957 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1958 >,
1959 D,
1960 val_ref,
1961 decoder,
1962 inner_offset,
1963 inner_depth
1964 )?;
1965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1966 {
1967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1968 }
1969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1971 }
1972 }
1973
1974 next_offset += envelope_size;
1975 _next_ordinal_to_read += 1;
1976 if next_offset >= end_offset {
1977 return Ok(());
1978 }
1979
1980 while _next_ordinal_to_read < 2 {
1982 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1983 _next_ordinal_to_read += 1;
1984 next_offset += envelope_size;
1985 }
1986
1987 let next_out_of_line = decoder.next_out_of_line();
1988 let handles_before = decoder.remaining_handles();
1989 if let Some((inlined, num_bytes, num_handles)) =
1990 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1991 {
1992 let member_inline_size =
1993 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1994 decoder.context,
1995 );
1996 if inlined != (member_inline_size <= 4) {
1997 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1998 }
1999 let inner_offset;
2000 let mut inner_depth = depth.clone();
2001 if inlined {
2002 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2003 inner_offset = next_offset;
2004 } else {
2005 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2006 inner_depth.increment()?;
2007 }
2008 let val_ref = self
2009 .topological_path
2010 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2011 fidl::decode!(
2012 fidl::encoding::UnboundedString,
2013 D,
2014 val_ref,
2015 decoder,
2016 inner_offset,
2017 inner_depth
2018 )?;
2019 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2020 {
2021 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2022 }
2023 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2024 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2025 }
2026 }
2027
2028 next_offset += envelope_size;
2029 _next_ordinal_to_read += 1;
2030 if next_offset >= end_offset {
2031 return Ok(());
2032 }
2033
2034 while _next_ordinal_to_read < 3 {
2036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2037 _next_ordinal_to_read += 1;
2038 next_offset += envelope_size;
2039 }
2040
2041 let next_out_of_line = decoder.next_out_of_line();
2042 let handles_before = decoder.remaining_handles();
2043 if let Some((inlined, num_bytes, num_handles)) =
2044 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2045 {
2046 let member_inline_size =
2047 <CompositeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2048 if inlined != (member_inline_size <= 4) {
2049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2050 }
2051 let inner_offset;
2052 let mut inner_depth = depth.clone();
2053 if inlined {
2054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2055 inner_offset = next_offset;
2056 } else {
2057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2058 inner_depth.increment()?;
2059 }
2060 let val_ref =
2061 self.composite.get_or_insert_with(|| fidl::new_empty!(CompositeInfo, D));
2062 fidl::decode!(CompositeInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2063 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2064 {
2065 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2066 }
2067 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2068 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2069 }
2070 }
2071
2072 next_offset += envelope_size;
2073
2074 while next_offset < end_offset {
2076 _next_ordinal_to_read += 1;
2077 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2078 next_offset += envelope_size;
2079 }
2080
2081 Ok(())
2082 }
2083 }
2084
2085 impl DispatcherInfo {
2086 #[inline(always)]
2087 fn max_ordinal_present(&self) -> u64 {
2088 if let Some(_) = self.scheduler_role {
2089 return 4;
2090 }
2091 if let Some(_) = self.options {
2092 return 3;
2093 }
2094 if let Some(_) = self.name {
2095 return 2;
2096 }
2097 if let Some(_) = self.driver {
2098 return 1;
2099 }
2100 0
2101 }
2102 }
2103
2104 impl fidl::encoding::ValueTypeMarker for DispatcherInfo {
2105 type Borrowed<'a> = &'a Self;
2106 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2107 value
2108 }
2109 }
2110
2111 unsafe impl fidl::encoding::TypeMarker for DispatcherInfo {
2112 type Owned = Self;
2113
2114 #[inline(always)]
2115 fn inline_align(_context: fidl::encoding::Context) -> usize {
2116 8
2117 }
2118
2119 #[inline(always)]
2120 fn inline_size(_context: fidl::encoding::Context) -> usize {
2121 16
2122 }
2123 }
2124
2125 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DispatcherInfo, D>
2126 for &DispatcherInfo
2127 {
2128 unsafe fn encode(
2129 self,
2130 encoder: &mut fidl::encoding::Encoder<'_, D>,
2131 offset: usize,
2132 mut depth: fidl::encoding::Depth,
2133 ) -> fidl::Result<()> {
2134 encoder.debug_check_bounds::<DispatcherInfo>(offset);
2135 let max_ordinal: u64 = self.max_ordinal_present();
2137 encoder.write_num(max_ordinal, offset);
2138 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2139 if max_ordinal == 0 {
2141 return Ok(());
2142 }
2143 depth.increment()?;
2144 let envelope_size = 8;
2145 let bytes_len = max_ordinal as usize * envelope_size;
2146 #[allow(unused_variables)]
2147 let offset = encoder.out_of_line_offset(bytes_len);
2148 let mut _prev_end_offset: usize = 0;
2149 if 1 > max_ordinal {
2150 return Ok(());
2151 }
2152
2153 let cur_offset: usize = (1 - 1) * envelope_size;
2156
2157 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2159
2160 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2165 self.driver.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2166 encoder, offset + cur_offset, depth
2167 )?;
2168
2169 _prev_end_offset = cur_offset + envelope_size;
2170 if 2 > max_ordinal {
2171 return Ok(());
2172 }
2173
2174 let cur_offset: usize = (2 - 1) * envelope_size;
2177
2178 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2180
2181 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2186 self.name.as_ref().map(
2187 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2188 ),
2189 encoder,
2190 offset + cur_offset,
2191 depth,
2192 )?;
2193
2194 _prev_end_offset = cur_offset + envelope_size;
2195 if 3 > max_ordinal {
2196 return Ok(());
2197 }
2198
2199 let cur_offset: usize = (3 - 1) * envelope_size;
2202
2203 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2205
2206 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2211 self.options.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2212 encoder,
2213 offset + cur_offset,
2214 depth,
2215 )?;
2216
2217 _prev_end_offset = cur_offset + envelope_size;
2218 if 4 > max_ordinal {
2219 return Ok(());
2220 }
2221
2222 let cur_offset: usize = (4 - 1) * envelope_size;
2225
2226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2228
2229 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2234 self.scheduler_role.as_ref().map(
2235 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2236 ),
2237 encoder,
2238 offset + cur_offset,
2239 depth,
2240 )?;
2241
2242 _prev_end_offset = cur_offset + envelope_size;
2243
2244 Ok(())
2245 }
2246 }
2247
2248 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DispatcherInfo {
2249 #[inline(always)]
2250 fn new_empty() -> Self {
2251 Self::default()
2252 }
2253
2254 unsafe fn decode(
2255 &mut self,
2256 decoder: &mut fidl::encoding::Decoder<'_, D>,
2257 offset: usize,
2258 mut depth: fidl::encoding::Depth,
2259 ) -> fidl::Result<()> {
2260 decoder.debug_check_bounds::<Self>(offset);
2261 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2262 None => return Err(fidl::Error::NotNullable),
2263 Some(len) => len,
2264 };
2265 if len == 0 {
2267 return Ok(());
2268 };
2269 depth.increment()?;
2270 let envelope_size = 8;
2271 let bytes_len = len * envelope_size;
2272 let offset = decoder.out_of_line_offset(bytes_len)?;
2273 let mut _next_ordinal_to_read = 0;
2275 let mut next_offset = offset;
2276 let end_offset = offset + bytes_len;
2277 _next_ordinal_to_read += 1;
2278 if next_offset >= end_offset {
2279 return Ok(());
2280 }
2281
2282 while _next_ordinal_to_read < 1 {
2284 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2285 _next_ordinal_to_read += 1;
2286 next_offset += envelope_size;
2287 }
2288
2289 let next_out_of_line = decoder.next_out_of_line();
2290 let handles_before = decoder.remaining_handles();
2291 if let Some((inlined, num_bytes, num_handles)) =
2292 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2293 {
2294 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2295 if inlined != (member_inline_size <= 4) {
2296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2297 }
2298 let inner_offset;
2299 let mut inner_depth = depth.clone();
2300 if inlined {
2301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2302 inner_offset = next_offset;
2303 } else {
2304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2305 inner_depth.increment()?;
2306 }
2307 let val_ref = self.driver.get_or_insert_with(|| {
2308 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2309 });
2310 fidl::decode!(
2311 fidl::encoding::BoundedString<4096>,
2312 D,
2313 val_ref,
2314 decoder,
2315 inner_offset,
2316 inner_depth
2317 )?;
2318 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2319 {
2320 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2321 }
2322 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2323 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2324 }
2325 }
2326
2327 next_offset += envelope_size;
2328 _next_ordinal_to_read += 1;
2329 if next_offset >= end_offset {
2330 return Ok(());
2331 }
2332
2333 while _next_ordinal_to_read < 2 {
2335 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2336 _next_ordinal_to_read += 1;
2337 next_offset += envelope_size;
2338 }
2339
2340 let next_out_of_line = decoder.next_out_of_line();
2341 let handles_before = decoder.remaining_handles();
2342 if let Some((inlined, num_bytes, num_handles)) =
2343 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2344 {
2345 let member_inline_size =
2346 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2347 decoder.context,
2348 );
2349 if inlined != (member_inline_size <= 4) {
2350 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2351 }
2352 let inner_offset;
2353 let mut inner_depth = depth.clone();
2354 if inlined {
2355 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2356 inner_offset = next_offset;
2357 } else {
2358 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2359 inner_depth.increment()?;
2360 }
2361 let val_ref = self
2362 .name
2363 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2364 fidl::decode!(
2365 fidl::encoding::UnboundedString,
2366 D,
2367 val_ref,
2368 decoder,
2369 inner_offset,
2370 inner_depth
2371 )?;
2372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2373 {
2374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2375 }
2376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2378 }
2379 }
2380
2381 next_offset += envelope_size;
2382 _next_ordinal_to_read += 1;
2383 if next_offset >= end_offset {
2384 return Ok(());
2385 }
2386
2387 while _next_ordinal_to_read < 3 {
2389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2390 _next_ordinal_to_read += 1;
2391 next_offset += envelope_size;
2392 }
2393
2394 let next_out_of_line = decoder.next_out_of_line();
2395 let handles_before = decoder.remaining_handles();
2396 if let Some((inlined, num_bytes, num_handles)) =
2397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2398 {
2399 let member_inline_size =
2400 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2401 if inlined != (member_inline_size <= 4) {
2402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2403 }
2404 let inner_offset;
2405 let mut inner_depth = depth.clone();
2406 if inlined {
2407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2408 inner_offset = next_offset;
2409 } else {
2410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2411 inner_depth.increment()?;
2412 }
2413 let val_ref = self.options.get_or_insert_with(|| fidl::new_empty!(u32, D));
2414 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2415 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2416 {
2417 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2418 }
2419 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2420 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2421 }
2422 }
2423
2424 next_offset += envelope_size;
2425 _next_ordinal_to_read += 1;
2426 if next_offset >= end_offset {
2427 return Ok(());
2428 }
2429
2430 while _next_ordinal_to_read < 4 {
2432 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2433 _next_ordinal_to_read += 1;
2434 next_offset += envelope_size;
2435 }
2436
2437 let next_out_of_line = decoder.next_out_of_line();
2438 let handles_before = decoder.remaining_handles();
2439 if let Some((inlined, num_bytes, num_handles)) =
2440 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2441 {
2442 let member_inline_size =
2443 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2444 decoder.context,
2445 );
2446 if inlined != (member_inline_size <= 4) {
2447 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2448 }
2449 let inner_offset;
2450 let mut inner_depth = depth.clone();
2451 if inlined {
2452 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2453 inner_offset = next_offset;
2454 } else {
2455 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2456 inner_depth.increment()?;
2457 }
2458 let val_ref = self
2459 .scheduler_role
2460 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2461 fidl::decode!(
2462 fidl::encoding::UnboundedString,
2463 D,
2464 val_ref,
2465 decoder,
2466 inner_offset,
2467 inner_depth
2468 )?;
2469 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2470 {
2471 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2472 }
2473 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2474 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2475 }
2476 }
2477
2478 next_offset += envelope_size;
2479
2480 while next_offset < end_offset {
2482 _next_ordinal_to_read += 1;
2483 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2484 next_offset += envelope_size;
2485 }
2486
2487 Ok(())
2488 }
2489 }
2490
2491 impl DriverHostInfo {
2492 #[inline(always)]
2493 fn max_ordinal_present(&self) -> u64 {
2494 if let Some(_) = self.dispatchers {
2495 return 4;
2496 }
2497 if let Some(_) = self.drivers {
2498 return 3;
2499 }
2500 if let Some(_) = self.threads {
2501 return 2;
2502 }
2503 if let Some(_) = self.process_koid {
2504 return 1;
2505 }
2506 0
2507 }
2508 }
2509
2510 impl fidl::encoding::ValueTypeMarker for DriverHostInfo {
2511 type Borrowed<'a> = &'a Self;
2512 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2513 value
2514 }
2515 }
2516
2517 unsafe impl fidl::encoding::TypeMarker for DriverHostInfo {
2518 type Owned = Self;
2519
2520 #[inline(always)]
2521 fn inline_align(_context: fidl::encoding::Context) -> usize {
2522 8
2523 }
2524
2525 #[inline(always)]
2526 fn inline_size(_context: fidl::encoding::Context) -> usize {
2527 16
2528 }
2529 }
2530
2531 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DriverHostInfo, D>
2532 for &DriverHostInfo
2533 {
2534 unsafe fn encode(
2535 self,
2536 encoder: &mut fidl::encoding::Encoder<'_, D>,
2537 offset: usize,
2538 mut depth: fidl::encoding::Depth,
2539 ) -> fidl::Result<()> {
2540 encoder.debug_check_bounds::<DriverHostInfo>(offset);
2541 let max_ordinal: u64 = self.max_ordinal_present();
2543 encoder.write_num(max_ordinal, offset);
2544 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2545 if max_ordinal == 0 {
2547 return Ok(());
2548 }
2549 depth.increment()?;
2550 let envelope_size = 8;
2551 let bytes_len = max_ordinal as usize * envelope_size;
2552 #[allow(unused_variables)]
2553 let offset = encoder.out_of_line_offset(bytes_len);
2554 let mut _prev_end_offset: usize = 0;
2555 if 1 > max_ordinal {
2556 return Ok(());
2557 }
2558
2559 let cur_offset: usize = (1 - 1) * envelope_size;
2562
2563 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2565
2566 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2571 self.process_koid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2572 encoder,
2573 offset + cur_offset,
2574 depth,
2575 )?;
2576
2577 _prev_end_offset = cur_offset + envelope_size;
2578 if 2 > max_ordinal {
2579 return Ok(());
2580 }
2581
2582 let cur_offset: usize = (2 - 1) * envelope_size;
2585
2586 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2588
2589 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ThreadInfo>, D>(
2594 self.threads.as_ref().map(<fidl::encoding::UnboundedVector<ThreadInfo> as fidl::encoding::ValueTypeMarker>::borrow),
2595 encoder, offset + cur_offset, depth
2596 )?;
2597
2598 _prev_end_offset = cur_offset + envelope_size;
2599 if 3 > max_ordinal {
2600 return Ok(());
2601 }
2602
2603 let cur_offset: usize = (3 - 1) * envelope_size;
2606
2607 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2609
2610 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>, D>(
2615 self.drivers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>> as fidl::encoding::ValueTypeMarker>::borrow),
2616 encoder, offset + cur_offset, depth
2617 )?;
2618
2619 _prev_end_offset = cur_offset + envelope_size;
2620 if 4 > max_ordinal {
2621 return Ok(());
2622 }
2623
2624 let cur_offset: usize = (4 - 1) * envelope_size;
2627
2628 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2630
2631 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DispatcherInfo>, D>(
2636 self.dispatchers.as_ref().map(<fidl::encoding::UnboundedVector<DispatcherInfo> as fidl::encoding::ValueTypeMarker>::borrow),
2637 encoder, offset + cur_offset, depth
2638 )?;
2639
2640 _prev_end_offset = cur_offset + envelope_size;
2641
2642 Ok(())
2643 }
2644 }
2645
2646 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverHostInfo {
2647 #[inline(always)]
2648 fn new_empty() -> Self {
2649 Self::default()
2650 }
2651
2652 unsafe fn decode(
2653 &mut self,
2654 decoder: &mut fidl::encoding::Decoder<'_, D>,
2655 offset: usize,
2656 mut depth: fidl::encoding::Depth,
2657 ) -> fidl::Result<()> {
2658 decoder.debug_check_bounds::<Self>(offset);
2659 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2660 None => return Err(fidl::Error::NotNullable),
2661 Some(len) => len,
2662 };
2663 if len == 0 {
2665 return Ok(());
2666 };
2667 depth.increment()?;
2668 let envelope_size = 8;
2669 let bytes_len = len * envelope_size;
2670 let offset = decoder.out_of_line_offset(bytes_len)?;
2671 let mut _next_ordinal_to_read = 0;
2673 let mut next_offset = offset;
2674 let end_offset = offset + bytes_len;
2675 _next_ordinal_to_read += 1;
2676 if next_offset >= end_offset {
2677 return Ok(());
2678 }
2679
2680 while _next_ordinal_to_read < 1 {
2682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2683 _next_ordinal_to_read += 1;
2684 next_offset += envelope_size;
2685 }
2686
2687 let next_out_of_line = decoder.next_out_of_line();
2688 let handles_before = decoder.remaining_handles();
2689 if let Some((inlined, num_bytes, num_handles)) =
2690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2691 {
2692 let member_inline_size =
2693 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2694 if inlined != (member_inline_size <= 4) {
2695 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2696 }
2697 let inner_offset;
2698 let mut inner_depth = depth.clone();
2699 if inlined {
2700 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2701 inner_offset = next_offset;
2702 } else {
2703 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2704 inner_depth.increment()?;
2705 }
2706 let val_ref = self.process_koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
2707 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2708 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2709 {
2710 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2711 }
2712 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2713 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2714 }
2715 }
2716
2717 next_offset += envelope_size;
2718 _next_ordinal_to_read += 1;
2719 if next_offset >= end_offset {
2720 return Ok(());
2721 }
2722
2723 while _next_ordinal_to_read < 2 {
2725 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2726 _next_ordinal_to_read += 1;
2727 next_offset += envelope_size;
2728 }
2729
2730 let next_out_of_line = decoder.next_out_of_line();
2731 let handles_before = decoder.remaining_handles();
2732 if let Some((inlined, num_bytes, num_handles)) =
2733 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2734 {
2735 let member_inline_size = <fidl::encoding::UnboundedVector<ThreadInfo> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2736 if inlined != (member_inline_size <= 4) {
2737 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2738 }
2739 let inner_offset;
2740 let mut inner_depth = depth.clone();
2741 if inlined {
2742 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2743 inner_offset = next_offset;
2744 } else {
2745 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2746 inner_depth.increment()?;
2747 }
2748 let val_ref = self.threads.get_or_insert_with(|| {
2749 fidl::new_empty!(fidl::encoding::UnboundedVector<ThreadInfo>, D)
2750 });
2751 fidl::decode!(
2752 fidl::encoding::UnboundedVector<ThreadInfo>,
2753 D,
2754 val_ref,
2755 decoder,
2756 inner_offset,
2757 inner_depth
2758 )?;
2759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2760 {
2761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2762 }
2763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2765 }
2766 }
2767
2768 next_offset += envelope_size;
2769 _next_ordinal_to_read += 1;
2770 if next_offset >= end_offset {
2771 return Ok(());
2772 }
2773
2774 while _next_ordinal_to_read < 3 {
2776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2777 _next_ordinal_to_read += 1;
2778 next_offset += envelope_size;
2779 }
2780
2781 let next_out_of_line = decoder.next_out_of_line();
2782 let handles_before = decoder.remaining_handles();
2783 if let Some((inlined, num_bytes, num_handles)) =
2784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2785 {
2786 let member_inline_size = <fidl::encoding::UnboundedVector<
2787 fidl::encoding::BoundedString<4096>,
2788 > as fidl::encoding::TypeMarker>::inline_size(
2789 decoder.context
2790 );
2791 if inlined != (member_inline_size <= 4) {
2792 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2793 }
2794 let inner_offset;
2795 let mut inner_depth = depth.clone();
2796 if inlined {
2797 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2798 inner_offset = next_offset;
2799 } else {
2800 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2801 inner_depth.increment()?;
2802 }
2803 let val_ref = self.drivers.get_or_insert_with(|| {
2804 fidl::new_empty!(
2805 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
2806 D
2807 )
2808 });
2809 fidl::decode!(
2810 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
2811 D,
2812 val_ref,
2813 decoder,
2814 inner_offset,
2815 inner_depth
2816 )?;
2817 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2818 {
2819 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2820 }
2821 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2822 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2823 }
2824 }
2825
2826 next_offset += envelope_size;
2827 _next_ordinal_to_read += 1;
2828 if next_offset >= end_offset {
2829 return Ok(());
2830 }
2831
2832 while _next_ordinal_to_read < 4 {
2834 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2835 _next_ordinal_to_read += 1;
2836 next_offset += envelope_size;
2837 }
2838
2839 let next_out_of_line = decoder.next_out_of_line();
2840 let handles_before = decoder.remaining_handles();
2841 if let Some((inlined, num_bytes, num_handles)) =
2842 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2843 {
2844 let member_inline_size = <fidl::encoding::UnboundedVector<DispatcherInfo> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2845 if inlined != (member_inline_size <= 4) {
2846 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2847 }
2848 let inner_offset;
2849 let mut inner_depth = depth.clone();
2850 if inlined {
2851 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2852 inner_offset = next_offset;
2853 } else {
2854 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2855 inner_depth.increment()?;
2856 }
2857 let val_ref = self.dispatchers.get_or_insert_with(|| {
2858 fidl::new_empty!(fidl::encoding::UnboundedVector<DispatcherInfo>, D)
2859 });
2860 fidl::decode!(
2861 fidl::encoding::UnboundedVector<DispatcherInfo>,
2862 D,
2863 val_ref,
2864 decoder,
2865 inner_offset,
2866 inner_depth
2867 )?;
2868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2869 {
2870 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2871 }
2872 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2873 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2874 }
2875 }
2876
2877 next_offset += envelope_size;
2878
2879 while next_offset < end_offset {
2881 _next_ordinal_to_read += 1;
2882 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2883 next_offset += envelope_size;
2884 }
2885
2886 Ok(())
2887 }
2888 }
2889
2890 impl NodeBindingInfo {
2891 #[inline(always)]
2892 fn max_ordinal_present(&self) -> u64 {
2893 if let Some(_) = self.composite_parents {
2894 return 3;
2895 }
2896 if let Some(_) = self.driver_url {
2897 return 2;
2898 }
2899 if let Some(_) = self.node_name {
2900 return 1;
2901 }
2902 0
2903 }
2904 }
2905
2906 impl fidl::encoding::ValueTypeMarker for NodeBindingInfo {
2907 type Borrowed<'a> = &'a Self;
2908 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2909 value
2910 }
2911 }
2912
2913 unsafe impl fidl::encoding::TypeMarker for NodeBindingInfo {
2914 type Owned = Self;
2915
2916 #[inline(always)]
2917 fn inline_align(_context: fidl::encoding::Context) -> usize {
2918 8
2919 }
2920
2921 #[inline(always)]
2922 fn inline_size(_context: fidl::encoding::Context) -> usize {
2923 16
2924 }
2925 }
2926
2927 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeBindingInfo, D>
2928 for &NodeBindingInfo
2929 {
2930 unsafe fn encode(
2931 self,
2932 encoder: &mut fidl::encoding::Encoder<'_, D>,
2933 offset: usize,
2934 mut depth: fidl::encoding::Depth,
2935 ) -> fidl::Result<()> {
2936 encoder.debug_check_bounds::<NodeBindingInfo>(offset);
2937 let max_ordinal: u64 = self.max_ordinal_present();
2939 encoder.write_num(max_ordinal, offset);
2940 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2941 if max_ordinal == 0 {
2943 return Ok(());
2944 }
2945 depth.increment()?;
2946 let envelope_size = 8;
2947 let bytes_len = max_ordinal as usize * envelope_size;
2948 #[allow(unused_variables)]
2949 let offset = encoder.out_of_line_offset(bytes_len);
2950 let mut _prev_end_offset: usize = 0;
2951 if 1 > max_ordinal {
2952 return Ok(());
2953 }
2954
2955 let cur_offset: usize = (1 - 1) * envelope_size;
2958
2959 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2961
2962 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
2967 self.node_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
2968 encoder, offset + cur_offset, depth
2969 )?;
2970
2971 _prev_end_offset = cur_offset + envelope_size;
2972 if 2 > max_ordinal {
2973 return Ok(());
2974 }
2975
2976 let cur_offset: usize = (2 - 1) * envelope_size;
2979
2980 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2982
2983 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2988 self.driver_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2989 encoder, offset + cur_offset, depth
2990 )?;
2991
2992 _prev_end_offset = cur_offset + envelope_size;
2993 if 3 > max_ordinal {
2994 return Ok(());
2995 }
2996
2997 let cur_offset: usize = (3 - 1) * envelope_size;
3000
3001 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3003
3004 fidl::encoding::encode_in_envelope_optional::<
3009 fidl::encoding::UnboundedVector<
3010 fidl_fuchsia_driver_framework__common::CompositeParent,
3011 >,
3012 D,
3013 >(
3014 self.composite_parents.as_ref().map(
3015 <fidl::encoding::UnboundedVector<
3016 fidl_fuchsia_driver_framework__common::CompositeParent,
3017 > as fidl::encoding::ValueTypeMarker>::borrow,
3018 ),
3019 encoder,
3020 offset + cur_offset,
3021 depth,
3022 )?;
3023
3024 _prev_end_offset = cur_offset + envelope_size;
3025
3026 Ok(())
3027 }
3028 }
3029
3030 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeBindingInfo {
3031 #[inline(always)]
3032 fn new_empty() -> Self {
3033 Self::default()
3034 }
3035
3036 unsafe fn decode(
3037 &mut self,
3038 decoder: &mut fidl::encoding::Decoder<'_, D>,
3039 offset: usize,
3040 mut depth: fidl::encoding::Depth,
3041 ) -> fidl::Result<()> {
3042 decoder.debug_check_bounds::<Self>(offset);
3043 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3044 None => return Err(fidl::Error::NotNullable),
3045 Some(len) => len,
3046 };
3047 if len == 0 {
3049 return Ok(());
3050 };
3051 depth.increment()?;
3052 let envelope_size = 8;
3053 let bytes_len = len * envelope_size;
3054 let offset = decoder.out_of_line_offset(bytes_len)?;
3055 let mut _next_ordinal_to_read = 0;
3057 let mut next_offset = offset;
3058 let end_offset = offset + bytes_len;
3059 _next_ordinal_to_read += 1;
3060 if next_offset >= end_offset {
3061 return Ok(());
3062 }
3063
3064 while _next_ordinal_to_read < 1 {
3066 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3067 _next_ordinal_to_read += 1;
3068 next_offset += envelope_size;
3069 }
3070
3071 let next_out_of_line = decoder.next_out_of_line();
3072 let handles_before = decoder.remaining_handles();
3073 if let Some((inlined, num_bytes, num_handles)) =
3074 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3075 {
3076 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3077 if inlined != (member_inline_size <= 4) {
3078 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3079 }
3080 let inner_offset;
3081 let mut inner_depth = depth.clone();
3082 if inlined {
3083 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3084 inner_offset = next_offset;
3085 } else {
3086 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3087 inner_depth.increment()?;
3088 }
3089 let val_ref = self.node_name.get_or_insert_with(|| {
3090 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
3091 });
3092 fidl::decode!(
3093 fidl::encoding::BoundedString<1024>,
3094 D,
3095 val_ref,
3096 decoder,
3097 inner_offset,
3098 inner_depth
3099 )?;
3100 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3101 {
3102 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3103 }
3104 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3105 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3106 }
3107 }
3108
3109 next_offset += envelope_size;
3110 _next_ordinal_to_read += 1;
3111 if next_offset >= end_offset {
3112 return Ok(());
3113 }
3114
3115 while _next_ordinal_to_read < 2 {
3117 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3118 _next_ordinal_to_read += 1;
3119 next_offset += envelope_size;
3120 }
3121
3122 let next_out_of_line = decoder.next_out_of_line();
3123 let handles_before = decoder.remaining_handles();
3124 if let Some((inlined, num_bytes, num_handles)) =
3125 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3126 {
3127 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3128 if inlined != (member_inline_size <= 4) {
3129 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3130 }
3131 let inner_offset;
3132 let mut inner_depth = depth.clone();
3133 if inlined {
3134 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3135 inner_offset = next_offset;
3136 } else {
3137 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3138 inner_depth.increment()?;
3139 }
3140 let val_ref = self.driver_url.get_or_insert_with(|| {
3141 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3142 });
3143 fidl::decode!(
3144 fidl::encoding::BoundedString<4096>,
3145 D,
3146 val_ref,
3147 decoder,
3148 inner_offset,
3149 inner_depth
3150 )?;
3151 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3152 {
3153 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3154 }
3155 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3156 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3157 }
3158 }
3159
3160 next_offset += envelope_size;
3161 _next_ordinal_to_read += 1;
3162 if next_offset >= end_offset {
3163 return Ok(());
3164 }
3165
3166 while _next_ordinal_to_read < 3 {
3168 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3169 _next_ordinal_to_read += 1;
3170 next_offset += envelope_size;
3171 }
3172
3173 let next_out_of_line = decoder.next_out_of_line();
3174 let handles_before = decoder.remaining_handles();
3175 if let Some((inlined, num_bytes, num_handles)) =
3176 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3177 {
3178 let member_inline_size = <fidl::encoding::UnboundedVector<
3179 fidl_fuchsia_driver_framework__common::CompositeParent,
3180 > as fidl::encoding::TypeMarker>::inline_size(
3181 decoder.context
3182 );
3183 if inlined != (member_inline_size <= 4) {
3184 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3185 }
3186 let inner_offset;
3187 let mut inner_depth = depth.clone();
3188 if inlined {
3189 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3190 inner_offset = next_offset;
3191 } else {
3192 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3193 inner_depth.increment()?;
3194 }
3195 let val_ref = self.composite_parents.get_or_insert_with(|| {
3196 fidl::new_empty!(
3197 fidl::encoding::UnboundedVector<
3198 fidl_fuchsia_driver_framework__common::CompositeParent,
3199 >,
3200 D
3201 )
3202 });
3203 fidl::decode!(
3204 fidl::encoding::UnboundedVector<
3205 fidl_fuchsia_driver_framework__common::CompositeParent,
3206 >,
3207 D,
3208 val_ref,
3209 decoder,
3210 inner_offset,
3211 inner_depth
3212 )?;
3213 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3214 {
3215 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3216 }
3217 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3218 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3219 }
3220 }
3221
3222 next_offset += envelope_size;
3223
3224 while next_offset < end_offset {
3226 _next_ordinal_to_read += 1;
3227 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3228 next_offset += envelope_size;
3229 }
3230
3231 Ok(())
3232 }
3233 }
3234
3235 impl NodeInfo {
3236 #[inline(always)]
3237 fn max_ordinal_present(&self) -> u64 {
3238 if let Some(_) = self.bus_topology {
3239 return 11;
3240 }
3241 if let Some(_) = self.quarantined {
3242 return 10;
3243 }
3244 if let Some(_) = self.offer_list {
3245 return 9;
3246 }
3247 if let Some(_) = self.node_property_list {
3248 return 8;
3249 }
3250 if let Some(_) = self.moniker {
3251 return 7;
3252 }
3253 if let Some(_) = self.bound_driver_url {
3254 return 5;
3255 }
3256 if let Some(_) = self.driver_host_koid {
3257 return 4;
3258 }
3259 if let Some(_) = self.child_ids {
3260 return 3;
3261 }
3262 if let Some(_) = self.parent_ids {
3263 return 2;
3264 }
3265 if let Some(_) = self.id {
3266 return 1;
3267 }
3268 0
3269 }
3270 }
3271
3272 impl fidl::encoding::ValueTypeMarker for NodeInfo {
3273 type Borrowed<'a> = &'a Self;
3274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3275 value
3276 }
3277 }
3278
3279 unsafe impl fidl::encoding::TypeMarker for NodeInfo {
3280 type Owned = Self;
3281
3282 #[inline(always)]
3283 fn inline_align(_context: fidl::encoding::Context) -> usize {
3284 8
3285 }
3286
3287 #[inline(always)]
3288 fn inline_size(_context: fidl::encoding::Context) -> usize {
3289 16
3290 }
3291 }
3292
3293 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeInfo, D> for &NodeInfo {
3294 unsafe fn encode(
3295 self,
3296 encoder: &mut fidl::encoding::Encoder<'_, D>,
3297 offset: usize,
3298 mut depth: fidl::encoding::Depth,
3299 ) -> fidl::Result<()> {
3300 encoder.debug_check_bounds::<NodeInfo>(offset);
3301 let max_ordinal: u64 = self.max_ordinal_present();
3303 encoder.write_num(max_ordinal, offset);
3304 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3305 if max_ordinal == 0 {
3307 return Ok(());
3308 }
3309 depth.increment()?;
3310 let envelope_size = 8;
3311 let bytes_len = max_ordinal as usize * envelope_size;
3312 #[allow(unused_variables)]
3313 let offset = encoder.out_of_line_offset(bytes_len);
3314 let mut _prev_end_offset: usize = 0;
3315 if 1 > max_ordinal {
3316 return Ok(());
3317 }
3318
3319 let cur_offset: usize = (1 - 1) * envelope_size;
3322
3323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3325
3326 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3331 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3332 encoder,
3333 offset + cur_offset,
3334 depth,
3335 )?;
3336
3337 _prev_end_offset = cur_offset + envelope_size;
3338 if 2 > max_ordinal {
3339 return Ok(());
3340 }
3341
3342 let cur_offset: usize = (2 - 1) * envelope_size;
3345
3346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3348
3349 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
3354 self.parent_ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
3355 encoder, offset + cur_offset, depth
3356 )?;
3357
3358 _prev_end_offset = cur_offset + envelope_size;
3359 if 3 > max_ordinal {
3360 return Ok(());
3361 }
3362
3363 let cur_offset: usize = (3 - 1) * envelope_size;
3366
3367 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3369
3370 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
3375 self.child_ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
3376 encoder, offset + cur_offset, depth
3377 )?;
3378
3379 _prev_end_offset = cur_offset + envelope_size;
3380 if 4 > max_ordinal {
3381 return Ok(());
3382 }
3383
3384 let cur_offset: usize = (4 - 1) * envelope_size;
3387
3388 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3390
3391 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3396 self.driver_host_koid
3397 .as_ref()
3398 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3399 encoder,
3400 offset + cur_offset,
3401 depth,
3402 )?;
3403
3404 _prev_end_offset = cur_offset + envelope_size;
3405 if 5 > max_ordinal {
3406 return Ok(());
3407 }
3408
3409 let cur_offset: usize = (5 - 1) * envelope_size;
3412
3413 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3415
3416 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3421 self.bound_driver_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3422 encoder, offset + cur_offset, depth
3423 )?;
3424
3425 _prev_end_offset = cur_offset + envelope_size;
3426 if 7 > max_ordinal {
3427 return Ok(());
3428 }
3429
3430 let cur_offset: usize = (7 - 1) * envelope_size;
3433
3434 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3436
3437 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
3442 self.moniker.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
3443 encoder, offset + cur_offset, depth
3444 )?;
3445
3446 _prev_end_offset = cur_offset + envelope_size;
3447 if 8 > max_ordinal {
3448 return Ok(());
3449 }
3450
3451 let cur_offset: usize = (8 - 1) * envelope_size;
3454
3455 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3457
3458 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D>(
3463 self.node_property_list.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3464 encoder, offset + cur_offset, depth
3465 )?;
3466
3467 _prev_end_offset = cur_offset + envelope_size;
3468 if 9 > max_ordinal {
3469 return Ok(());
3470 }
3471
3472 let cur_offset: usize = (9 - 1) * envelope_size;
3475
3476 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3478
3479 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Offer>, D>(
3484 self.offer_list.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Offer> as fidl::encoding::ValueTypeMarker>::borrow),
3485 encoder, offset + cur_offset, depth
3486 )?;
3487
3488 _prev_end_offset = cur_offset + envelope_size;
3489 if 10 > max_ordinal {
3490 return Ok(());
3491 }
3492
3493 let cur_offset: usize = (10 - 1) * envelope_size;
3496
3497 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3499
3500 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3505 self.quarantined.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3506 encoder,
3507 offset + cur_offset,
3508 depth,
3509 )?;
3510
3511 _prev_end_offset = cur_offset + envelope_size;
3512 if 11 > max_ordinal {
3513 return Ok(());
3514 }
3515
3516 let cur_offset: usize = (11 - 1) * envelope_size;
3519
3520 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3522
3523 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::BusInfo, 20>, D>(
3528 self.bus_topology.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::BusInfo, 20> as fidl::encoding::ValueTypeMarker>::borrow),
3529 encoder, offset + cur_offset, depth
3530 )?;
3531
3532 _prev_end_offset = cur_offset + envelope_size;
3533
3534 Ok(())
3535 }
3536 }
3537
3538 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeInfo {
3539 #[inline(always)]
3540 fn new_empty() -> Self {
3541 Self::default()
3542 }
3543
3544 unsafe fn decode(
3545 &mut self,
3546 decoder: &mut fidl::encoding::Decoder<'_, D>,
3547 offset: usize,
3548 mut depth: fidl::encoding::Depth,
3549 ) -> fidl::Result<()> {
3550 decoder.debug_check_bounds::<Self>(offset);
3551 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3552 None => return Err(fidl::Error::NotNullable),
3553 Some(len) => len,
3554 };
3555 if len == 0 {
3557 return Ok(());
3558 };
3559 depth.increment()?;
3560 let envelope_size = 8;
3561 let bytes_len = len * envelope_size;
3562 let offset = decoder.out_of_line_offset(bytes_len)?;
3563 let mut _next_ordinal_to_read = 0;
3565 let mut next_offset = offset;
3566 let end_offset = offset + bytes_len;
3567 _next_ordinal_to_read += 1;
3568 if next_offset >= end_offset {
3569 return Ok(());
3570 }
3571
3572 while _next_ordinal_to_read < 1 {
3574 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3575 _next_ordinal_to_read += 1;
3576 next_offset += envelope_size;
3577 }
3578
3579 let next_out_of_line = decoder.next_out_of_line();
3580 let handles_before = decoder.remaining_handles();
3581 if let Some((inlined, num_bytes, num_handles)) =
3582 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3583 {
3584 let member_inline_size =
3585 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3586 if inlined != (member_inline_size <= 4) {
3587 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3588 }
3589 let inner_offset;
3590 let mut inner_depth = depth.clone();
3591 if inlined {
3592 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3593 inner_offset = next_offset;
3594 } else {
3595 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3596 inner_depth.increment()?;
3597 }
3598 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3599 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3600 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3601 {
3602 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3603 }
3604 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3605 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3606 }
3607 }
3608
3609 next_offset += envelope_size;
3610 _next_ordinal_to_read += 1;
3611 if next_offset >= end_offset {
3612 return Ok(());
3613 }
3614
3615 while _next_ordinal_to_read < 2 {
3617 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3618 _next_ordinal_to_read += 1;
3619 next_offset += envelope_size;
3620 }
3621
3622 let next_out_of_line = decoder.next_out_of_line();
3623 let handles_before = decoder.remaining_handles();
3624 if let Some((inlined, num_bytes, num_handles)) =
3625 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3626 {
3627 let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3628 if inlined != (member_inline_size <= 4) {
3629 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3630 }
3631 let inner_offset;
3632 let mut inner_depth = depth.clone();
3633 if inlined {
3634 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3635 inner_offset = next_offset;
3636 } else {
3637 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3638 inner_depth.increment()?;
3639 }
3640 let val_ref = self.parent_ids.get_or_insert_with(|| {
3641 fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
3642 });
3643 fidl::decode!(
3644 fidl::encoding::UnboundedVector<u64>,
3645 D,
3646 val_ref,
3647 decoder,
3648 inner_offset,
3649 inner_depth
3650 )?;
3651 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3652 {
3653 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3654 }
3655 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3656 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3657 }
3658 }
3659
3660 next_offset += envelope_size;
3661 _next_ordinal_to_read += 1;
3662 if next_offset >= end_offset {
3663 return Ok(());
3664 }
3665
3666 while _next_ordinal_to_read < 3 {
3668 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3669 _next_ordinal_to_read += 1;
3670 next_offset += envelope_size;
3671 }
3672
3673 let next_out_of_line = decoder.next_out_of_line();
3674 let handles_before = decoder.remaining_handles();
3675 if let Some((inlined, num_bytes, num_handles)) =
3676 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3677 {
3678 let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3679 if inlined != (member_inline_size <= 4) {
3680 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3681 }
3682 let inner_offset;
3683 let mut inner_depth = depth.clone();
3684 if inlined {
3685 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3686 inner_offset = next_offset;
3687 } else {
3688 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3689 inner_depth.increment()?;
3690 }
3691 let val_ref = self.child_ids.get_or_insert_with(|| {
3692 fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
3693 });
3694 fidl::decode!(
3695 fidl::encoding::UnboundedVector<u64>,
3696 D,
3697 val_ref,
3698 decoder,
3699 inner_offset,
3700 inner_depth
3701 )?;
3702 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3703 {
3704 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3705 }
3706 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3707 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3708 }
3709 }
3710
3711 next_offset += envelope_size;
3712 _next_ordinal_to_read += 1;
3713 if next_offset >= end_offset {
3714 return Ok(());
3715 }
3716
3717 while _next_ordinal_to_read < 4 {
3719 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3720 _next_ordinal_to_read += 1;
3721 next_offset += envelope_size;
3722 }
3723
3724 let next_out_of_line = decoder.next_out_of_line();
3725 let handles_before = decoder.remaining_handles();
3726 if let Some((inlined, num_bytes, num_handles)) =
3727 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3728 {
3729 let member_inline_size =
3730 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3731 if inlined != (member_inline_size <= 4) {
3732 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3733 }
3734 let inner_offset;
3735 let mut inner_depth = depth.clone();
3736 if inlined {
3737 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3738 inner_offset = next_offset;
3739 } else {
3740 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3741 inner_depth.increment()?;
3742 }
3743 let val_ref = self.driver_host_koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
3744 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3745 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3746 {
3747 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3748 }
3749 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3750 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3751 }
3752 }
3753
3754 next_offset += envelope_size;
3755 _next_ordinal_to_read += 1;
3756 if next_offset >= end_offset {
3757 return Ok(());
3758 }
3759
3760 while _next_ordinal_to_read < 5 {
3762 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3763 _next_ordinal_to_read += 1;
3764 next_offset += envelope_size;
3765 }
3766
3767 let next_out_of_line = decoder.next_out_of_line();
3768 let handles_before = decoder.remaining_handles();
3769 if let Some((inlined, num_bytes, num_handles)) =
3770 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3771 {
3772 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3773 if inlined != (member_inline_size <= 4) {
3774 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3775 }
3776 let inner_offset;
3777 let mut inner_depth = depth.clone();
3778 if inlined {
3779 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3780 inner_offset = next_offset;
3781 } else {
3782 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3783 inner_depth.increment()?;
3784 }
3785 let val_ref = self.bound_driver_url.get_or_insert_with(|| {
3786 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3787 });
3788 fidl::decode!(
3789 fidl::encoding::BoundedString<4096>,
3790 D,
3791 val_ref,
3792 decoder,
3793 inner_offset,
3794 inner_depth
3795 )?;
3796 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3797 {
3798 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3799 }
3800 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3801 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3802 }
3803 }
3804
3805 next_offset += envelope_size;
3806 _next_ordinal_to_read += 1;
3807 if next_offset >= end_offset {
3808 return Ok(());
3809 }
3810
3811 while _next_ordinal_to_read < 7 {
3813 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3814 _next_ordinal_to_read += 1;
3815 next_offset += envelope_size;
3816 }
3817
3818 let next_out_of_line = decoder.next_out_of_line();
3819 let handles_before = decoder.remaining_handles();
3820 if let Some((inlined, num_bytes, num_handles)) =
3821 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3822 {
3823 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3824 if inlined != (member_inline_size <= 4) {
3825 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3826 }
3827 let inner_offset;
3828 let mut inner_depth = depth.clone();
3829 if inlined {
3830 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3831 inner_offset = next_offset;
3832 } else {
3833 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3834 inner_depth.increment()?;
3835 }
3836 let val_ref = self.moniker.get_or_insert_with(|| {
3837 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
3838 });
3839 fidl::decode!(
3840 fidl::encoding::BoundedString<1024>,
3841 D,
3842 val_ref,
3843 decoder,
3844 inner_offset,
3845 inner_depth
3846 )?;
3847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848 {
3849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850 }
3851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853 }
3854 }
3855
3856 next_offset += envelope_size;
3857 _next_ordinal_to_read += 1;
3858 if next_offset >= end_offset {
3859 return Ok(());
3860 }
3861
3862 while _next_ordinal_to_read < 8 {
3864 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3865 _next_ordinal_to_read += 1;
3866 next_offset += envelope_size;
3867 }
3868
3869 let next_out_of_line = decoder.next_out_of_line();
3870 let handles_before = decoder.remaining_handles();
3871 if let Some((inlined, num_bytes, num_handles)) =
3872 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3873 {
3874 let member_inline_size = <fidl::encoding::Vector<
3875 fidl_fuchsia_driver_framework__common::NodeProperty,
3876 64,
3877 > as fidl::encoding::TypeMarker>::inline_size(
3878 decoder.context
3879 );
3880 if inlined != (member_inline_size <= 4) {
3881 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3882 }
3883 let inner_offset;
3884 let mut inner_depth = depth.clone();
3885 if inlined {
3886 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3887 inner_offset = next_offset;
3888 } else {
3889 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3890 inner_depth.increment()?;
3891 }
3892 let val_ref =
3893 self.node_property_list.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D));
3894 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3895 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3896 {
3897 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3898 }
3899 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3900 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3901 }
3902 }
3903
3904 next_offset += envelope_size;
3905 _next_ordinal_to_read += 1;
3906 if next_offset >= end_offset {
3907 return Ok(());
3908 }
3909
3910 while _next_ordinal_to_read < 9 {
3912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3913 _next_ordinal_to_read += 1;
3914 next_offset += envelope_size;
3915 }
3916
3917 let next_out_of_line = decoder.next_out_of_line();
3918 let handles_before = decoder.remaining_handles();
3919 if let Some((inlined, num_bytes, num_handles)) =
3920 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3921 {
3922 let member_inline_size = <fidl::encoding::UnboundedVector<
3923 fidl_fuchsia_component_decl__common::Offer,
3924 > as fidl::encoding::TypeMarker>::inline_size(
3925 decoder.context
3926 );
3927 if inlined != (member_inline_size <= 4) {
3928 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3929 }
3930 let inner_offset;
3931 let mut inner_depth = depth.clone();
3932 if inlined {
3933 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3934 inner_offset = next_offset;
3935 } else {
3936 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3937 inner_depth.increment()?;
3938 }
3939 let val_ref = self.offer_list.get_or_insert_with(|| {
3940 fidl::new_empty!(
3941 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Offer>,
3942 D
3943 )
3944 });
3945 fidl::decode!(
3946 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Offer>,
3947 D,
3948 val_ref,
3949 decoder,
3950 inner_offset,
3951 inner_depth
3952 )?;
3953 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3954 {
3955 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3956 }
3957 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3958 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3959 }
3960 }
3961
3962 next_offset += envelope_size;
3963 _next_ordinal_to_read += 1;
3964 if next_offset >= end_offset {
3965 return Ok(());
3966 }
3967
3968 while _next_ordinal_to_read < 10 {
3970 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3971 _next_ordinal_to_read += 1;
3972 next_offset += envelope_size;
3973 }
3974
3975 let next_out_of_line = decoder.next_out_of_line();
3976 let handles_before = decoder.remaining_handles();
3977 if let Some((inlined, num_bytes, num_handles)) =
3978 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3979 {
3980 let member_inline_size =
3981 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3982 if inlined != (member_inline_size <= 4) {
3983 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3984 }
3985 let inner_offset;
3986 let mut inner_depth = depth.clone();
3987 if inlined {
3988 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3989 inner_offset = next_offset;
3990 } else {
3991 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3992 inner_depth.increment()?;
3993 }
3994 let val_ref = self.quarantined.get_or_insert_with(|| fidl::new_empty!(bool, D));
3995 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3996 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3997 {
3998 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3999 }
4000 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4001 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4002 }
4003 }
4004
4005 next_offset += envelope_size;
4006 _next_ordinal_to_read += 1;
4007 if next_offset >= end_offset {
4008 return Ok(());
4009 }
4010
4011 while _next_ordinal_to_read < 11 {
4013 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4014 _next_ordinal_to_read += 1;
4015 next_offset += envelope_size;
4016 }
4017
4018 let next_out_of_line = decoder.next_out_of_line();
4019 let handles_before = decoder.remaining_handles();
4020 if let Some((inlined, num_bytes, num_handles)) =
4021 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4022 {
4023 let member_inline_size = <fidl::encoding::Vector<
4024 fidl_fuchsia_driver_framework__common::BusInfo,
4025 20,
4026 > as fidl::encoding::TypeMarker>::inline_size(
4027 decoder.context
4028 );
4029 if inlined != (member_inline_size <= 4) {
4030 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4031 }
4032 let inner_offset;
4033 let mut inner_depth = depth.clone();
4034 if inlined {
4035 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4036 inner_offset = next_offset;
4037 } else {
4038 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4039 inner_depth.increment()?;
4040 }
4041 let val_ref =
4042 self.bus_topology.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::BusInfo, 20>, D));
4043 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::BusInfo, 20>, D, val_ref, decoder, inner_offset, inner_depth)?;
4044 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4045 {
4046 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4047 }
4048 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4049 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4050 }
4051 }
4052
4053 next_offset += envelope_size;
4054
4055 while next_offset < end_offset {
4057 _next_ordinal_to_read += 1;
4058 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4059 next_offset += envelope_size;
4060 }
4061
4062 Ok(())
4063 }
4064 }
4065
4066 impl TestNodeAddArgs {
4067 #[inline(always)]
4068 fn max_ordinal_present(&self) -> u64 {
4069 if let Some(_) = self.properties {
4070 return 2;
4071 }
4072 if let Some(_) = self.name {
4073 return 1;
4074 }
4075 0
4076 }
4077 }
4078
4079 impl fidl::encoding::ValueTypeMarker for TestNodeAddArgs {
4080 type Borrowed<'a> = &'a Self;
4081 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4082 value
4083 }
4084 }
4085
4086 unsafe impl fidl::encoding::TypeMarker for TestNodeAddArgs {
4087 type Owned = Self;
4088
4089 #[inline(always)]
4090 fn inline_align(_context: fidl::encoding::Context) -> usize {
4091 8
4092 }
4093
4094 #[inline(always)]
4095 fn inline_size(_context: fidl::encoding::Context) -> usize {
4096 16
4097 }
4098 }
4099
4100 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TestNodeAddArgs, D>
4101 for &TestNodeAddArgs
4102 {
4103 unsafe fn encode(
4104 self,
4105 encoder: &mut fidl::encoding::Encoder<'_, D>,
4106 offset: usize,
4107 mut depth: fidl::encoding::Depth,
4108 ) -> fidl::Result<()> {
4109 encoder.debug_check_bounds::<TestNodeAddArgs>(offset);
4110 let max_ordinal: u64 = self.max_ordinal_present();
4112 encoder.write_num(max_ordinal, offset);
4113 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4114 if max_ordinal == 0 {
4116 return Ok(());
4117 }
4118 depth.increment()?;
4119 let envelope_size = 8;
4120 let bytes_len = max_ordinal as usize * envelope_size;
4121 #[allow(unused_variables)]
4122 let offset = encoder.out_of_line_offset(bytes_len);
4123 let mut _prev_end_offset: usize = 0;
4124 if 1 > max_ordinal {
4125 return Ok(());
4126 }
4127
4128 let cur_offset: usize = (1 - 1) * envelope_size;
4131
4132 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4134
4135 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4140 self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4141 encoder, offset + cur_offset, depth
4142 )?;
4143
4144 _prev_end_offset = cur_offset + envelope_size;
4145 if 2 > max_ordinal {
4146 return Ok(());
4147 }
4148
4149 let cur_offset: usize = (2 - 1) * envelope_size;
4152
4153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4155
4156 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D>(
4161 self.properties.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow),
4162 encoder, offset + cur_offset, depth
4163 )?;
4164
4165 _prev_end_offset = cur_offset + envelope_size;
4166
4167 Ok(())
4168 }
4169 }
4170
4171 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestNodeAddArgs {
4172 #[inline(always)]
4173 fn new_empty() -> Self {
4174 Self::default()
4175 }
4176
4177 unsafe fn decode(
4178 &mut self,
4179 decoder: &mut fidl::encoding::Decoder<'_, D>,
4180 offset: usize,
4181 mut depth: fidl::encoding::Depth,
4182 ) -> fidl::Result<()> {
4183 decoder.debug_check_bounds::<Self>(offset);
4184 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4185 None => return Err(fidl::Error::NotNullable),
4186 Some(len) => len,
4187 };
4188 if len == 0 {
4190 return Ok(());
4191 };
4192 depth.increment()?;
4193 let envelope_size = 8;
4194 let bytes_len = len * envelope_size;
4195 let offset = decoder.out_of_line_offset(bytes_len)?;
4196 let mut _next_ordinal_to_read = 0;
4198 let mut next_offset = offset;
4199 let end_offset = offset + bytes_len;
4200 _next_ordinal_to_read += 1;
4201 if next_offset >= end_offset {
4202 return Ok(());
4203 }
4204
4205 while _next_ordinal_to_read < 1 {
4207 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4208 _next_ordinal_to_read += 1;
4209 next_offset += envelope_size;
4210 }
4211
4212 let next_out_of_line = decoder.next_out_of_line();
4213 let handles_before = decoder.remaining_handles();
4214 if let Some((inlined, num_bytes, num_handles)) =
4215 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4216 {
4217 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4218 if inlined != (member_inline_size <= 4) {
4219 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4220 }
4221 let inner_offset;
4222 let mut inner_depth = depth.clone();
4223 if inlined {
4224 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4225 inner_offset = next_offset;
4226 } else {
4227 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4228 inner_depth.increment()?;
4229 }
4230 let val_ref = self.name.get_or_insert_with(|| {
4231 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4232 });
4233 fidl::decode!(
4234 fidl::encoding::BoundedString<1024>,
4235 D,
4236 val_ref,
4237 decoder,
4238 inner_offset,
4239 inner_depth
4240 )?;
4241 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4242 {
4243 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4244 }
4245 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4246 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4247 }
4248 }
4249
4250 next_offset += envelope_size;
4251 _next_ordinal_to_read += 1;
4252 if next_offset >= end_offset {
4253 return Ok(());
4254 }
4255
4256 while _next_ordinal_to_read < 2 {
4258 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4259 _next_ordinal_to_read += 1;
4260 next_offset += envelope_size;
4261 }
4262
4263 let next_out_of_line = decoder.next_out_of_line();
4264 let handles_before = decoder.remaining_handles();
4265 if let Some((inlined, num_bytes, num_handles)) =
4266 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4267 {
4268 let member_inline_size = <fidl::encoding::Vector<
4269 fidl_fuchsia_driver_framework__common::NodeProperty,
4270 64,
4271 > as fidl::encoding::TypeMarker>::inline_size(
4272 decoder.context
4273 );
4274 if inlined != (member_inline_size <= 4) {
4275 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4276 }
4277 let inner_offset;
4278 let mut inner_depth = depth.clone();
4279 if inlined {
4280 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4281 inner_offset = next_offset;
4282 } else {
4283 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4284 inner_depth.increment()?;
4285 }
4286 let val_ref =
4287 self.properties.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D));
4288 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4289 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4290 {
4291 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4292 }
4293 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4294 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4295 }
4296 }
4297
4298 next_offset += envelope_size;
4299
4300 while next_offset < end_offset {
4302 _next_ordinal_to_read += 1;
4303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4304 next_offset += envelope_size;
4305 }
4306
4307 Ok(())
4308 }
4309 }
4310
4311 impl ThreadInfo {
4312 #[inline(always)]
4313 fn max_ordinal_present(&self) -> u64 {
4314 if let Some(_) = self.scheduler_role {
4315 return 3;
4316 }
4317 if let Some(_) = self.name {
4318 return 2;
4319 }
4320 if let Some(_) = self.koid {
4321 return 1;
4322 }
4323 0
4324 }
4325 }
4326
4327 impl fidl::encoding::ValueTypeMarker for ThreadInfo {
4328 type Borrowed<'a> = &'a Self;
4329 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4330 value
4331 }
4332 }
4333
4334 unsafe impl fidl::encoding::TypeMarker for ThreadInfo {
4335 type Owned = Self;
4336
4337 #[inline(always)]
4338 fn inline_align(_context: fidl::encoding::Context) -> usize {
4339 8
4340 }
4341
4342 #[inline(always)]
4343 fn inline_size(_context: fidl::encoding::Context) -> usize {
4344 16
4345 }
4346 }
4347
4348 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ThreadInfo, D>
4349 for &ThreadInfo
4350 {
4351 unsafe fn encode(
4352 self,
4353 encoder: &mut fidl::encoding::Encoder<'_, D>,
4354 offset: usize,
4355 mut depth: fidl::encoding::Depth,
4356 ) -> fidl::Result<()> {
4357 encoder.debug_check_bounds::<ThreadInfo>(offset);
4358 let max_ordinal: u64 = self.max_ordinal_present();
4360 encoder.write_num(max_ordinal, offset);
4361 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4362 if max_ordinal == 0 {
4364 return Ok(());
4365 }
4366 depth.increment()?;
4367 let envelope_size = 8;
4368 let bytes_len = max_ordinal as usize * envelope_size;
4369 #[allow(unused_variables)]
4370 let offset = encoder.out_of_line_offset(bytes_len);
4371 let mut _prev_end_offset: usize = 0;
4372 if 1 > max_ordinal {
4373 return Ok(());
4374 }
4375
4376 let cur_offset: usize = (1 - 1) * envelope_size;
4379
4380 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4382
4383 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4388 self.koid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4389 encoder,
4390 offset + cur_offset,
4391 depth,
4392 )?;
4393
4394 _prev_end_offset = cur_offset + envelope_size;
4395 if 2 > max_ordinal {
4396 return Ok(());
4397 }
4398
4399 let cur_offset: usize = (2 - 1) * envelope_size;
4402
4403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4405
4406 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4411 self.name.as_ref().map(
4412 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4413 ),
4414 encoder,
4415 offset + cur_offset,
4416 depth,
4417 )?;
4418
4419 _prev_end_offset = cur_offset + envelope_size;
4420 if 3 > max_ordinal {
4421 return Ok(());
4422 }
4423
4424 let cur_offset: usize = (3 - 1) * envelope_size;
4427
4428 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4430
4431 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4436 self.scheduler_role.as_ref().map(
4437 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4438 ),
4439 encoder,
4440 offset + cur_offset,
4441 depth,
4442 )?;
4443
4444 _prev_end_offset = cur_offset + envelope_size;
4445
4446 Ok(())
4447 }
4448 }
4449
4450 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ThreadInfo {
4451 #[inline(always)]
4452 fn new_empty() -> Self {
4453 Self::default()
4454 }
4455
4456 unsafe fn decode(
4457 &mut self,
4458 decoder: &mut fidl::encoding::Decoder<'_, D>,
4459 offset: usize,
4460 mut depth: fidl::encoding::Depth,
4461 ) -> fidl::Result<()> {
4462 decoder.debug_check_bounds::<Self>(offset);
4463 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4464 None => return Err(fidl::Error::NotNullable),
4465 Some(len) => len,
4466 };
4467 if len == 0 {
4469 return Ok(());
4470 };
4471 depth.increment()?;
4472 let envelope_size = 8;
4473 let bytes_len = len * envelope_size;
4474 let offset = decoder.out_of_line_offset(bytes_len)?;
4475 let mut _next_ordinal_to_read = 0;
4477 let mut next_offset = offset;
4478 let end_offset = offset + bytes_len;
4479 _next_ordinal_to_read += 1;
4480 if next_offset >= end_offset {
4481 return Ok(());
4482 }
4483
4484 while _next_ordinal_to_read < 1 {
4486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4487 _next_ordinal_to_read += 1;
4488 next_offset += envelope_size;
4489 }
4490
4491 let next_out_of_line = decoder.next_out_of_line();
4492 let handles_before = decoder.remaining_handles();
4493 if let Some((inlined, num_bytes, num_handles)) =
4494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4495 {
4496 let member_inline_size =
4497 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4498 if inlined != (member_inline_size <= 4) {
4499 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4500 }
4501 let inner_offset;
4502 let mut inner_depth = depth.clone();
4503 if inlined {
4504 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4505 inner_offset = next_offset;
4506 } else {
4507 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4508 inner_depth.increment()?;
4509 }
4510 let val_ref = self.koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
4511 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4512 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4513 {
4514 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4515 }
4516 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4517 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4518 }
4519 }
4520
4521 next_offset += envelope_size;
4522 _next_ordinal_to_read += 1;
4523 if next_offset >= end_offset {
4524 return Ok(());
4525 }
4526
4527 while _next_ordinal_to_read < 2 {
4529 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4530 _next_ordinal_to_read += 1;
4531 next_offset += envelope_size;
4532 }
4533
4534 let next_out_of_line = decoder.next_out_of_line();
4535 let handles_before = decoder.remaining_handles();
4536 if let Some((inlined, num_bytes, num_handles)) =
4537 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4538 {
4539 let member_inline_size =
4540 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4541 decoder.context,
4542 );
4543 if inlined != (member_inline_size <= 4) {
4544 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4545 }
4546 let inner_offset;
4547 let mut inner_depth = depth.clone();
4548 if inlined {
4549 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4550 inner_offset = next_offset;
4551 } else {
4552 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4553 inner_depth.increment()?;
4554 }
4555 let val_ref = self
4556 .name
4557 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4558 fidl::decode!(
4559 fidl::encoding::UnboundedString,
4560 D,
4561 val_ref,
4562 decoder,
4563 inner_offset,
4564 inner_depth
4565 )?;
4566 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4567 {
4568 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4569 }
4570 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4571 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4572 }
4573 }
4574
4575 next_offset += envelope_size;
4576 _next_ordinal_to_read += 1;
4577 if next_offset >= end_offset {
4578 return Ok(());
4579 }
4580
4581 while _next_ordinal_to_read < 3 {
4583 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4584 _next_ordinal_to_read += 1;
4585 next_offset += envelope_size;
4586 }
4587
4588 let next_out_of_line = decoder.next_out_of_line();
4589 let handles_before = decoder.remaining_handles();
4590 if let Some((inlined, num_bytes, num_handles)) =
4591 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4592 {
4593 let member_inline_size =
4594 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4595 decoder.context,
4596 );
4597 if inlined != (member_inline_size <= 4) {
4598 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4599 }
4600 let inner_offset;
4601 let mut inner_depth = depth.clone();
4602 if inlined {
4603 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4604 inner_offset = next_offset;
4605 } else {
4606 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4607 inner_depth.increment()?;
4608 }
4609 let val_ref = self
4610 .scheduler_role
4611 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4612 fidl::decode!(
4613 fidl::encoding::UnboundedString,
4614 D,
4615 val_ref,
4616 decoder,
4617 inner_offset,
4618 inner_depth
4619 )?;
4620 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4621 {
4622 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4623 }
4624 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4625 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4626 }
4627 }
4628
4629 next_offset += envelope_size;
4630
4631 while next_offset < end_offset {
4633 _next_ordinal_to_read += 1;
4634 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4635 next_offset += envelope_size;
4636 }
4637
4638 Ok(())
4639 }
4640 }
4641
4642 impl fidl::encoding::ValueTypeMarker for CompositeInfo {
4643 type Borrowed<'a> = &'a Self;
4644 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4645 value
4646 }
4647 }
4648
4649 unsafe impl fidl::encoding::TypeMarker for CompositeInfo {
4650 type Owned = Self;
4651
4652 #[inline(always)]
4653 fn inline_align(_context: fidl::encoding::Context) -> usize {
4654 8
4655 }
4656
4657 #[inline(always)]
4658 fn inline_size(_context: fidl::encoding::Context) -> usize {
4659 16
4660 }
4661 }
4662
4663 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeInfo, D>
4664 for &CompositeInfo
4665 {
4666 #[inline]
4667 unsafe fn encode(
4668 self,
4669 encoder: &mut fidl::encoding::Encoder<'_, D>,
4670 offset: usize,
4671 _depth: fidl::encoding::Depth,
4672 ) -> fidl::Result<()> {
4673 encoder.debug_check_bounds::<CompositeInfo>(offset);
4674 encoder.write_num::<u64>(self.ordinal(), offset);
4675 match self {
4676 CompositeInfo::Composite(ref val) => {
4677 fidl::encoding::encode_in_envelope::<fidl_fuchsia_driver_framework__common::CompositeInfo, D>(
4678 <fidl_fuchsia_driver_framework__common::CompositeInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
4679 encoder, offset + 8, _depth
4680 )
4681 }
4682 }
4683 }
4684 }
4685
4686 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeInfo {
4687 #[inline(always)]
4688 fn new_empty() -> Self {
4689 Self::Composite(fidl::new_empty!(
4690 fidl_fuchsia_driver_framework__common::CompositeInfo,
4691 D
4692 ))
4693 }
4694
4695 #[inline]
4696 unsafe fn decode(
4697 &mut self,
4698 decoder: &mut fidl::encoding::Decoder<'_, D>,
4699 offset: usize,
4700 mut depth: fidl::encoding::Depth,
4701 ) -> fidl::Result<()> {
4702 decoder.debug_check_bounds::<Self>(offset);
4703 #[allow(unused_variables)]
4704 let next_out_of_line = decoder.next_out_of_line();
4705 let handles_before = decoder.remaining_handles();
4706 let (ordinal, inlined, num_bytes, num_handles) =
4707 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4708
4709 let member_inline_size = match ordinal {
4710 2 => <fidl_fuchsia_driver_framework__common::CompositeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4711 _ => return Err(fidl::Error::UnknownUnionTag),
4712 };
4713
4714 if inlined != (member_inline_size <= 4) {
4715 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4716 }
4717 let _inner_offset;
4718 if inlined {
4719 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4720 _inner_offset = offset + 8;
4721 } else {
4722 depth.increment()?;
4723 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4724 }
4725 match ordinal {
4726 2 => {
4727 #[allow(irrefutable_let_patterns)]
4728 if let CompositeInfo::Composite(_) = self {
4729 } else {
4731 *self = CompositeInfo::Composite(fidl::new_empty!(
4733 fidl_fuchsia_driver_framework__common::CompositeInfo,
4734 D
4735 ));
4736 }
4737 #[allow(irrefutable_let_patterns)]
4738 if let CompositeInfo::Composite(ref mut val) = self {
4739 fidl::decode!(
4740 fidl_fuchsia_driver_framework__common::CompositeInfo,
4741 D,
4742 val,
4743 decoder,
4744 _inner_offset,
4745 depth
4746 )?;
4747 } else {
4748 unreachable!()
4749 }
4750 }
4751 ordinal => panic!("unexpected ordinal {:?}", ordinal),
4752 }
4753 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4754 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4755 }
4756 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4757 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4758 }
4759 Ok(())
4760 }
4761 }
4762}