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