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