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