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