fidl_fuchsia_driver_development__common/
fidl_fuchsia_driver_development__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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    /// These flags indicate when a |fuchsia.driver.index.DriverIndex::MatchDriver| call should be
21    /// made for a node that is restarting in order to find a new driver, instead of reusing the driver
22    /// that was previously bound to the node.
23    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
24    pub struct RestartRematchFlags: u32 {
25        /// Rematch nodes that are currently bound to the requested driver. The requested driver is
26        /// the driver url that the restart operation was initiated for.
27        const REQUESTED = 1;
28        /// Rematch nodes that are currently bound to a driver other than the requested driver. These
29        /// are nodes that are affected by the restart of the requested driver, for example when
30        /// it is a colocated parent.
31        const NON_REQUESTED = 2;
32        /// Rematch nodes that are created as part of a completed composite spec.
33        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    /// List of new bindings that happened as a result of this.
130    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/// Contains information for a composite node.
159#[derive(Clone, Debug, Default, PartialEq)]
160pub struct CompositeNodeInfo {
161    /// The topological paths of the parent nodes of this composite, ordered by index.
162    pub parent_topological_paths: Option<Vec<Option<String>>>,
163    /// The topological path of the created composite node. Empty if not created.
164    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/// Contains information for a dispatcher.
173#[derive(Clone, Debug, Default, PartialEq)]
174pub struct DispatcherInfo {
175    /// The driver which created this dispatcher.
176    pub driver: Option<String>,
177    /// The name of the dispatcher.
178    pub name: Option<String>,
179    /// The options the dispatcher was created with.
180    pub options: Option<u32>,
181    /// The scheduler role of the dispatcher.
182    pub scheduler_role: Option<String>,
183    #[doc(hidden)]
184    pub __source_breaking: fidl::marker::SourceBreaking,
185}
186
187impl fidl::Persistable for DispatcherInfo {}
188
189/// Contains information for a driver host.
190#[derive(Clone, Debug, Default, PartialEq)]
191pub struct DriverHostInfo {
192    /// The process KOID of the driver host.
193    pub process_koid: Option<u64>,
194    /// The list of threads of the driver host.
195    pub threads: Option<Vec<ThreadInfo>>,
196    /// List of drivers loaded into this driver host.
197    pub drivers: Option<Vec<String>>,
198    /// List of dispatchers .
199    pub dispatchers: Option<Vec<DispatcherInfo>>,
200    #[doc(hidden)]
201    pub __source_breaking: fidl::marker::SourceBreaking,
202}
203
204impl fidl::Persistable for DriverHostInfo {}
205
206/// Information about a node binding to either a driver or a composite.
207#[derive(Clone, Debug, Default, PartialEq)]
208pub struct NodeBindingInfo {
209    /// Full topological name of the node.
210    pub node_name: Option<String>,
211    /// This is the component url for the driver that bound to the node.
212    /// If this is present, then |composite_parents| must not be.
213    pub driver_url: Option<String>,
214    /// The composite parents that this node binded to.
215    /// If this is present, then |driver_url| must not be.
216    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    /// Unique ID identifying the node.
226    pub id: Option<u64>,
227    /// List of ids representing parents. If more than one, this is a composite node.
228    pub parent_ids: Option<Vec<u64>>,
229    /// List of ids representing children.
230    pub child_ids: Option<Vec<u64>>,
231    /// The process KOID of the driver host the driver resides within.
232    pub driver_host_koid: Option<u64>,
233    /// URL to the driver component manifest
234    pub bound_driver_url: Option<String>,
235    /// The collection-relative moniker of the node.
236    pub moniker: Option<String>,
237    /// Properties of the node.
238    pub node_property_list: Option<Vec<fidl_fuchsia_driver_framework__common::NodeProperty>>,
239    /// Component offers to the node.
240    pub offer_list: Option<Vec<fidl_fuchsia_component_decl__common::Offer>>,
241    /// Whether the node is in a quarantined state. That is, the |bound_driver_url| has failed to
242    /// start, and the node is no longer running its driver instance.
243    pub quarantined: Option<bool>,
244    /// Information about the node's bus topology.
245    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    /// Name of the node.
255    pub name: Option<String>,
256    /// Properties of the node.
257    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/// Contains information for a thread.
265#[derive(Clone, Debug, Default, PartialEq)]
266pub struct ThreadInfo {
267    /// The koid for the thread.
268    pub koid: Option<u64>,
269    /// The name of the thread.
270    pub name: Option<String>,
271    /// The scheduler role of the thread.
272    pub scheduler_role: Option<String>,
273    #[doc(hidden)]
274    pub __source_breaking: fidl::marker::SourceBreaking,
275}
276
277impl fidl::Persistable for ThreadInfo {}
278
279/// Contains information for a composite.
280#[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            // Delegate to tuple encoding.
427            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            // Zero out padding regions. There's no need to apply masks
449            // because the unmasked parts will be overwritten by fields.
450            // Write the fields.
451            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            // Verify that padding bytes are zero.
475            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            // Delegate to tuple encoding.
521            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            // Zero out padding regions. There's no need to apply masks
550            // because the unmasked parts will be overwritten by fields.
551            // Write the fields.
552            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            // Verify that padding bytes are zero.
581            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            // Delegate to tuple encoding.
629            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            // Zero out padding regions. There's no need to apply masks
651            // because the unmasked parts will be overwritten by fields.
652            // Write the fields.
653            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            // Verify that padding bytes are zero.
677            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            // Delegate to tuple encoding.
723            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            // Zero out padding regions. There's no need to apply masks
750            // because the unmasked parts will be overwritten by fields.
751            // Write the fields.
752            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            // Verify that padding bytes are zero.
781            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            // Delegate to tuple encoding.
826            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            // Zero out padding regions. There's no need to apply masks
846            // because the unmasked parts will be overwritten by fields.
847            // Write the fields.
848            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            // Verify that padding bytes are zero.
870            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            // Delegate to tuple encoding.
908            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            // Zero out padding regions. There's no need to apply masks
932            // because the unmasked parts will be overwritten by fields.
933            // Write the fields.
934            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            // Verify that padding bytes are zero.
963            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            // Delegate to tuple encoding.
1016            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            // Zero out padding regions. There's no need to apply masks
1040            // because the unmasked parts will be overwritten by fields.
1041            // Write the fields.
1042            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            // Verify that padding bytes are zero.
1071            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            // Delegate to tuple encoding.
1125            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            // Zero out padding regions. There's no need to apply masks
1149            // because the unmasked parts will be overwritten by fields.
1150            // Write the fields.
1151            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            // Verify that padding bytes are zero.
1173            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            // Delegate to tuple encoding.
1218            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            // Zero out padding regions. There's no need to apply masks
1242            // because the unmasked parts will be overwritten by fields.
1243            // Write the fields.
1244            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            // Verify that padding bytes are zero.
1266            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            // Delegate to tuple encoding.
1312            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            // Zero out padding regions. There's no need to apply masks
1336            // because the unmasked parts will be overwritten by fields.
1337            unsafe {
1338                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1339                (ptr as *mut u64).write_unaligned(0);
1340            }
1341            // Write the fields.
1342            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            // Verify that padding bytes are zero.
1368            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            // Delegate to tuple encoding.
1431            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            // Zero out padding regions. There's no need to apply masks
1453            // because the unmasked parts will be overwritten by fields.
1454            // Write the fields.
1455            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            // Verify that padding bytes are zero.
1479            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                // Copy the object into the buffer.
1528                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1533                // done second because the memcpy will write garbage to these bytes.
1534            }
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            // Zero out padding regions. There's no need to apply masks
1550            // because the unmasked parts will be overwritten by fields.
1551            // Write the fields.
1552            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            // Verify that padding bytes are zero.
1575            // Copy from the buffer into the object.
1576            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                // Copy the object into the buffer.
1627                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1631                // done second because the memcpy will write garbage to these bytes.
1632            }
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            // Zero out padding regions. There's no need to apply masks
1648            // because the unmasked parts will be overwritten by fields.
1649            // Write the fields.
1650            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            // Verify that padding bytes are zero.
1673            // Copy from the buffer into the object.
1674            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            // Delegate to tuple encoding.
1715            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            // Zero out padding regions. There's no need to apply masks
1737            // because the unmasked parts will be overwritten by fields.
1738            // Write the fields.
1739            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            // Verify that padding bytes are zero.
1761            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            // Vector header
1821            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1825            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1839            // are envelope_size bytes.
1840            let cur_offset: usize = (1 - 1) * envelope_size;
1841
1842            // Zero reserved fields.
1843            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1844
1845            // Safety:
1846            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1847            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1848            //   envelope_size bytes, there is always sufficient room.
1849            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1871            // are envelope_size bytes.
1872            let cur_offset: usize = (2 - 1) * envelope_size;
1873
1874            // Zero reserved fields.
1875            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1876
1877            // Safety:
1878            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1879            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1880            //   envelope_size bytes, there is always sufficient room.
1881            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1896            // are envelope_size bytes.
1897            let cur_offset: usize = (3 - 1) * envelope_size;
1898
1899            // Zero reserved fields.
1900            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1901
1902            // Safety:
1903            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1904            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1905            //   envelope_size bytes, there is always sufficient room.
1906            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1939            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            // Decode the envelope for each type.
1947            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            // Decode unknown envelopes for gaps in ordinals.
1956            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            // Decode unknown envelopes for gaps in ordinals.
2018            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            // Decode unknown envelopes for gaps in ordinals.
2072            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            // Decode the remaining unknown envelopes.
2112            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            // Vector header
2173            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2177            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2191            // are envelope_size bytes.
2192            let cur_offset: usize = (1 - 1) * envelope_size;
2193
2194            // Zero reserved fields.
2195            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2196
2197            // Safety:
2198            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2199            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2200            //   envelope_size bytes, there is always sufficient room.
2201            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2212            // are envelope_size bytes.
2213            let cur_offset: usize = (2 - 1) * envelope_size;
2214
2215            // Zero reserved fields.
2216            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2217
2218            // Safety:
2219            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2220            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2221            //   envelope_size bytes, there is always sufficient room.
2222            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2237            // are envelope_size bytes.
2238            let cur_offset: usize = (3 - 1) * envelope_size;
2239
2240            // Zero reserved fields.
2241            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2242
2243            // Safety:
2244            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2245            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2246            //   envelope_size bytes, there is always sufficient room.
2247            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2260            // are envelope_size bytes.
2261            let cur_offset: usize = (4 - 1) * envelope_size;
2262
2263            // Zero reserved fields.
2264            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2265
2266            // Safety:
2267            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2268            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2269            //   envelope_size bytes, there is always sufficient room.
2270            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2303            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            // Decode the envelope for each type.
2311            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            // Decode unknown envelopes for gaps in ordinals.
2320            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            // Decode unknown envelopes for gaps in ordinals.
2371            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            // Decode unknown envelopes for gaps in ordinals.
2425            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            // Decode unknown envelopes for gaps in ordinals.
2468            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            // Decode the remaining unknown envelopes.
2518            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            // Vector header
2579            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2583            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2597            // are envelope_size bytes.
2598            let cur_offset: usize = (1 - 1) * envelope_size;
2599
2600            // Zero reserved fields.
2601            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2602
2603            // Safety:
2604            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2605            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2606            //   envelope_size bytes, there is always sufficient room.
2607            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2620            // are envelope_size bytes.
2621            let cur_offset: usize = (2 - 1) * envelope_size;
2622
2623            // Zero reserved fields.
2624            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2625
2626            // Safety:
2627            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2628            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2629            //   envelope_size bytes, there is always sufficient room.
2630            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2641            // are envelope_size bytes.
2642            let cur_offset: usize = (3 - 1) * envelope_size;
2643
2644            // Zero reserved fields.
2645            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2646
2647            // Safety:
2648            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2649            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2650            //   envelope_size bytes, there is always sufficient room.
2651            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2662            // are envelope_size bytes.
2663            let cur_offset: usize = (4 - 1) * envelope_size;
2664
2665            // Zero reserved fields.
2666            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2667
2668            // Safety:
2669            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2670            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2671            //   envelope_size bytes, there is always sufficient room.
2672            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2701            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            // Decode the envelope for each type.
2709            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            // Decode unknown envelopes for gaps in ordinals.
2718            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            // Decode unknown envelopes for gaps in ordinals.
2761            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            // Decode unknown envelopes for gaps in ordinals.
2812            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            // Decode unknown envelopes for gaps in ordinals.
2870            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            // Decode the remaining unknown envelopes.
2917            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            // Vector header
2975            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2979            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2993            // are envelope_size bytes.
2994            let cur_offset: usize = (1 - 1) * envelope_size;
2995
2996            // Zero reserved fields.
2997            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2998
2999            // Safety:
3000            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3001            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3002            //   envelope_size bytes, there is always sufficient room.
3003            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3014            // are envelope_size bytes.
3015            let cur_offset: usize = (2 - 1) * envelope_size;
3016
3017            // Zero reserved fields.
3018            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3019
3020            // Safety:
3021            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3022            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3023            //   envelope_size bytes, there is always sufficient room.
3024            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3035            // are envelope_size bytes.
3036            let cur_offset: usize = (3 - 1) * envelope_size;
3037
3038            // Zero reserved fields.
3039            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3040
3041            // Safety:
3042            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3043            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3044            //   envelope_size bytes, there is always sufficient room.
3045            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3085            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            // Decode the envelope for each type.
3093            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            // Decode unknown envelopes for gaps in ordinals.
3102            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            // Decode unknown envelopes for gaps in ordinals.
3153            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            // Decode unknown envelopes for gaps in ordinals.
3204            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            // Decode the remaining unknown envelopes.
3262            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            // Vector header
3339            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3343            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3357            // are envelope_size bytes.
3358            let cur_offset: usize = (1 - 1) * envelope_size;
3359
3360            // Zero reserved fields.
3361            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3362
3363            // Safety:
3364            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3365            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3366            //   envelope_size bytes, there is always sufficient room.
3367            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3380            // are envelope_size bytes.
3381            let cur_offset: usize = (2 - 1) * envelope_size;
3382
3383            // Zero reserved fields.
3384            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3385
3386            // Safety:
3387            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3388            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3389            //   envelope_size bytes, there is always sufficient room.
3390            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3401            // are envelope_size bytes.
3402            let cur_offset: usize = (3 - 1) * envelope_size;
3403
3404            // Zero reserved fields.
3405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3406
3407            // Safety:
3408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3410            //   envelope_size bytes, there is always sufficient room.
3411            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3422            // are envelope_size bytes.
3423            let cur_offset: usize = (4 - 1) * envelope_size;
3424
3425            // Zero reserved fields.
3426            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3427
3428            // Safety:
3429            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3430            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3431            //   envelope_size bytes, there is always sufficient room.
3432            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3447            // are envelope_size bytes.
3448            let cur_offset: usize = (5 - 1) * envelope_size;
3449
3450            // Zero reserved fields.
3451            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3452
3453            // Safety:
3454            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3455            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3456            //   envelope_size bytes, there is always sufficient room.
3457            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3468            // are envelope_size bytes.
3469            let cur_offset: usize = (7 - 1) * envelope_size;
3470
3471            // Zero reserved fields.
3472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3473
3474            // Safety:
3475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3477            //   envelope_size bytes, there is always sufficient room.
3478            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3489            // are envelope_size bytes.
3490            let cur_offset: usize = (8 - 1) * envelope_size;
3491
3492            // Zero reserved fields.
3493            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3494
3495            // Safety:
3496            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3497            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3498            //   envelope_size bytes, there is always sufficient room.
3499            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3510            // are envelope_size bytes.
3511            let cur_offset: usize = (9 - 1) * envelope_size;
3512
3513            // Zero reserved fields.
3514            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3515
3516            // Safety:
3517            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3518            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3519            //   envelope_size bytes, there is always sufficient room.
3520            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3531            // are envelope_size bytes.
3532            let cur_offset: usize = (10 - 1) * envelope_size;
3533
3534            // Zero reserved fields.
3535            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3536
3537            // Safety:
3538            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3539            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3540            //   envelope_size bytes, there is always sufficient room.
3541            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3554            // are envelope_size bytes.
3555            let cur_offset: usize = (11 - 1) * envelope_size;
3556
3557            // Zero reserved fields.
3558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3559
3560            // Safety:
3561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3563            //   envelope_size bytes, there is always sufficient room.
3564            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3593            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            // Decode the envelope for each type.
3601            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            // Decode unknown envelopes for gaps in ordinals.
3610            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            // Decode unknown envelopes for gaps in ordinals.
3653            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            // Decode unknown envelopes for gaps in ordinals.
3704            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            // Decode unknown envelopes for gaps in ordinals.
3755            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            // Decode unknown envelopes for gaps in ordinals.
3798            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            // Decode unknown envelopes for gaps in ordinals.
3849            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            // Decode unknown envelopes for gaps in ordinals.
3900            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            // Decode unknown envelopes for gaps in ordinals.
3948            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            // Decode unknown envelopes for gaps in ordinals.
4006            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            // Decode unknown envelopes for gaps in ordinals.
4049            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            // Decode the remaining unknown envelopes.
4093            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            // Vector header
4148            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            // Calling encoder.out_of_line_offset(0) is not allowed.
4152            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4166            // are envelope_size bytes.
4167            let cur_offset: usize = (1 - 1) * envelope_size;
4168
4169            // Zero reserved fields.
4170            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4171
4172            // Safety:
4173            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4174            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4175            //   envelope_size bytes, there is always sufficient room.
4176            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4187            // are envelope_size bytes.
4188            let cur_offset: usize = (2 - 1) * envelope_size;
4189
4190            // Zero reserved fields.
4191            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4192
4193            // Safety:
4194            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4195            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4196            //   envelope_size bytes, there is always sufficient room.
4197            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            // Calling decoder.out_of_line_offset(0) is not allowed.
4226            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            // Decode the envelope for each type.
4234            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            // Decode unknown envelopes for gaps in ordinals.
4243            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            // Decode unknown envelopes for gaps in ordinals.
4294            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            // Decode the remaining unknown envelopes.
4338            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            // Vector header
4396            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            // Calling encoder.out_of_line_offset(0) is not allowed.
4400            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4414            // are envelope_size bytes.
4415            let cur_offset: usize = (1 - 1) * envelope_size;
4416
4417            // Zero reserved fields.
4418            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4419
4420            // Safety:
4421            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4422            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4423            //   envelope_size bytes, there is always sufficient room.
4424            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4437            // are envelope_size bytes.
4438            let cur_offset: usize = (2 - 1) * envelope_size;
4439
4440            // Zero reserved fields.
4441            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4442
4443            // Safety:
4444            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4445            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4446            //   envelope_size bytes, there is always sufficient room.
4447            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4462            // are envelope_size bytes.
4463            let cur_offset: usize = (3 - 1) * envelope_size;
4464
4465            // Zero reserved fields.
4466            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4467
4468            // Safety:
4469            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4470            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4471            //   envelope_size bytes, there is always sufficient room.
4472            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            // Calling decoder.out_of_line_offset(0) is not allowed.
4505            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            // Decode the envelope for each type.
4513            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            // Decode unknown envelopes for gaps in ordinals.
4522            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            // Decode unknown envelopes for gaps in ordinals.
4565            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            // Decode unknown envelopes for gaps in ordinals.
4619            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            // Decode the remaining unknown envelopes.
4669            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                        // Do nothing, read the value into the object
4767                    } else {
4768                        // Initialize `self` to the right variant
4769                        *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}