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