fidl_fuchsia_starnix_container/
fidl_fuchsia_starnix_container.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 _};
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum SpawnConsoleError {
15    /// A required table field was missing or otherwise invalid.
16    InvalidArgs,
17    /// The console process exited without a normal return code.
18    Canceled,
19    #[doc(hidden)]
20    __SourceBreaking { unknown_ordinal: u32 },
21}
22
23/// Pattern that matches an unknown `SpawnConsoleError` member.
24#[macro_export]
25macro_rules! SpawnConsoleErrorUnknown {
26    () => {
27        _
28    };
29}
30
31impl SpawnConsoleError {
32    #[inline]
33    pub fn from_primitive(prim: u32) -> Option<Self> {
34        match prim {
35            1 => Some(Self::InvalidArgs),
36            2 => Some(Self::Canceled),
37            _ => None,
38        }
39    }
40
41    #[inline]
42    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43        match prim {
44            1 => Self::InvalidArgs,
45            2 => Self::Canceled,
46            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
47        }
48    }
49
50    #[inline]
51    pub fn unknown() -> Self {
52        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
53    }
54
55    #[inline]
56    pub const fn into_primitive(self) -> u32 {
57        match self {
58            Self::InvalidArgs => 1,
59            Self::Canceled => 2,
60            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
61        }
62    }
63
64    #[inline]
65    pub fn is_unknown(&self) -> bool {
66        match self {
67            Self::__SourceBreaking { unknown_ordinal: _ } => true,
68            _ => false,
69        }
70    }
71}
72
73#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
74#[repr(C)]
75pub struct ConsoleWindowSize {
76    pub rows: u16,
77    pub cols: u16,
78    pub x_pixels: u16,
79    pub y_pixels: u16,
80}
81
82impl fidl::Persistable for ConsoleWindowSize {}
83
84#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
85#[repr(C)]
86pub struct ControllerSpawnConsoleResponse {
87    pub exit_code: u8,
88}
89
90impl fidl::Persistable for ControllerSpawnConsoleResponse {}
91
92#[derive(Clone, Debug, Default, PartialEq)]
93pub struct ControllerGetVmoReferencesRequest {
94    pub koid: Option<u64>,
95    #[doc(hidden)]
96    pub __source_breaking: fidl::marker::SourceBreaking,
97}
98
99impl fidl::Persistable for ControllerGetVmoReferencesRequest {}
100
101#[derive(Debug, Default, PartialEq)]
102pub struct ControllerSpawnConsoleRequest {
103    pub console_in: Option<fidl::Socket>,
104    pub console_out: Option<fidl::Socket>,
105    pub binary_path: Option<String>,
106    pub argv: Option<Vec<String>>,
107    pub environ: Option<Vec<String>>,
108    pub window_size: Option<ConsoleWindowSize>,
109    #[doc(hidden)]
110    pub __source_breaking: fidl::marker::SourceBreaking,
111}
112
113impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
114    for ControllerSpawnConsoleRequest
115{
116}
117
118#[derive(Debug, Default, PartialEq)]
119pub struct ControllerVsockConnectRequest {
120    pub port: Option<u32>,
121    pub bridge_socket: Option<fidl::Socket>,
122    #[doc(hidden)]
123    pub __source_breaking: fidl::marker::SourceBreaking,
124}
125
126impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
127    for ControllerVsockConnectRequest
128{
129}
130
131#[derive(Debug, Default, PartialEq)]
132pub struct ControllerGetJobHandleResponse {
133    pub job: Option<fidl::Job>,
134    #[doc(hidden)]
135    pub __source_breaking: fidl::marker::SourceBreaking,
136}
137
138impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
139    for ControllerGetJobHandleResponse
140{
141}
142
143#[derive(Clone, Debug, Default, PartialEq)]
144pub struct ControllerGetVmoReferencesResponse {
145    pub references: Option<Vec<VmoReference>>,
146    #[doc(hidden)]
147    pub __source_breaking: fidl::marker::SourceBreaking,
148}
149
150impl fidl::Persistable for ControllerGetVmoReferencesResponse {}
151
152#[derive(Clone, Debug, Default, PartialEq)]
153pub struct VmoReference {
154    /// The name of the process containing a file backed by the vmo.
155    pub process_name: Option<String>,
156    /// The Starnix pid of the process containing a file backed by the vmo.
157    pub pid: Option<u64>,
158    /// The file descriptor number in the process that refers to the vmo.
159    pub fd: Option<i32>,
160    /// The koid of the vmo.
161    pub koid: Option<u64>,
162    #[doc(hidden)]
163    pub __source_breaking: fidl::marker::SourceBreaking,
164}
165
166impl fidl::Persistable for VmoReference {}
167
168#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
169pub struct ControllerMarker;
170
171impl fidl::endpoints::ProtocolMarker for ControllerMarker {
172    type Proxy = ControllerProxy;
173    type RequestStream = ControllerRequestStream;
174    #[cfg(target_os = "fuchsia")]
175    type SynchronousProxy = ControllerSynchronousProxy;
176
177    const DEBUG_NAME: &'static str = "fuchsia.starnix.container.Controller";
178}
179impl fidl::endpoints::DiscoverableProtocolMarker for ControllerMarker {}
180pub type ControllerSpawnConsoleResult = Result<u8, SpawnConsoleError>;
181
182pub trait ControllerProxyInterface: Send + Sync {
183    fn r#vsock_connect(&self, payload: ControllerVsockConnectRequest) -> Result<(), fidl::Error>;
184    type SpawnConsoleResponseFut: std::future::Future<Output = Result<ControllerSpawnConsoleResult, fidl::Error>>
185        + Send;
186    fn r#spawn_console(
187        &self,
188        payload: ControllerSpawnConsoleRequest,
189    ) -> Self::SpawnConsoleResponseFut;
190    type GetVmoReferencesResponseFut: std::future::Future<Output = Result<ControllerGetVmoReferencesResponse, fidl::Error>>
191        + Send;
192    fn r#get_vmo_references(
193        &self,
194        payload: &ControllerGetVmoReferencesRequest,
195    ) -> Self::GetVmoReferencesResponseFut;
196    type GetJobHandleResponseFut: std::future::Future<Output = Result<ControllerGetJobHandleResponse, fidl::Error>>
197        + Send;
198    fn r#get_job_handle(&self) -> Self::GetJobHandleResponseFut;
199}
200#[derive(Debug)]
201#[cfg(target_os = "fuchsia")]
202pub struct ControllerSynchronousProxy {
203    client: fidl::client::sync::Client,
204}
205
206#[cfg(target_os = "fuchsia")]
207impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
208    type Proxy = ControllerProxy;
209    type Protocol = ControllerMarker;
210
211    fn from_channel(inner: fidl::Channel) -> Self {
212        Self::new(inner)
213    }
214
215    fn into_channel(self) -> fidl::Channel {
216        self.client.into_channel()
217    }
218
219    fn as_channel(&self) -> &fidl::Channel {
220        self.client.as_channel()
221    }
222}
223
224#[cfg(target_os = "fuchsia")]
225impl ControllerSynchronousProxy {
226    pub fn new(channel: fidl::Channel) -> Self {
227        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
228        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
229    }
230
231    pub fn into_channel(self) -> fidl::Channel {
232        self.client.into_channel()
233    }
234
235    /// Waits until an event arrives and returns it. It is safe for other
236    /// threads to make concurrent requests while waiting for an event.
237    pub fn wait_for_event(
238        &self,
239        deadline: zx::MonotonicInstant,
240    ) -> Result<ControllerEvent, fidl::Error> {
241        ControllerEvent::decode(self.client.wait_for_event(deadline)?)
242    }
243
244    /// Connects `bridge_socket` to a vsocket at `port` in the container.
245    pub fn r#vsock_connect(
246        &self,
247        mut payload: ControllerVsockConnectRequest,
248    ) -> Result<(), fidl::Error> {
249        self.client.send::<ControllerVsockConnectRequest>(
250            &mut payload,
251            0x494a469a8943213b,
252            fidl::encoding::DynamicFlags::FLEXIBLE,
253        )
254    }
255
256    /// Spawn a console for debugging in the container. For testing, prefer launching Linux programs
257    /// as components with the `starnix_container` runner.
258    ///
259    /// Returns when the console exits.
260    pub fn r#spawn_console(
261        &self,
262        mut payload: ControllerSpawnConsoleRequest,
263        ___deadline: zx::MonotonicInstant,
264    ) -> Result<ControllerSpawnConsoleResult, fidl::Error> {
265        let _response =
266            self.client
267                .send_query::<ControllerSpawnConsoleRequest, fidl::encoding::FlexibleResultType<
268                    ControllerSpawnConsoleResponse,
269                    SpawnConsoleError,
270                >>(
271                    &mut payload,
272                    0x76eb46fdc63aa8b8,
273                    fidl::encoding::DynamicFlags::FLEXIBLE,
274                    ___deadline,
275                )?
276                .into_result::<ControllerMarker>("spawn_console")?;
277        Ok(_response.map(|x| x.exit_code))
278    }
279
280    /// Returns all processes that have open files that are backed by a vmo with koid.
281    pub fn r#get_vmo_references(
282        &self,
283        mut payload: &ControllerGetVmoReferencesRequest,
284        ___deadline: zx::MonotonicInstant,
285    ) -> Result<ControllerGetVmoReferencesResponse, fidl::Error> {
286        let _response = self.client.send_query::<
287            ControllerGetVmoReferencesRequest,
288            fidl::encoding::FlexibleType<ControllerGetVmoReferencesResponse>,
289        >(
290            payload,
291            0x47a7f039bb97f173,
292            fidl::encoding::DynamicFlags::FLEXIBLE,
293            ___deadline,
294        )?
295        .into_result::<ControllerMarker>("get_vmo_references")?;
296        Ok(_response)
297    }
298
299    /// Returns the job handle of the container.
300    pub fn r#get_job_handle(
301        &self,
302        ___deadline: zx::MonotonicInstant,
303    ) -> Result<ControllerGetJobHandleResponse, fidl::Error> {
304        let _response = self.client.send_query::<
305            fidl::encoding::EmptyPayload,
306            fidl::encoding::FlexibleType<ControllerGetJobHandleResponse>,
307        >(
308            (),
309            0x60a31a248576ffea,
310            fidl::encoding::DynamicFlags::FLEXIBLE,
311            ___deadline,
312        )?
313        .into_result::<ControllerMarker>("get_job_handle")?;
314        Ok(_response)
315    }
316}
317
318#[derive(Debug, Clone)]
319pub struct ControllerProxy {
320    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
321}
322
323impl fidl::endpoints::Proxy for ControllerProxy {
324    type Protocol = ControllerMarker;
325
326    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
327        Self::new(inner)
328    }
329
330    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
331        self.client.into_channel().map_err(|client| Self { client })
332    }
333
334    fn as_channel(&self) -> &::fidl::AsyncChannel {
335        self.client.as_channel()
336    }
337}
338
339impl ControllerProxy {
340    /// Create a new Proxy for fuchsia.starnix.container/Controller.
341    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
342        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
343        Self { client: fidl::client::Client::new(channel, protocol_name) }
344    }
345
346    /// Get a Stream of events from the remote end of the protocol.
347    ///
348    /// # Panics
349    ///
350    /// Panics if the event stream was already taken.
351    pub fn take_event_stream(&self) -> ControllerEventStream {
352        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
353    }
354
355    /// Connects `bridge_socket` to a vsocket at `port` in the container.
356    pub fn r#vsock_connect(
357        &self,
358        mut payload: ControllerVsockConnectRequest,
359    ) -> Result<(), fidl::Error> {
360        ControllerProxyInterface::r#vsock_connect(self, payload)
361    }
362
363    /// Spawn a console for debugging in the container. For testing, prefer launching Linux programs
364    /// as components with the `starnix_container` runner.
365    ///
366    /// Returns when the console exits.
367    pub fn r#spawn_console(
368        &self,
369        mut payload: ControllerSpawnConsoleRequest,
370    ) -> fidl::client::QueryResponseFut<
371        ControllerSpawnConsoleResult,
372        fidl::encoding::DefaultFuchsiaResourceDialect,
373    > {
374        ControllerProxyInterface::r#spawn_console(self, payload)
375    }
376
377    /// Returns all processes that have open files that are backed by a vmo with koid.
378    pub fn r#get_vmo_references(
379        &self,
380        mut payload: &ControllerGetVmoReferencesRequest,
381    ) -> fidl::client::QueryResponseFut<
382        ControllerGetVmoReferencesResponse,
383        fidl::encoding::DefaultFuchsiaResourceDialect,
384    > {
385        ControllerProxyInterface::r#get_vmo_references(self, payload)
386    }
387
388    /// Returns the job handle of the container.
389    pub fn r#get_job_handle(
390        &self,
391    ) -> fidl::client::QueryResponseFut<
392        ControllerGetJobHandleResponse,
393        fidl::encoding::DefaultFuchsiaResourceDialect,
394    > {
395        ControllerProxyInterface::r#get_job_handle(self)
396    }
397}
398
399impl ControllerProxyInterface for ControllerProxy {
400    fn r#vsock_connect(
401        &self,
402        mut payload: ControllerVsockConnectRequest,
403    ) -> Result<(), fidl::Error> {
404        self.client.send::<ControllerVsockConnectRequest>(
405            &mut payload,
406            0x494a469a8943213b,
407            fidl::encoding::DynamicFlags::FLEXIBLE,
408        )
409    }
410
411    type SpawnConsoleResponseFut = fidl::client::QueryResponseFut<
412        ControllerSpawnConsoleResult,
413        fidl::encoding::DefaultFuchsiaResourceDialect,
414    >;
415    fn r#spawn_console(
416        &self,
417        mut payload: ControllerSpawnConsoleRequest,
418    ) -> Self::SpawnConsoleResponseFut {
419        fn _decode(
420            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
421        ) -> Result<ControllerSpawnConsoleResult, fidl::Error> {
422            let _response = fidl::client::decode_transaction_body::<
423                fidl::encoding::FlexibleResultType<
424                    ControllerSpawnConsoleResponse,
425                    SpawnConsoleError,
426                >,
427                fidl::encoding::DefaultFuchsiaResourceDialect,
428                0x76eb46fdc63aa8b8,
429            >(_buf?)?
430            .into_result::<ControllerMarker>("spawn_console")?;
431            Ok(_response.map(|x| x.exit_code))
432        }
433        self.client
434            .send_query_and_decode::<ControllerSpawnConsoleRequest, ControllerSpawnConsoleResult>(
435                &mut payload,
436                0x76eb46fdc63aa8b8,
437                fidl::encoding::DynamicFlags::FLEXIBLE,
438                _decode,
439            )
440    }
441
442    type GetVmoReferencesResponseFut = fidl::client::QueryResponseFut<
443        ControllerGetVmoReferencesResponse,
444        fidl::encoding::DefaultFuchsiaResourceDialect,
445    >;
446    fn r#get_vmo_references(
447        &self,
448        mut payload: &ControllerGetVmoReferencesRequest,
449    ) -> Self::GetVmoReferencesResponseFut {
450        fn _decode(
451            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
452        ) -> Result<ControllerGetVmoReferencesResponse, fidl::Error> {
453            let _response = fidl::client::decode_transaction_body::<
454                fidl::encoding::FlexibleType<ControllerGetVmoReferencesResponse>,
455                fidl::encoding::DefaultFuchsiaResourceDialect,
456                0x47a7f039bb97f173,
457            >(_buf?)?
458            .into_result::<ControllerMarker>("get_vmo_references")?;
459            Ok(_response)
460        }
461        self.client.send_query_and_decode::<
462            ControllerGetVmoReferencesRequest,
463            ControllerGetVmoReferencesResponse,
464        >(
465            payload,
466            0x47a7f039bb97f173,
467            fidl::encoding::DynamicFlags::FLEXIBLE,
468            _decode,
469        )
470    }
471
472    type GetJobHandleResponseFut = fidl::client::QueryResponseFut<
473        ControllerGetJobHandleResponse,
474        fidl::encoding::DefaultFuchsiaResourceDialect,
475    >;
476    fn r#get_job_handle(&self) -> Self::GetJobHandleResponseFut {
477        fn _decode(
478            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
479        ) -> Result<ControllerGetJobHandleResponse, fidl::Error> {
480            let _response = fidl::client::decode_transaction_body::<
481                fidl::encoding::FlexibleType<ControllerGetJobHandleResponse>,
482                fidl::encoding::DefaultFuchsiaResourceDialect,
483                0x60a31a248576ffea,
484            >(_buf?)?
485            .into_result::<ControllerMarker>("get_job_handle")?;
486            Ok(_response)
487        }
488        self.client
489            .send_query_and_decode::<fidl::encoding::EmptyPayload, ControllerGetJobHandleResponse>(
490                (),
491                0x60a31a248576ffea,
492                fidl::encoding::DynamicFlags::FLEXIBLE,
493                _decode,
494            )
495    }
496}
497
498pub struct ControllerEventStream {
499    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
500}
501
502impl std::marker::Unpin for ControllerEventStream {}
503
504impl futures::stream::FusedStream for ControllerEventStream {
505    fn is_terminated(&self) -> bool {
506        self.event_receiver.is_terminated()
507    }
508}
509
510impl futures::Stream for ControllerEventStream {
511    type Item = Result<ControllerEvent, fidl::Error>;
512
513    fn poll_next(
514        mut self: std::pin::Pin<&mut Self>,
515        cx: &mut std::task::Context<'_>,
516    ) -> std::task::Poll<Option<Self::Item>> {
517        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
518            &mut self.event_receiver,
519            cx
520        )?) {
521            Some(buf) => std::task::Poll::Ready(Some(ControllerEvent::decode(buf))),
522            None => std::task::Poll::Ready(None),
523        }
524    }
525}
526
527#[derive(Debug)]
528pub enum ControllerEvent {
529    #[non_exhaustive]
530    _UnknownEvent {
531        /// Ordinal of the event that was sent.
532        ordinal: u64,
533    },
534}
535
536impl ControllerEvent {
537    /// Decodes a message buffer as a [`ControllerEvent`].
538    fn decode(
539        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
540    ) -> Result<ControllerEvent, fidl::Error> {
541        let (bytes, _handles) = buf.split_mut();
542        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
543        debug_assert_eq!(tx_header.tx_id, 0);
544        match tx_header.ordinal {
545            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
546                Ok(ControllerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
547            }
548            _ => Err(fidl::Error::UnknownOrdinal {
549                ordinal: tx_header.ordinal,
550                protocol_name: <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
551            }),
552        }
553    }
554}
555
556/// A Stream of incoming requests for fuchsia.starnix.container/Controller.
557pub struct ControllerRequestStream {
558    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
559    is_terminated: bool,
560}
561
562impl std::marker::Unpin for ControllerRequestStream {}
563
564impl futures::stream::FusedStream for ControllerRequestStream {
565    fn is_terminated(&self) -> bool {
566        self.is_terminated
567    }
568}
569
570impl fidl::endpoints::RequestStream for ControllerRequestStream {
571    type Protocol = ControllerMarker;
572    type ControlHandle = ControllerControlHandle;
573
574    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
575        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
576    }
577
578    fn control_handle(&self) -> Self::ControlHandle {
579        ControllerControlHandle { inner: self.inner.clone() }
580    }
581
582    fn into_inner(
583        self,
584    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
585    {
586        (self.inner, self.is_terminated)
587    }
588
589    fn from_inner(
590        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
591        is_terminated: bool,
592    ) -> Self {
593        Self { inner, is_terminated }
594    }
595}
596
597impl futures::Stream for ControllerRequestStream {
598    type Item = Result<ControllerRequest, fidl::Error>;
599
600    fn poll_next(
601        mut self: std::pin::Pin<&mut Self>,
602        cx: &mut std::task::Context<'_>,
603    ) -> std::task::Poll<Option<Self::Item>> {
604        let this = &mut *self;
605        if this.inner.check_shutdown(cx) {
606            this.is_terminated = true;
607            return std::task::Poll::Ready(None);
608        }
609        if this.is_terminated {
610            panic!("polled ControllerRequestStream after completion");
611        }
612        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
613            |bytes, handles| {
614                match this.inner.channel().read_etc(cx, bytes, handles) {
615                    std::task::Poll::Ready(Ok(())) => {}
616                    std::task::Poll::Pending => return std::task::Poll::Pending,
617                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
618                        this.is_terminated = true;
619                        return std::task::Poll::Ready(None);
620                    }
621                    std::task::Poll::Ready(Err(e)) => {
622                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
623                            e.into(),
624                        ))))
625                    }
626                }
627
628                // A message has been received from the channel
629                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
630
631                std::task::Poll::Ready(Some(match header.ordinal {
632                    0x494a469a8943213b => {
633                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
634                        let mut req = fidl::new_empty!(
635                            ControllerVsockConnectRequest,
636                            fidl::encoding::DefaultFuchsiaResourceDialect
637                        );
638                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerVsockConnectRequest>(&header, _body_bytes, handles, &mut req)?;
639                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
640                        Ok(ControllerRequest::VsockConnect { payload: req, control_handle })
641                    }
642                    0x76eb46fdc63aa8b8 => {
643                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
644                        let mut req = fidl::new_empty!(
645                            ControllerSpawnConsoleRequest,
646                            fidl::encoding::DefaultFuchsiaResourceDialect
647                        );
648                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSpawnConsoleRequest>(&header, _body_bytes, handles, &mut req)?;
649                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
650                        Ok(ControllerRequest::SpawnConsole {
651                            payload: req,
652                            responder: ControllerSpawnConsoleResponder {
653                                control_handle: std::mem::ManuallyDrop::new(control_handle),
654                                tx_id: header.tx_id,
655                            },
656                        })
657                    }
658                    0x47a7f039bb97f173 => {
659                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
660                        let mut req = fidl::new_empty!(
661                            ControllerGetVmoReferencesRequest,
662                            fidl::encoding::DefaultFuchsiaResourceDialect
663                        );
664                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerGetVmoReferencesRequest>(&header, _body_bytes, handles, &mut req)?;
665                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
666                        Ok(ControllerRequest::GetVmoReferences {
667                            payload: req,
668                            responder: ControllerGetVmoReferencesResponder {
669                                control_handle: std::mem::ManuallyDrop::new(control_handle),
670                                tx_id: header.tx_id,
671                            },
672                        })
673                    }
674                    0x60a31a248576ffea => {
675                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
676                        let mut req = fidl::new_empty!(
677                            fidl::encoding::EmptyPayload,
678                            fidl::encoding::DefaultFuchsiaResourceDialect
679                        );
680                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
681                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
682                        Ok(ControllerRequest::GetJobHandle {
683                            responder: ControllerGetJobHandleResponder {
684                                control_handle: std::mem::ManuallyDrop::new(control_handle),
685                                tx_id: header.tx_id,
686                            },
687                        })
688                    }
689                    _ if header.tx_id == 0
690                        && header
691                            .dynamic_flags()
692                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
693                    {
694                        Ok(ControllerRequest::_UnknownMethod {
695                            ordinal: header.ordinal,
696                            control_handle: ControllerControlHandle { inner: this.inner.clone() },
697                            method_type: fidl::MethodType::OneWay,
698                        })
699                    }
700                    _ if header
701                        .dynamic_flags()
702                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
703                    {
704                        this.inner.send_framework_err(
705                            fidl::encoding::FrameworkErr::UnknownMethod,
706                            header.tx_id,
707                            header.ordinal,
708                            header.dynamic_flags(),
709                            (bytes, handles),
710                        )?;
711                        Ok(ControllerRequest::_UnknownMethod {
712                            ordinal: header.ordinal,
713                            control_handle: ControllerControlHandle { inner: this.inner.clone() },
714                            method_type: fidl::MethodType::TwoWay,
715                        })
716                    }
717                    _ => Err(fidl::Error::UnknownOrdinal {
718                        ordinal: header.ordinal,
719                        protocol_name:
720                            <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
721                    }),
722                }))
723            },
724        )
725    }
726}
727
728#[derive(Debug)]
729pub enum ControllerRequest {
730    /// Connects `bridge_socket` to a vsocket at `port` in the container.
731    VsockConnect { payload: ControllerVsockConnectRequest, control_handle: ControllerControlHandle },
732    /// Spawn a console for debugging in the container. For testing, prefer launching Linux programs
733    /// as components with the `starnix_container` runner.
734    ///
735    /// Returns when the console exits.
736    SpawnConsole {
737        payload: ControllerSpawnConsoleRequest,
738        responder: ControllerSpawnConsoleResponder,
739    },
740    /// Returns all processes that have open files that are backed by a vmo with koid.
741    GetVmoReferences {
742        payload: ControllerGetVmoReferencesRequest,
743        responder: ControllerGetVmoReferencesResponder,
744    },
745    /// Returns the job handle of the container.
746    GetJobHandle { responder: ControllerGetJobHandleResponder },
747    /// An interaction was received which does not match any known method.
748    #[non_exhaustive]
749    _UnknownMethod {
750        /// Ordinal of the method that was called.
751        ordinal: u64,
752        control_handle: ControllerControlHandle,
753        method_type: fidl::MethodType,
754    },
755}
756
757impl ControllerRequest {
758    #[allow(irrefutable_let_patterns)]
759    pub fn into_vsock_connect(
760        self,
761    ) -> Option<(ControllerVsockConnectRequest, ControllerControlHandle)> {
762        if let ControllerRequest::VsockConnect { payload, control_handle } = self {
763            Some((payload, control_handle))
764        } else {
765            None
766        }
767    }
768
769    #[allow(irrefutable_let_patterns)]
770    pub fn into_spawn_console(
771        self,
772    ) -> Option<(ControllerSpawnConsoleRequest, ControllerSpawnConsoleResponder)> {
773        if let ControllerRequest::SpawnConsole { payload, responder } = self {
774            Some((payload, responder))
775        } else {
776            None
777        }
778    }
779
780    #[allow(irrefutable_let_patterns)]
781    pub fn into_get_vmo_references(
782        self,
783    ) -> Option<(ControllerGetVmoReferencesRequest, ControllerGetVmoReferencesResponder)> {
784        if let ControllerRequest::GetVmoReferences { payload, responder } = self {
785            Some((payload, responder))
786        } else {
787            None
788        }
789    }
790
791    #[allow(irrefutable_let_patterns)]
792    pub fn into_get_job_handle(self) -> Option<(ControllerGetJobHandleResponder)> {
793        if let ControllerRequest::GetJobHandle { responder } = self {
794            Some((responder))
795        } else {
796            None
797        }
798    }
799
800    /// Name of the method defined in FIDL
801    pub fn method_name(&self) -> &'static str {
802        match *self {
803            ControllerRequest::VsockConnect { .. } => "vsock_connect",
804            ControllerRequest::SpawnConsole { .. } => "spawn_console",
805            ControllerRequest::GetVmoReferences { .. } => "get_vmo_references",
806            ControllerRequest::GetJobHandle { .. } => "get_job_handle",
807            ControllerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
808                "unknown one-way method"
809            }
810            ControllerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
811                "unknown two-way method"
812            }
813        }
814    }
815}
816
817#[derive(Debug, Clone)]
818pub struct ControllerControlHandle {
819    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
820}
821
822impl fidl::endpoints::ControlHandle for ControllerControlHandle {
823    fn shutdown(&self) {
824        self.inner.shutdown()
825    }
826    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
827        self.inner.shutdown_with_epitaph(status)
828    }
829
830    fn is_closed(&self) -> bool {
831        self.inner.channel().is_closed()
832    }
833    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
834        self.inner.channel().on_closed()
835    }
836
837    #[cfg(target_os = "fuchsia")]
838    fn signal_peer(
839        &self,
840        clear_mask: zx::Signals,
841        set_mask: zx::Signals,
842    ) -> Result<(), zx_status::Status> {
843        use fidl::Peered;
844        self.inner.channel().signal_peer(clear_mask, set_mask)
845    }
846}
847
848impl ControllerControlHandle {}
849
850#[must_use = "FIDL methods require a response to be sent"]
851#[derive(Debug)]
852pub struct ControllerSpawnConsoleResponder {
853    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
854    tx_id: u32,
855}
856
857/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
858/// if the responder is dropped without sending a response, so that the client
859/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
860impl std::ops::Drop for ControllerSpawnConsoleResponder {
861    fn drop(&mut self) {
862        self.control_handle.shutdown();
863        // Safety: drops once, never accessed again
864        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
865    }
866}
867
868impl fidl::endpoints::Responder for ControllerSpawnConsoleResponder {
869    type ControlHandle = ControllerControlHandle;
870
871    fn control_handle(&self) -> &ControllerControlHandle {
872        &self.control_handle
873    }
874
875    fn drop_without_shutdown(mut self) {
876        // Safety: drops once, never accessed again due to mem::forget
877        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
878        // Prevent Drop from running (which would shut down the channel)
879        std::mem::forget(self);
880    }
881}
882
883impl ControllerSpawnConsoleResponder {
884    /// Sends a response to the FIDL transaction.
885    ///
886    /// Sets the channel to shutdown if an error occurs.
887    pub fn send(self, mut result: Result<u8, SpawnConsoleError>) -> Result<(), fidl::Error> {
888        let _result = self.send_raw(result);
889        if _result.is_err() {
890            self.control_handle.shutdown();
891        }
892        self.drop_without_shutdown();
893        _result
894    }
895
896    /// Similar to "send" but does not shutdown the channel if an error occurs.
897    pub fn send_no_shutdown_on_err(
898        self,
899        mut result: Result<u8, SpawnConsoleError>,
900    ) -> Result<(), fidl::Error> {
901        let _result = self.send_raw(result);
902        self.drop_without_shutdown();
903        _result
904    }
905
906    fn send_raw(&self, mut result: Result<u8, SpawnConsoleError>) -> Result<(), fidl::Error> {
907        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
908            ControllerSpawnConsoleResponse,
909            SpawnConsoleError,
910        >>(
911            fidl::encoding::FlexibleResult::new(result.map(|exit_code| (exit_code,))),
912            self.tx_id,
913            0x76eb46fdc63aa8b8,
914            fidl::encoding::DynamicFlags::FLEXIBLE,
915        )
916    }
917}
918
919#[must_use = "FIDL methods require a response to be sent"]
920#[derive(Debug)]
921pub struct ControllerGetVmoReferencesResponder {
922    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
923    tx_id: u32,
924}
925
926/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
927/// if the responder is dropped without sending a response, so that the client
928/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
929impl std::ops::Drop for ControllerGetVmoReferencesResponder {
930    fn drop(&mut self) {
931        self.control_handle.shutdown();
932        // Safety: drops once, never accessed again
933        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
934    }
935}
936
937impl fidl::endpoints::Responder for ControllerGetVmoReferencesResponder {
938    type ControlHandle = ControllerControlHandle;
939
940    fn control_handle(&self) -> &ControllerControlHandle {
941        &self.control_handle
942    }
943
944    fn drop_without_shutdown(mut self) {
945        // Safety: drops once, never accessed again due to mem::forget
946        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
947        // Prevent Drop from running (which would shut down the channel)
948        std::mem::forget(self);
949    }
950}
951
952impl ControllerGetVmoReferencesResponder {
953    /// Sends a response to the FIDL transaction.
954    ///
955    /// Sets the channel to shutdown if an error occurs.
956    pub fn send(self, mut payload: &ControllerGetVmoReferencesResponse) -> Result<(), fidl::Error> {
957        let _result = self.send_raw(payload);
958        if _result.is_err() {
959            self.control_handle.shutdown();
960        }
961        self.drop_without_shutdown();
962        _result
963    }
964
965    /// Similar to "send" but does not shutdown the channel if an error occurs.
966    pub fn send_no_shutdown_on_err(
967        self,
968        mut payload: &ControllerGetVmoReferencesResponse,
969    ) -> Result<(), fidl::Error> {
970        let _result = self.send_raw(payload);
971        self.drop_without_shutdown();
972        _result
973    }
974
975    fn send_raw(
976        &self,
977        mut payload: &ControllerGetVmoReferencesResponse,
978    ) -> Result<(), fidl::Error> {
979        self.control_handle
980            .inner
981            .send::<fidl::encoding::FlexibleType<ControllerGetVmoReferencesResponse>>(
982                fidl::encoding::Flexible::new(payload),
983                self.tx_id,
984                0x47a7f039bb97f173,
985                fidl::encoding::DynamicFlags::FLEXIBLE,
986            )
987    }
988}
989
990#[must_use = "FIDL methods require a response to be sent"]
991#[derive(Debug)]
992pub struct ControllerGetJobHandleResponder {
993    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
994    tx_id: u32,
995}
996
997/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
998/// if the responder is dropped without sending a response, so that the client
999/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1000impl std::ops::Drop for ControllerGetJobHandleResponder {
1001    fn drop(&mut self) {
1002        self.control_handle.shutdown();
1003        // Safety: drops once, never accessed again
1004        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1005    }
1006}
1007
1008impl fidl::endpoints::Responder for ControllerGetJobHandleResponder {
1009    type ControlHandle = ControllerControlHandle;
1010
1011    fn control_handle(&self) -> &ControllerControlHandle {
1012        &self.control_handle
1013    }
1014
1015    fn drop_without_shutdown(mut self) {
1016        // Safety: drops once, never accessed again due to mem::forget
1017        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1018        // Prevent Drop from running (which would shut down the channel)
1019        std::mem::forget(self);
1020    }
1021}
1022
1023impl ControllerGetJobHandleResponder {
1024    /// Sends a response to the FIDL transaction.
1025    ///
1026    /// Sets the channel to shutdown if an error occurs.
1027    pub fn send(self, mut payload: ControllerGetJobHandleResponse) -> Result<(), fidl::Error> {
1028        let _result = self.send_raw(payload);
1029        if _result.is_err() {
1030            self.control_handle.shutdown();
1031        }
1032        self.drop_without_shutdown();
1033        _result
1034    }
1035
1036    /// Similar to "send" but does not shutdown the channel if an error occurs.
1037    pub fn send_no_shutdown_on_err(
1038        self,
1039        mut payload: ControllerGetJobHandleResponse,
1040    ) -> Result<(), fidl::Error> {
1041        let _result = self.send_raw(payload);
1042        self.drop_without_shutdown();
1043        _result
1044    }
1045
1046    fn send_raw(&self, mut payload: ControllerGetJobHandleResponse) -> Result<(), fidl::Error> {
1047        self.control_handle
1048            .inner
1049            .send::<fidl::encoding::FlexibleType<ControllerGetJobHandleResponse>>(
1050                fidl::encoding::Flexible::new(&mut payload),
1051                self.tx_id,
1052                0x60a31a248576ffea,
1053                fidl::encoding::DynamicFlags::FLEXIBLE,
1054            )
1055    }
1056}
1057
1058mod internal {
1059    use super::*;
1060    unsafe impl fidl::encoding::TypeMarker for SpawnConsoleError {
1061        type Owned = Self;
1062
1063        #[inline(always)]
1064        fn inline_align(_context: fidl::encoding::Context) -> usize {
1065            std::mem::align_of::<u32>()
1066        }
1067
1068        #[inline(always)]
1069        fn inline_size(_context: fidl::encoding::Context) -> usize {
1070            std::mem::size_of::<u32>()
1071        }
1072
1073        #[inline(always)]
1074        fn encode_is_copy() -> bool {
1075            false
1076        }
1077
1078        #[inline(always)]
1079        fn decode_is_copy() -> bool {
1080            false
1081        }
1082    }
1083
1084    impl fidl::encoding::ValueTypeMarker for SpawnConsoleError {
1085        type Borrowed<'a> = Self;
1086        #[inline(always)]
1087        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1088            *value
1089        }
1090    }
1091
1092    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1093        for SpawnConsoleError
1094    {
1095        #[inline]
1096        unsafe fn encode(
1097            self,
1098            encoder: &mut fidl::encoding::Encoder<'_, D>,
1099            offset: usize,
1100            _depth: fidl::encoding::Depth,
1101        ) -> fidl::Result<()> {
1102            encoder.debug_check_bounds::<Self>(offset);
1103            encoder.write_num(self.into_primitive(), offset);
1104            Ok(())
1105        }
1106    }
1107
1108    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SpawnConsoleError {
1109        #[inline(always)]
1110        fn new_empty() -> Self {
1111            Self::unknown()
1112        }
1113
1114        #[inline]
1115        unsafe fn decode(
1116            &mut self,
1117            decoder: &mut fidl::encoding::Decoder<'_, D>,
1118            offset: usize,
1119            _depth: fidl::encoding::Depth,
1120        ) -> fidl::Result<()> {
1121            decoder.debug_check_bounds::<Self>(offset);
1122            let prim = decoder.read_num::<u32>(offset);
1123
1124            *self = Self::from_primitive_allow_unknown(prim);
1125            Ok(())
1126        }
1127    }
1128
1129    impl fidl::encoding::ValueTypeMarker for ConsoleWindowSize {
1130        type Borrowed<'a> = &'a Self;
1131        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1132            value
1133        }
1134    }
1135
1136    unsafe impl fidl::encoding::TypeMarker for ConsoleWindowSize {
1137        type Owned = Self;
1138
1139        #[inline(always)]
1140        fn inline_align(_context: fidl::encoding::Context) -> usize {
1141            2
1142        }
1143
1144        #[inline(always)]
1145        fn inline_size(_context: fidl::encoding::Context) -> usize {
1146            8
1147        }
1148        #[inline(always)]
1149        fn encode_is_copy() -> bool {
1150            true
1151        }
1152
1153        #[inline(always)]
1154        fn decode_is_copy() -> bool {
1155            true
1156        }
1157    }
1158
1159    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConsoleWindowSize, D>
1160        for &ConsoleWindowSize
1161    {
1162        #[inline]
1163        unsafe fn encode(
1164            self,
1165            encoder: &mut fidl::encoding::Encoder<'_, D>,
1166            offset: usize,
1167            _depth: fidl::encoding::Depth,
1168        ) -> fidl::Result<()> {
1169            encoder.debug_check_bounds::<ConsoleWindowSize>(offset);
1170            unsafe {
1171                // Copy the object into the buffer.
1172                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1173                (buf_ptr as *mut ConsoleWindowSize)
1174                    .write_unaligned((self as *const ConsoleWindowSize).read());
1175                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1176                // done second because the memcpy will write garbage to these bytes.
1177            }
1178            Ok(())
1179        }
1180    }
1181    unsafe impl<
1182            D: fidl::encoding::ResourceDialect,
1183            T0: fidl::encoding::Encode<u16, D>,
1184            T1: fidl::encoding::Encode<u16, D>,
1185            T2: fidl::encoding::Encode<u16, D>,
1186            T3: fidl::encoding::Encode<u16, D>,
1187        > fidl::encoding::Encode<ConsoleWindowSize, D> for (T0, T1, T2, T3)
1188    {
1189        #[inline]
1190        unsafe fn encode(
1191            self,
1192            encoder: &mut fidl::encoding::Encoder<'_, D>,
1193            offset: usize,
1194            depth: fidl::encoding::Depth,
1195        ) -> fidl::Result<()> {
1196            encoder.debug_check_bounds::<ConsoleWindowSize>(offset);
1197            // Zero out padding regions. There's no need to apply masks
1198            // because the unmasked parts will be overwritten by fields.
1199            // Write the fields.
1200            self.0.encode(encoder, offset + 0, depth)?;
1201            self.1.encode(encoder, offset + 2, depth)?;
1202            self.2.encode(encoder, offset + 4, depth)?;
1203            self.3.encode(encoder, offset + 6, depth)?;
1204            Ok(())
1205        }
1206    }
1207
1208    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConsoleWindowSize {
1209        #[inline(always)]
1210        fn new_empty() -> Self {
1211            Self {
1212                rows: fidl::new_empty!(u16, D),
1213                cols: fidl::new_empty!(u16, D),
1214                x_pixels: fidl::new_empty!(u16, D),
1215                y_pixels: fidl::new_empty!(u16, D),
1216            }
1217        }
1218
1219        #[inline]
1220        unsafe fn decode(
1221            &mut self,
1222            decoder: &mut fidl::encoding::Decoder<'_, D>,
1223            offset: usize,
1224            _depth: fidl::encoding::Depth,
1225        ) -> fidl::Result<()> {
1226            decoder.debug_check_bounds::<Self>(offset);
1227            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1228            // Verify that padding bytes are zero.
1229            // Copy from the buffer into the object.
1230            unsafe {
1231                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1232            }
1233            Ok(())
1234        }
1235    }
1236
1237    impl fidl::encoding::ValueTypeMarker for ControllerSpawnConsoleResponse {
1238        type Borrowed<'a> = &'a Self;
1239        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1240            value
1241        }
1242    }
1243
1244    unsafe impl fidl::encoding::TypeMarker for ControllerSpawnConsoleResponse {
1245        type Owned = Self;
1246
1247        #[inline(always)]
1248        fn inline_align(_context: fidl::encoding::Context) -> usize {
1249            1
1250        }
1251
1252        #[inline(always)]
1253        fn inline_size(_context: fidl::encoding::Context) -> usize {
1254            1
1255        }
1256        #[inline(always)]
1257        fn encode_is_copy() -> bool {
1258            true
1259        }
1260
1261        #[inline(always)]
1262        fn decode_is_copy() -> bool {
1263            true
1264        }
1265    }
1266
1267    unsafe impl<D: fidl::encoding::ResourceDialect>
1268        fidl::encoding::Encode<ControllerSpawnConsoleResponse, D>
1269        for &ControllerSpawnConsoleResponse
1270    {
1271        #[inline]
1272        unsafe fn encode(
1273            self,
1274            encoder: &mut fidl::encoding::Encoder<'_, D>,
1275            offset: usize,
1276            _depth: fidl::encoding::Depth,
1277        ) -> fidl::Result<()> {
1278            encoder.debug_check_bounds::<ControllerSpawnConsoleResponse>(offset);
1279            unsafe {
1280                // Copy the object into the buffer.
1281                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1282                (buf_ptr as *mut ControllerSpawnConsoleResponse)
1283                    .write_unaligned((self as *const ControllerSpawnConsoleResponse).read());
1284                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1285                // done second because the memcpy will write garbage to these bytes.
1286            }
1287            Ok(())
1288        }
1289    }
1290    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1291        fidl::encoding::Encode<ControllerSpawnConsoleResponse, D> for (T0,)
1292    {
1293        #[inline]
1294        unsafe fn encode(
1295            self,
1296            encoder: &mut fidl::encoding::Encoder<'_, D>,
1297            offset: usize,
1298            depth: fidl::encoding::Depth,
1299        ) -> fidl::Result<()> {
1300            encoder.debug_check_bounds::<ControllerSpawnConsoleResponse>(offset);
1301            // Zero out padding regions. There's no need to apply masks
1302            // because the unmasked parts will be overwritten by fields.
1303            // Write the fields.
1304            self.0.encode(encoder, offset + 0, depth)?;
1305            Ok(())
1306        }
1307    }
1308
1309    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1310        for ControllerSpawnConsoleResponse
1311    {
1312        #[inline(always)]
1313        fn new_empty() -> Self {
1314            Self { exit_code: fidl::new_empty!(u8, D) }
1315        }
1316
1317        #[inline]
1318        unsafe fn decode(
1319            &mut self,
1320            decoder: &mut fidl::encoding::Decoder<'_, D>,
1321            offset: usize,
1322            _depth: fidl::encoding::Depth,
1323        ) -> fidl::Result<()> {
1324            decoder.debug_check_bounds::<Self>(offset);
1325            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1326            // Verify that padding bytes are zero.
1327            // Copy from the buffer into the object.
1328            unsafe {
1329                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1330            }
1331            Ok(())
1332        }
1333    }
1334
1335    impl ControllerGetVmoReferencesRequest {
1336        #[inline(always)]
1337        fn max_ordinal_present(&self) -> u64 {
1338            if let Some(_) = self.koid {
1339                return 1;
1340            }
1341            0
1342        }
1343    }
1344
1345    impl fidl::encoding::ValueTypeMarker for ControllerGetVmoReferencesRequest {
1346        type Borrowed<'a> = &'a Self;
1347        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1348            value
1349        }
1350    }
1351
1352    unsafe impl fidl::encoding::TypeMarker for ControllerGetVmoReferencesRequest {
1353        type Owned = Self;
1354
1355        #[inline(always)]
1356        fn inline_align(_context: fidl::encoding::Context) -> usize {
1357            8
1358        }
1359
1360        #[inline(always)]
1361        fn inline_size(_context: fidl::encoding::Context) -> usize {
1362            16
1363        }
1364    }
1365
1366    unsafe impl<D: fidl::encoding::ResourceDialect>
1367        fidl::encoding::Encode<ControllerGetVmoReferencesRequest, D>
1368        for &ControllerGetVmoReferencesRequest
1369    {
1370        unsafe fn encode(
1371            self,
1372            encoder: &mut fidl::encoding::Encoder<'_, D>,
1373            offset: usize,
1374            mut depth: fidl::encoding::Depth,
1375        ) -> fidl::Result<()> {
1376            encoder.debug_check_bounds::<ControllerGetVmoReferencesRequest>(offset);
1377            // Vector header
1378            let max_ordinal: u64 = self.max_ordinal_present();
1379            encoder.write_num(max_ordinal, offset);
1380            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1381            // Calling encoder.out_of_line_offset(0) is not allowed.
1382            if max_ordinal == 0 {
1383                return Ok(());
1384            }
1385            depth.increment()?;
1386            let envelope_size = 8;
1387            let bytes_len = max_ordinal as usize * envelope_size;
1388            #[allow(unused_variables)]
1389            let offset = encoder.out_of_line_offset(bytes_len);
1390            let mut _prev_end_offset: usize = 0;
1391            if 1 > max_ordinal {
1392                return Ok(());
1393            }
1394
1395            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1396            // are envelope_size bytes.
1397            let cur_offset: usize = (1 - 1) * envelope_size;
1398
1399            // Zero reserved fields.
1400            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1401
1402            // Safety:
1403            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1404            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1405            //   envelope_size bytes, there is always sufficient room.
1406            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1407                self.koid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1408                encoder,
1409                offset + cur_offset,
1410                depth,
1411            )?;
1412
1413            _prev_end_offset = cur_offset + envelope_size;
1414
1415            Ok(())
1416        }
1417    }
1418
1419    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1420        for ControllerGetVmoReferencesRequest
1421    {
1422        #[inline(always)]
1423        fn new_empty() -> Self {
1424            Self::default()
1425        }
1426
1427        unsafe fn decode(
1428            &mut self,
1429            decoder: &mut fidl::encoding::Decoder<'_, D>,
1430            offset: usize,
1431            mut depth: fidl::encoding::Depth,
1432        ) -> fidl::Result<()> {
1433            decoder.debug_check_bounds::<Self>(offset);
1434            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1435                None => return Err(fidl::Error::NotNullable),
1436                Some(len) => len,
1437            };
1438            // Calling decoder.out_of_line_offset(0) is not allowed.
1439            if len == 0 {
1440                return Ok(());
1441            };
1442            depth.increment()?;
1443            let envelope_size = 8;
1444            let bytes_len = len * envelope_size;
1445            let offset = decoder.out_of_line_offset(bytes_len)?;
1446            // Decode the envelope for each type.
1447            let mut _next_ordinal_to_read = 0;
1448            let mut next_offset = offset;
1449            let end_offset = offset + bytes_len;
1450            _next_ordinal_to_read += 1;
1451            if next_offset >= end_offset {
1452                return Ok(());
1453            }
1454
1455            // Decode unknown envelopes for gaps in ordinals.
1456            while _next_ordinal_to_read < 1 {
1457                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1458                _next_ordinal_to_read += 1;
1459                next_offset += envelope_size;
1460            }
1461
1462            let next_out_of_line = decoder.next_out_of_line();
1463            let handles_before = decoder.remaining_handles();
1464            if let Some((inlined, num_bytes, num_handles)) =
1465                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1466            {
1467                let member_inline_size =
1468                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1469                if inlined != (member_inline_size <= 4) {
1470                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1471                }
1472                let inner_offset;
1473                let mut inner_depth = depth.clone();
1474                if inlined {
1475                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1476                    inner_offset = next_offset;
1477                } else {
1478                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1479                    inner_depth.increment()?;
1480                }
1481                let val_ref = self.koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
1482                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1483                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1484                {
1485                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1486                }
1487                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1488                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1489                }
1490            }
1491
1492            next_offset += envelope_size;
1493
1494            // Decode the remaining unknown envelopes.
1495            while next_offset < end_offset {
1496                _next_ordinal_to_read += 1;
1497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1498                next_offset += envelope_size;
1499            }
1500
1501            Ok(())
1502        }
1503    }
1504
1505    impl ControllerSpawnConsoleRequest {
1506        #[inline(always)]
1507        fn max_ordinal_present(&self) -> u64 {
1508            if let Some(_) = self.window_size {
1509                return 6;
1510            }
1511            if let Some(_) = self.environ {
1512                return 5;
1513            }
1514            if let Some(_) = self.argv {
1515                return 4;
1516            }
1517            if let Some(_) = self.binary_path {
1518                return 3;
1519            }
1520            if let Some(_) = self.console_out {
1521                return 2;
1522            }
1523            if let Some(_) = self.console_in {
1524                return 1;
1525            }
1526            0
1527        }
1528    }
1529
1530    impl fidl::encoding::ResourceTypeMarker for ControllerSpawnConsoleRequest {
1531        type Borrowed<'a> = &'a mut Self;
1532        fn take_or_borrow<'a>(
1533            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1534        ) -> Self::Borrowed<'a> {
1535            value
1536        }
1537    }
1538
1539    unsafe impl fidl::encoding::TypeMarker for ControllerSpawnConsoleRequest {
1540        type Owned = Self;
1541
1542        #[inline(always)]
1543        fn inline_align(_context: fidl::encoding::Context) -> usize {
1544            8
1545        }
1546
1547        #[inline(always)]
1548        fn inline_size(_context: fidl::encoding::Context) -> usize {
1549            16
1550        }
1551    }
1552
1553    unsafe impl
1554        fidl::encoding::Encode<
1555            ControllerSpawnConsoleRequest,
1556            fidl::encoding::DefaultFuchsiaResourceDialect,
1557        > for &mut ControllerSpawnConsoleRequest
1558    {
1559        unsafe fn encode(
1560            self,
1561            encoder: &mut fidl::encoding::Encoder<
1562                '_,
1563                fidl::encoding::DefaultFuchsiaResourceDialect,
1564            >,
1565            offset: usize,
1566            mut depth: fidl::encoding::Depth,
1567        ) -> fidl::Result<()> {
1568            encoder.debug_check_bounds::<ControllerSpawnConsoleRequest>(offset);
1569            // Vector header
1570            let max_ordinal: u64 = self.max_ordinal_present();
1571            encoder.write_num(max_ordinal, offset);
1572            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1573            // Calling encoder.out_of_line_offset(0) is not allowed.
1574            if max_ordinal == 0 {
1575                return Ok(());
1576            }
1577            depth.increment()?;
1578            let envelope_size = 8;
1579            let bytes_len = max_ordinal as usize * envelope_size;
1580            #[allow(unused_variables)]
1581            let offset = encoder.out_of_line_offset(bytes_len);
1582            let mut _prev_end_offset: usize = 0;
1583            if 1 > max_ordinal {
1584                return Ok(());
1585            }
1586
1587            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1588            // are envelope_size bytes.
1589            let cur_offset: usize = (1 - 1) * envelope_size;
1590
1591            // Zero reserved fields.
1592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1593
1594            // Safety:
1595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1597            //   envelope_size bytes, there is always sufficient room.
1598            fidl::encoding::encode_in_envelope_optional::<
1599                fidl::encoding::HandleType<
1600                    fidl::Socket,
1601                    { fidl::ObjectType::SOCKET.into_raw() },
1602                    2147483648,
1603                >,
1604                fidl::encoding::DefaultFuchsiaResourceDialect,
1605            >(
1606                self.console_in.as_mut().map(
1607                    <fidl::encoding::HandleType<
1608                        fidl::Socket,
1609                        { fidl::ObjectType::SOCKET.into_raw() },
1610                        2147483648,
1611                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1612                ),
1613                encoder,
1614                offset + cur_offset,
1615                depth,
1616            )?;
1617
1618            _prev_end_offset = cur_offset + envelope_size;
1619            if 2 > max_ordinal {
1620                return Ok(());
1621            }
1622
1623            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1624            // are envelope_size bytes.
1625            let cur_offset: usize = (2 - 1) * envelope_size;
1626
1627            // Zero reserved fields.
1628            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1629
1630            // Safety:
1631            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1632            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1633            //   envelope_size bytes, there is always sufficient room.
1634            fidl::encoding::encode_in_envelope_optional::<
1635                fidl::encoding::HandleType<
1636                    fidl::Socket,
1637                    { fidl::ObjectType::SOCKET.into_raw() },
1638                    2147483648,
1639                >,
1640                fidl::encoding::DefaultFuchsiaResourceDialect,
1641            >(
1642                self.console_out.as_mut().map(
1643                    <fidl::encoding::HandleType<
1644                        fidl::Socket,
1645                        { fidl::ObjectType::SOCKET.into_raw() },
1646                        2147483648,
1647                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1648                ),
1649                encoder,
1650                offset + cur_offset,
1651                depth,
1652            )?;
1653
1654            _prev_end_offset = cur_offset + envelope_size;
1655            if 3 > max_ordinal {
1656                return Ok(());
1657            }
1658
1659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1660            // are envelope_size bytes.
1661            let cur_offset: usize = (3 - 1) * envelope_size;
1662
1663            // Zero reserved fields.
1664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1665
1666            // Safety:
1667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1669            //   envelope_size bytes, there is always sufficient room.
1670            fidl::encoding::encode_in_envelope_optional::<
1671                fidl::encoding::UnboundedString,
1672                fidl::encoding::DefaultFuchsiaResourceDialect,
1673            >(
1674                self.binary_path.as_ref().map(
1675                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1676                ),
1677                encoder,
1678                offset + cur_offset,
1679                depth,
1680            )?;
1681
1682            _prev_end_offset = cur_offset + envelope_size;
1683            if 4 > max_ordinal {
1684                return Ok(());
1685            }
1686
1687            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1688            // are envelope_size bytes.
1689            let cur_offset: usize = (4 - 1) * envelope_size;
1690
1691            // Zero reserved fields.
1692            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1693
1694            // Safety:
1695            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1696            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1697            //   envelope_size bytes, there is always sufficient room.
1698            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1699            self.argv.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
1700            encoder, offset + cur_offset, depth
1701        )?;
1702
1703            _prev_end_offset = cur_offset + envelope_size;
1704            if 5 > max_ordinal {
1705                return Ok(());
1706            }
1707
1708            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1709            // are envelope_size bytes.
1710            let cur_offset: usize = (5 - 1) * envelope_size;
1711
1712            // Zero reserved fields.
1713            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1714
1715            // Safety:
1716            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1717            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1718            //   envelope_size bytes, there is always sufficient room.
1719            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1720            self.environ.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
1721            encoder, offset + cur_offset, depth
1722        )?;
1723
1724            _prev_end_offset = cur_offset + envelope_size;
1725            if 6 > max_ordinal {
1726                return Ok(());
1727            }
1728
1729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1730            // are envelope_size bytes.
1731            let cur_offset: usize = (6 - 1) * envelope_size;
1732
1733            // Zero reserved fields.
1734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1735
1736            // Safety:
1737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1739            //   envelope_size bytes, there is always sufficient room.
1740            fidl::encoding::encode_in_envelope_optional::<
1741                ConsoleWindowSize,
1742                fidl::encoding::DefaultFuchsiaResourceDialect,
1743            >(
1744                self.window_size
1745                    .as_ref()
1746                    .map(<ConsoleWindowSize as fidl::encoding::ValueTypeMarker>::borrow),
1747                encoder,
1748                offset + cur_offset,
1749                depth,
1750            )?;
1751
1752            _prev_end_offset = cur_offset + envelope_size;
1753
1754            Ok(())
1755        }
1756    }
1757
1758    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1759        for ControllerSpawnConsoleRequest
1760    {
1761        #[inline(always)]
1762        fn new_empty() -> Self {
1763            Self::default()
1764        }
1765
1766        unsafe fn decode(
1767            &mut self,
1768            decoder: &mut fidl::encoding::Decoder<
1769                '_,
1770                fidl::encoding::DefaultFuchsiaResourceDialect,
1771            >,
1772            offset: usize,
1773            mut depth: fidl::encoding::Depth,
1774        ) -> fidl::Result<()> {
1775            decoder.debug_check_bounds::<Self>(offset);
1776            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1777                None => return Err(fidl::Error::NotNullable),
1778                Some(len) => len,
1779            };
1780            // Calling decoder.out_of_line_offset(0) is not allowed.
1781            if len == 0 {
1782                return Ok(());
1783            };
1784            depth.increment()?;
1785            let envelope_size = 8;
1786            let bytes_len = len * envelope_size;
1787            let offset = decoder.out_of_line_offset(bytes_len)?;
1788            // Decode the envelope for each type.
1789            let mut _next_ordinal_to_read = 0;
1790            let mut next_offset = offset;
1791            let end_offset = offset + bytes_len;
1792            _next_ordinal_to_read += 1;
1793            if next_offset >= end_offset {
1794                return Ok(());
1795            }
1796
1797            // Decode unknown envelopes for gaps in ordinals.
1798            while _next_ordinal_to_read < 1 {
1799                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1800                _next_ordinal_to_read += 1;
1801                next_offset += envelope_size;
1802            }
1803
1804            let next_out_of_line = decoder.next_out_of_line();
1805            let handles_before = decoder.remaining_handles();
1806            if let Some((inlined, num_bytes, num_handles)) =
1807                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1808            {
1809                let member_inline_size = <fidl::encoding::HandleType<
1810                    fidl::Socket,
1811                    { fidl::ObjectType::SOCKET.into_raw() },
1812                    2147483648,
1813                > as fidl::encoding::TypeMarker>::inline_size(
1814                    decoder.context
1815                );
1816                if inlined != (member_inline_size <= 4) {
1817                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1818                }
1819                let inner_offset;
1820                let mut inner_depth = depth.clone();
1821                if inlined {
1822                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1823                    inner_offset = next_offset;
1824                } else {
1825                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1826                    inner_depth.increment()?;
1827                }
1828                let val_ref =
1829                self.console_in.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
1830                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
1831                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1832                {
1833                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1834                }
1835                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1836                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1837                }
1838            }
1839
1840            next_offset += envelope_size;
1841            _next_ordinal_to_read += 1;
1842            if next_offset >= end_offset {
1843                return Ok(());
1844            }
1845
1846            // Decode unknown envelopes for gaps in ordinals.
1847            while _next_ordinal_to_read < 2 {
1848                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1849                _next_ordinal_to_read += 1;
1850                next_offset += envelope_size;
1851            }
1852
1853            let next_out_of_line = decoder.next_out_of_line();
1854            let handles_before = decoder.remaining_handles();
1855            if let Some((inlined, num_bytes, num_handles)) =
1856                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1857            {
1858                let member_inline_size = <fidl::encoding::HandleType<
1859                    fidl::Socket,
1860                    { fidl::ObjectType::SOCKET.into_raw() },
1861                    2147483648,
1862                > as fidl::encoding::TypeMarker>::inline_size(
1863                    decoder.context
1864                );
1865                if inlined != (member_inline_size <= 4) {
1866                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1867                }
1868                let inner_offset;
1869                let mut inner_depth = depth.clone();
1870                if inlined {
1871                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1872                    inner_offset = next_offset;
1873                } else {
1874                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1875                    inner_depth.increment()?;
1876                }
1877                let val_ref =
1878                self.console_out.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
1879                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
1880                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1881                {
1882                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1883                }
1884                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1885                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1886                }
1887            }
1888
1889            next_offset += envelope_size;
1890            _next_ordinal_to_read += 1;
1891            if next_offset >= end_offset {
1892                return Ok(());
1893            }
1894
1895            // Decode unknown envelopes for gaps in ordinals.
1896            while _next_ordinal_to_read < 3 {
1897                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1898                _next_ordinal_to_read += 1;
1899                next_offset += envelope_size;
1900            }
1901
1902            let next_out_of_line = decoder.next_out_of_line();
1903            let handles_before = decoder.remaining_handles();
1904            if let Some((inlined, num_bytes, num_handles)) =
1905                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1906            {
1907                let member_inline_size =
1908                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1909                        decoder.context,
1910                    );
1911                if inlined != (member_inline_size <= 4) {
1912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1913                }
1914                let inner_offset;
1915                let mut inner_depth = depth.clone();
1916                if inlined {
1917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1918                    inner_offset = next_offset;
1919                } else {
1920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1921                    inner_depth.increment()?;
1922                }
1923                let val_ref = self.binary_path.get_or_insert_with(|| {
1924                    fidl::new_empty!(
1925                        fidl::encoding::UnboundedString,
1926                        fidl::encoding::DefaultFuchsiaResourceDialect
1927                    )
1928                });
1929                fidl::decode!(
1930                    fidl::encoding::UnboundedString,
1931                    fidl::encoding::DefaultFuchsiaResourceDialect,
1932                    val_ref,
1933                    decoder,
1934                    inner_offset,
1935                    inner_depth
1936                )?;
1937                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1938                {
1939                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1940                }
1941                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1942                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1943                }
1944            }
1945
1946            next_offset += envelope_size;
1947            _next_ordinal_to_read += 1;
1948            if next_offset >= end_offset {
1949                return Ok(());
1950            }
1951
1952            // Decode unknown envelopes for gaps in ordinals.
1953            while _next_ordinal_to_read < 4 {
1954                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1955                _next_ordinal_to_read += 1;
1956                next_offset += envelope_size;
1957            }
1958
1959            let next_out_of_line = decoder.next_out_of_line();
1960            let handles_before = decoder.remaining_handles();
1961            if let Some((inlined, num_bytes, num_handles)) =
1962                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1963            {
1964                let member_inline_size = <fidl::encoding::UnboundedVector<
1965                    fidl::encoding::UnboundedString,
1966                > as fidl::encoding::TypeMarker>::inline_size(
1967                    decoder.context
1968                );
1969                if inlined != (member_inline_size <= 4) {
1970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1971                }
1972                let inner_offset;
1973                let mut inner_depth = depth.clone();
1974                if inlined {
1975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1976                    inner_offset = next_offset;
1977                } else {
1978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1979                    inner_depth.increment()?;
1980                }
1981                let val_ref = self.argv.get_or_insert_with(|| {
1982                    fidl::new_empty!(
1983                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1984                        fidl::encoding::DefaultFuchsiaResourceDialect
1985                    )
1986                });
1987                fidl::decode!(
1988                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1989                    fidl::encoding::DefaultFuchsiaResourceDialect,
1990                    val_ref,
1991                    decoder,
1992                    inner_offset,
1993                    inner_depth
1994                )?;
1995                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1996                {
1997                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1998                }
1999                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2000                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2001                }
2002            }
2003
2004            next_offset += envelope_size;
2005            _next_ordinal_to_read += 1;
2006            if next_offset >= end_offset {
2007                return Ok(());
2008            }
2009
2010            // Decode unknown envelopes for gaps in ordinals.
2011            while _next_ordinal_to_read < 5 {
2012                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2013                _next_ordinal_to_read += 1;
2014                next_offset += envelope_size;
2015            }
2016
2017            let next_out_of_line = decoder.next_out_of_line();
2018            let handles_before = decoder.remaining_handles();
2019            if let Some((inlined, num_bytes, num_handles)) =
2020                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2021            {
2022                let member_inline_size = <fidl::encoding::UnboundedVector<
2023                    fidl::encoding::UnboundedString,
2024                > as fidl::encoding::TypeMarker>::inline_size(
2025                    decoder.context
2026                );
2027                if inlined != (member_inline_size <= 4) {
2028                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2029                }
2030                let inner_offset;
2031                let mut inner_depth = depth.clone();
2032                if inlined {
2033                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2034                    inner_offset = next_offset;
2035                } else {
2036                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2037                    inner_depth.increment()?;
2038                }
2039                let val_ref = self.environ.get_or_insert_with(|| {
2040                    fidl::new_empty!(
2041                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2042                        fidl::encoding::DefaultFuchsiaResourceDialect
2043                    )
2044                });
2045                fidl::decode!(
2046                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2047                    fidl::encoding::DefaultFuchsiaResourceDialect,
2048                    val_ref,
2049                    decoder,
2050                    inner_offset,
2051                    inner_depth
2052                )?;
2053                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2054                {
2055                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2056                }
2057                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2058                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2059                }
2060            }
2061
2062            next_offset += envelope_size;
2063            _next_ordinal_to_read += 1;
2064            if next_offset >= end_offset {
2065                return Ok(());
2066            }
2067
2068            // Decode unknown envelopes for gaps in ordinals.
2069            while _next_ordinal_to_read < 6 {
2070                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2071                _next_ordinal_to_read += 1;
2072                next_offset += envelope_size;
2073            }
2074
2075            let next_out_of_line = decoder.next_out_of_line();
2076            let handles_before = decoder.remaining_handles();
2077            if let Some((inlined, num_bytes, num_handles)) =
2078                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2079            {
2080                let member_inline_size =
2081                    <ConsoleWindowSize as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2082                if inlined != (member_inline_size <= 4) {
2083                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2084                }
2085                let inner_offset;
2086                let mut inner_depth = depth.clone();
2087                if inlined {
2088                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2089                    inner_offset = next_offset;
2090                } else {
2091                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2092                    inner_depth.increment()?;
2093                }
2094                let val_ref = self.window_size.get_or_insert_with(|| {
2095                    fidl::new_empty!(
2096                        ConsoleWindowSize,
2097                        fidl::encoding::DefaultFuchsiaResourceDialect
2098                    )
2099                });
2100                fidl::decode!(
2101                    ConsoleWindowSize,
2102                    fidl::encoding::DefaultFuchsiaResourceDialect,
2103                    val_ref,
2104                    decoder,
2105                    inner_offset,
2106                    inner_depth
2107                )?;
2108                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2109                {
2110                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2111                }
2112                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2113                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2114                }
2115            }
2116
2117            next_offset += envelope_size;
2118
2119            // Decode the remaining unknown envelopes.
2120            while next_offset < end_offset {
2121                _next_ordinal_to_read += 1;
2122                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2123                next_offset += envelope_size;
2124            }
2125
2126            Ok(())
2127        }
2128    }
2129
2130    impl ControllerVsockConnectRequest {
2131        #[inline(always)]
2132        fn max_ordinal_present(&self) -> u64 {
2133            if let Some(_) = self.bridge_socket {
2134                return 2;
2135            }
2136            if let Some(_) = self.port {
2137                return 1;
2138            }
2139            0
2140        }
2141    }
2142
2143    impl fidl::encoding::ResourceTypeMarker for ControllerVsockConnectRequest {
2144        type Borrowed<'a> = &'a mut Self;
2145        fn take_or_borrow<'a>(
2146            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2147        ) -> Self::Borrowed<'a> {
2148            value
2149        }
2150    }
2151
2152    unsafe impl fidl::encoding::TypeMarker for ControllerVsockConnectRequest {
2153        type Owned = Self;
2154
2155        #[inline(always)]
2156        fn inline_align(_context: fidl::encoding::Context) -> usize {
2157            8
2158        }
2159
2160        #[inline(always)]
2161        fn inline_size(_context: fidl::encoding::Context) -> usize {
2162            16
2163        }
2164    }
2165
2166    unsafe impl
2167        fidl::encoding::Encode<
2168            ControllerVsockConnectRequest,
2169            fidl::encoding::DefaultFuchsiaResourceDialect,
2170        > for &mut ControllerVsockConnectRequest
2171    {
2172        unsafe fn encode(
2173            self,
2174            encoder: &mut fidl::encoding::Encoder<
2175                '_,
2176                fidl::encoding::DefaultFuchsiaResourceDialect,
2177            >,
2178            offset: usize,
2179            mut depth: fidl::encoding::Depth,
2180        ) -> fidl::Result<()> {
2181            encoder.debug_check_bounds::<ControllerVsockConnectRequest>(offset);
2182            // Vector header
2183            let max_ordinal: u64 = self.max_ordinal_present();
2184            encoder.write_num(max_ordinal, offset);
2185            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2186            // Calling encoder.out_of_line_offset(0) is not allowed.
2187            if max_ordinal == 0 {
2188                return Ok(());
2189            }
2190            depth.increment()?;
2191            let envelope_size = 8;
2192            let bytes_len = max_ordinal as usize * envelope_size;
2193            #[allow(unused_variables)]
2194            let offset = encoder.out_of_line_offset(bytes_len);
2195            let mut _prev_end_offset: usize = 0;
2196            if 1 > max_ordinal {
2197                return Ok(());
2198            }
2199
2200            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2201            // are envelope_size bytes.
2202            let cur_offset: usize = (1 - 1) * envelope_size;
2203
2204            // Zero reserved fields.
2205            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2206
2207            // Safety:
2208            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2209            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2210            //   envelope_size bytes, there is always sufficient room.
2211            fidl::encoding::encode_in_envelope_optional::<
2212                u32,
2213                fidl::encoding::DefaultFuchsiaResourceDialect,
2214            >(
2215                self.port.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2216                encoder,
2217                offset + cur_offset,
2218                depth,
2219            )?;
2220
2221            _prev_end_offset = cur_offset + envelope_size;
2222            if 2 > max_ordinal {
2223                return Ok(());
2224            }
2225
2226            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2227            // are envelope_size bytes.
2228            let cur_offset: usize = (2 - 1) * envelope_size;
2229
2230            // Zero reserved fields.
2231            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2232
2233            // Safety:
2234            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2235            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2236            //   envelope_size bytes, there is always sufficient room.
2237            fidl::encoding::encode_in_envelope_optional::<
2238                fidl::encoding::HandleType<
2239                    fidl::Socket,
2240                    { fidl::ObjectType::SOCKET.into_raw() },
2241                    2147483648,
2242                >,
2243                fidl::encoding::DefaultFuchsiaResourceDialect,
2244            >(
2245                self.bridge_socket.as_mut().map(
2246                    <fidl::encoding::HandleType<
2247                        fidl::Socket,
2248                        { fidl::ObjectType::SOCKET.into_raw() },
2249                        2147483648,
2250                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2251                ),
2252                encoder,
2253                offset + cur_offset,
2254                depth,
2255            )?;
2256
2257            _prev_end_offset = cur_offset + envelope_size;
2258
2259            Ok(())
2260        }
2261    }
2262
2263    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2264        for ControllerVsockConnectRequest
2265    {
2266        #[inline(always)]
2267        fn new_empty() -> Self {
2268            Self::default()
2269        }
2270
2271        unsafe fn decode(
2272            &mut self,
2273            decoder: &mut fidl::encoding::Decoder<
2274                '_,
2275                fidl::encoding::DefaultFuchsiaResourceDialect,
2276            >,
2277            offset: usize,
2278            mut depth: fidl::encoding::Depth,
2279        ) -> fidl::Result<()> {
2280            decoder.debug_check_bounds::<Self>(offset);
2281            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2282                None => return Err(fidl::Error::NotNullable),
2283                Some(len) => len,
2284            };
2285            // Calling decoder.out_of_line_offset(0) is not allowed.
2286            if len == 0 {
2287                return Ok(());
2288            };
2289            depth.increment()?;
2290            let envelope_size = 8;
2291            let bytes_len = len * envelope_size;
2292            let offset = decoder.out_of_line_offset(bytes_len)?;
2293            // Decode the envelope for each type.
2294            let mut _next_ordinal_to_read = 0;
2295            let mut next_offset = offset;
2296            let end_offset = offset + bytes_len;
2297            _next_ordinal_to_read += 1;
2298            if next_offset >= end_offset {
2299                return Ok(());
2300            }
2301
2302            // Decode unknown envelopes for gaps in ordinals.
2303            while _next_ordinal_to_read < 1 {
2304                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2305                _next_ordinal_to_read += 1;
2306                next_offset += envelope_size;
2307            }
2308
2309            let next_out_of_line = decoder.next_out_of_line();
2310            let handles_before = decoder.remaining_handles();
2311            if let Some((inlined, num_bytes, num_handles)) =
2312                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2313            {
2314                let member_inline_size =
2315                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2316                if inlined != (member_inline_size <= 4) {
2317                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2318                }
2319                let inner_offset;
2320                let mut inner_depth = depth.clone();
2321                if inlined {
2322                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2323                    inner_offset = next_offset;
2324                } else {
2325                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2326                    inner_depth.increment()?;
2327                }
2328                let val_ref = self.port.get_or_insert_with(|| {
2329                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
2330                });
2331                fidl::decode!(
2332                    u32,
2333                    fidl::encoding::DefaultFuchsiaResourceDialect,
2334                    val_ref,
2335                    decoder,
2336                    inner_offset,
2337                    inner_depth
2338                )?;
2339                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2340                {
2341                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2342                }
2343                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2344                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2345                }
2346            }
2347
2348            next_offset += envelope_size;
2349            _next_ordinal_to_read += 1;
2350            if next_offset >= end_offset {
2351                return Ok(());
2352            }
2353
2354            // Decode unknown envelopes for gaps in ordinals.
2355            while _next_ordinal_to_read < 2 {
2356                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2357                _next_ordinal_to_read += 1;
2358                next_offset += envelope_size;
2359            }
2360
2361            let next_out_of_line = decoder.next_out_of_line();
2362            let handles_before = decoder.remaining_handles();
2363            if let Some((inlined, num_bytes, num_handles)) =
2364                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2365            {
2366                let member_inline_size = <fidl::encoding::HandleType<
2367                    fidl::Socket,
2368                    { fidl::ObjectType::SOCKET.into_raw() },
2369                    2147483648,
2370                > as fidl::encoding::TypeMarker>::inline_size(
2371                    decoder.context
2372                );
2373                if inlined != (member_inline_size <= 4) {
2374                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2375                }
2376                let inner_offset;
2377                let mut inner_depth = depth.clone();
2378                if inlined {
2379                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2380                    inner_offset = next_offset;
2381                } else {
2382                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2383                    inner_depth.increment()?;
2384                }
2385                let val_ref =
2386                self.bridge_socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2387                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2388                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2389                {
2390                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2391                }
2392                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2393                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2394                }
2395            }
2396
2397            next_offset += envelope_size;
2398
2399            // Decode the remaining unknown envelopes.
2400            while next_offset < end_offset {
2401                _next_ordinal_to_read += 1;
2402                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2403                next_offset += envelope_size;
2404            }
2405
2406            Ok(())
2407        }
2408    }
2409
2410    impl ControllerGetJobHandleResponse {
2411        #[inline(always)]
2412        fn max_ordinal_present(&self) -> u64 {
2413            if let Some(_) = self.job {
2414                return 1;
2415            }
2416            0
2417        }
2418    }
2419
2420    impl fidl::encoding::ResourceTypeMarker for ControllerGetJobHandleResponse {
2421        type Borrowed<'a> = &'a mut Self;
2422        fn take_or_borrow<'a>(
2423            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2424        ) -> Self::Borrowed<'a> {
2425            value
2426        }
2427    }
2428
2429    unsafe impl fidl::encoding::TypeMarker for ControllerGetJobHandleResponse {
2430        type Owned = Self;
2431
2432        #[inline(always)]
2433        fn inline_align(_context: fidl::encoding::Context) -> usize {
2434            8
2435        }
2436
2437        #[inline(always)]
2438        fn inline_size(_context: fidl::encoding::Context) -> usize {
2439            16
2440        }
2441    }
2442
2443    unsafe impl
2444        fidl::encoding::Encode<
2445            ControllerGetJobHandleResponse,
2446            fidl::encoding::DefaultFuchsiaResourceDialect,
2447        > for &mut ControllerGetJobHandleResponse
2448    {
2449        unsafe fn encode(
2450            self,
2451            encoder: &mut fidl::encoding::Encoder<
2452                '_,
2453                fidl::encoding::DefaultFuchsiaResourceDialect,
2454            >,
2455            offset: usize,
2456            mut depth: fidl::encoding::Depth,
2457        ) -> fidl::Result<()> {
2458            encoder.debug_check_bounds::<ControllerGetJobHandleResponse>(offset);
2459            // Vector header
2460            let max_ordinal: u64 = self.max_ordinal_present();
2461            encoder.write_num(max_ordinal, offset);
2462            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2463            // Calling encoder.out_of_line_offset(0) is not allowed.
2464            if max_ordinal == 0 {
2465                return Ok(());
2466            }
2467            depth.increment()?;
2468            let envelope_size = 8;
2469            let bytes_len = max_ordinal as usize * envelope_size;
2470            #[allow(unused_variables)]
2471            let offset = encoder.out_of_line_offset(bytes_len);
2472            let mut _prev_end_offset: usize = 0;
2473            if 1 > max_ordinal {
2474                return Ok(());
2475            }
2476
2477            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2478            // are envelope_size bytes.
2479            let cur_offset: usize = (1 - 1) * envelope_size;
2480
2481            // Zero reserved fields.
2482            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2483
2484            // Safety:
2485            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2486            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2487            //   envelope_size bytes, there is always sufficient room.
2488            fidl::encoding::encode_in_envelope_optional::<
2489                fidl::encoding::HandleType<
2490                    fidl::Job,
2491                    { fidl::ObjectType::JOB.into_raw() },
2492                    2147483648,
2493                >,
2494                fidl::encoding::DefaultFuchsiaResourceDialect,
2495            >(
2496                self.job.as_mut().map(
2497                    <fidl::encoding::HandleType<
2498                        fidl::Job,
2499                        { fidl::ObjectType::JOB.into_raw() },
2500                        2147483648,
2501                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2502                ),
2503                encoder,
2504                offset + cur_offset,
2505                depth,
2506            )?;
2507
2508            _prev_end_offset = cur_offset + envelope_size;
2509
2510            Ok(())
2511        }
2512    }
2513
2514    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2515        for ControllerGetJobHandleResponse
2516    {
2517        #[inline(always)]
2518        fn new_empty() -> Self {
2519            Self::default()
2520        }
2521
2522        unsafe fn decode(
2523            &mut self,
2524            decoder: &mut fidl::encoding::Decoder<
2525                '_,
2526                fidl::encoding::DefaultFuchsiaResourceDialect,
2527            >,
2528            offset: usize,
2529            mut depth: fidl::encoding::Depth,
2530        ) -> fidl::Result<()> {
2531            decoder.debug_check_bounds::<Self>(offset);
2532            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2533                None => return Err(fidl::Error::NotNullable),
2534                Some(len) => len,
2535            };
2536            // Calling decoder.out_of_line_offset(0) is not allowed.
2537            if len == 0 {
2538                return Ok(());
2539            };
2540            depth.increment()?;
2541            let envelope_size = 8;
2542            let bytes_len = len * envelope_size;
2543            let offset = decoder.out_of_line_offset(bytes_len)?;
2544            // Decode the envelope for each type.
2545            let mut _next_ordinal_to_read = 0;
2546            let mut next_offset = offset;
2547            let end_offset = offset + bytes_len;
2548            _next_ordinal_to_read += 1;
2549            if next_offset >= end_offset {
2550                return Ok(());
2551            }
2552
2553            // Decode unknown envelopes for gaps in ordinals.
2554            while _next_ordinal_to_read < 1 {
2555                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2556                _next_ordinal_to_read += 1;
2557                next_offset += envelope_size;
2558            }
2559
2560            let next_out_of_line = decoder.next_out_of_line();
2561            let handles_before = decoder.remaining_handles();
2562            if let Some((inlined, num_bytes, num_handles)) =
2563                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2564            {
2565                let member_inline_size = <fidl::encoding::HandleType<
2566                    fidl::Job,
2567                    { fidl::ObjectType::JOB.into_raw() },
2568                    2147483648,
2569                > as fidl::encoding::TypeMarker>::inline_size(
2570                    decoder.context
2571                );
2572                if inlined != (member_inline_size <= 4) {
2573                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2574                }
2575                let inner_offset;
2576                let mut inner_depth = depth.clone();
2577                if inlined {
2578                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2579                    inner_offset = next_offset;
2580                } else {
2581                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2582                    inner_depth.increment()?;
2583                }
2584                let val_ref =
2585                self.job.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2586                fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2587                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2588                {
2589                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2590                }
2591                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2592                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2593                }
2594            }
2595
2596            next_offset += envelope_size;
2597
2598            // Decode the remaining unknown envelopes.
2599            while next_offset < end_offset {
2600                _next_ordinal_to_read += 1;
2601                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2602                next_offset += envelope_size;
2603            }
2604
2605            Ok(())
2606        }
2607    }
2608
2609    impl ControllerGetVmoReferencesResponse {
2610        #[inline(always)]
2611        fn max_ordinal_present(&self) -> u64 {
2612            if let Some(_) = self.references {
2613                return 1;
2614            }
2615            0
2616        }
2617    }
2618
2619    impl fidl::encoding::ValueTypeMarker for ControllerGetVmoReferencesResponse {
2620        type Borrowed<'a> = &'a Self;
2621        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2622            value
2623        }
2624    }
2625
2626    unsafe impl fidl::encoding::TypeMarker for ControllerGetVmoReferencesResponse {
2627        type Owned = Self;
2628
2629        #[inline(always)]
2630        fn inline_align(_context: fidl::encoding::Context) -> usize {
2631            8
2632        }
2633
2634        #[inline(always)]
2635        fn inline_size(_context: fidl::encoding::Context) -> usize {
2636            16
2637        }
2638    }
2639
2640    unsafe impl<D: fidl::encoding::ResourceDialect>
2641        fidl::encoding::Encode<ControllerGetVmoReferencesResponse, D>
2642        for &ControllerGetVmoReferencesResponse
2643    {
2644        unsafe fn encode(
2645            self,
2646            encoder: &mut fidl::encoding::Encoder<'_, D>,
2647            offset: usize,
2648            mut depth: fidl::encoding::Depth,
2649        ) -> fidl::Result<()> {
2650            encoder.debug_check_bounds::<ControllerGetVmoReferencesResponse>(offset);
2651            // Vector header
2652            let max_ordinal: u64 = self.max_ordinal_present();
2653            encoder.write_num(max_ordinal, offset);
2654            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2655            // Calling encoder.out_of_line_offset(0) is not allowed.
2656            if max_ordinal == 0 {
2657                return Ok(());
2658            }
2659            depth.increment()?;
2660            let envelope_size = 8;
2661            let bytes_len = max_ordinal as usize * envelope_size;
2662            #[allow(unused_variables)]
2663            let offset = encoder.out_of_line_offset(bytes_len);
2664            let mut _prev_end_offset: usize = 0;
2665            if 1 > max_ordinal {
2666                return Ok(());
2667            }
2668
2669            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2670            // are envelope_size bytes.
2671            let cur_offset: usize = (1 - 1) * envelope_size;
2672
2673            // Zero reserved fields.
2674            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2675
2676            // Safety:
2677            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2678            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2679            //   envelope_size bytes, there is always sufficient room.
2680            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<VmoReference>, D>(
2681            self.references.as_ref().map(<fidl::encoding::UnboundedVector<VmoReference> as fidl::encoding::ValueTypeMarker>::borrow),
2682            encoder, offset + cur_offset, depth
2683        )?;
2684
2685            _prev_end_offset = cur_offset + envelope_size;
2686
2687            Ok(())
2688        }
2689    }
2690
2691    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2692        for ControllerGetVmoReferencesResponse
2693    {
2694        #[inline(always)]
2695        fn new_empty() -> Self {
2696            Self::default()
2697        }
2698
2699        unsafe fn decode(
2700            &mut self,
2701            decoder: &mut fidl::encoding::Decoder<'_, D>,
2702            offset: usize,
2703            mut depth: fidl::encoding::Depth,
2704        ) -> fidl::Result<()> {
2705            decoder.debug_check_bounds::<Self>(offset);
2706            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2707                None => return Err(fidl::Error::NotNullable),
2708                Some(len) => len,
2709            };
2710            // Calling decoder.out_of_line_offset(0) is not allowed.
2711            if len == 0 {
2712                return Ok(());
2713            };
2714            depth.increment()?;
2715            let envelope_size = 8;
2716            let bytes_len = len * envelope_size;
2717            let offset = decoder.out_of_line_offset(bytes_len)?;
2718            // Decode the envelope for each type.
2719            let mut _next_ordinal_to_read = 0;
2720            let mut next_offset = offset;
2721            let end_offset = offset + bytes_len;
2722            _next_ordinal_to_read += 1;
2723            if next_offset >= end_offset {
2724                return Ok(());
2725            }
2726
2727            // Decode unknown envelopes for gaps in ordinals.
2728            while _next_ordinal_to_read < 1 {
2729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2730                _next_ordinal_to_read += 1;
2731                next_offset += envelope_size;
2732            }
2733
2734            let next_out_of_line = decoder.next_out_of_line();
2735            let handles_before = decoder.remaining_handles();
2736            if let Some((inlined, num_bytes, num_handles)) =
2737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2738            {
2739                let member_inline_size = <fidl::encoding::UnboundedVector<VmoReference> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2740                if inlined != (member_inline_size <= 4) {
2741                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2742                }
2743                let inner_offset;
2744                let mut inner_depth = depth.clone();
2745                if inlined {
2746                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2747                    inner_offset = next_offset;
2748                } else {
2749                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2750                    inner_depth.increment()?;
2751                }
2752                let val_ref = self.references.get_or_insert_with(|| {
2753                    fidl::new_empty!(fidl::encoding::UnboundedVector<VmoReference>, D)
2754                });
2755                fidl::decode!(
2756                    fidl::encoding::UnboundedVector<VmoReference>,
2757                    D,
2758                    val_ref,
2759                    decoder,
2760                    inner_offset,
2761                    inner_depth
2762                )?;
2763                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2764                {
2765                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2766                }
2767                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2768                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2769                }
2770            }
2771
2772            next_offset += envelope_size;
2773
2774            // Decode the remaining unknown envelopes.
2775            while next_offset < end_offset {
2776                _next_ordinal_to_read += 1;
2777                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2778                next_offset += envelope_size;
2779            }
2780
2781            Ok(())
2782        }
2783    }
2784
2785    impl VmoReference {
2786        #[inline(always)]
2787        fn max_ordinal_present(&self) -> u64 {
2788            if let Some(_) = self.koid {
2789                return 4;
2790            }
2791            if let Some(_) = self.fd {
2792                return 3;
2793            }
2794            if let Some(_) = self.pid {
2795                return 2;
2796            }
2797            if let Some(_) = self.process_name {
2798                return 1;
2799            }
2800            0
2801        }
2802    }
2803
2804    impl fidl::encoding::ValueTypeMarker for VmoReference {
2805        type Borrowed<'a> = &'a Self;
2806        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2807            value
2808        }
2809    }
2810
2811    unsafe impl fidl::encoding::TypeMarker for VmoReference {
2812        type Owned = Self;
2813
2814        #[inline(always)]
2815        fn inline_align(_context: fidl::encoding::Context) -> usize {
2816            8
2817        }
2818
2819        #[inline(always)]
2820        fn inline_size(_context: fidl::encoding::Context) -> usize {
2821            16
2822        }
2823    }
2824
2825    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VmoReference, D>
2826        for &VmoReference
2827    {
2828        unsafe fn encode(
2829            self,
2830            encoder: &mut fidl::encoding::Encoder<'_, D>,
2831            offset: usize,
2832            mut depth: fidl::encoding::Depth,
2833        ) -> fidl::Result<()> {
2834            encoder.debug_check_bounds::<VmoReference>(offset);
2835            // Vector header
2836            let max_ordinal: u64 = self.max_ordinal_present();
2837            encoder.write_num(max_ordinal, offset);
2838            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2839            // Calling encoder.out_of_line_offset(0) is not allowed.
2840            if max_ordinal == 0 {
2841                return Ok(());
2842            }
2843            depth.increment()?;
2844            let envelope_size = 8;
2845            let bytes_len = max_ordinal as usize * envelope_size;
2846            #[allow(unused_variables)]
2847            let offset = encoder.out_of_line_offset(bytes_len);
2848            let mut _prev_end_offset: usize = 0;
2849            if 1 > max_ordinal {
2850                return Ok(());
2851            }
2852
2853            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2854            // are envelope_size bytes.
2855            let cur_offset: usize = (1 - 1) * envelope_size;
2856
2857            // Zero reserved fields.
2858            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2859
2860            // Safety:
2861            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2862            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2863            //   envelope_size bytes, there is always sufficient room.
2864            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2865                self.process_name.as_ref().map(
2866                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2867                ),
2868                encoder,
2869                offset + cur_offset,
2870                depth,
2871            )?;
2872
2873            _prev_end_offset = cur_offset + envelope_size;
2874            if 2 > max_ordinal {
2875                return Ok(());
2876            }
2877
2878            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2879            // are envelope_size bytes.
2880            let cur_offset: usize = (2 - 1) * envelope_size;
2881
2882            // Zero reserved fields.
2883            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2884
2885            // Safety:
2886            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2887            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2888            //   envelope_size bytes, there is always sufficient room.
2889            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2890                self.pid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2891                encoder,
2892                offset + cur_offset,
2893                depth,
2894            )?;
2895
2896            _prev_end_offset = cur_offset + envelope_size;
2897            if 3 > max_ordinal {
2898                return Ok(());
2899            }
2900
2901            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2902            // are envelope_size bytes.
2903            let cur_offset: usize = (3 - 1) * envelope_size;
2904
2905            // Zero reserved fields.
2906            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2907
2908            // Safety:
2909            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2910            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2911            //   envelope_size bytes, there is always sufficient room.
2912            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2913                self.fd.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2914                encoder,
2915                offset + cur_offset,
2916                depth,
2917            )?;
2918
2919            _prev_end_offset = cur_offset + envelope_size;
2920            if 4 > max_ordinal {
2921                return Ok(());
2922            }
2923
2924            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2925            // are envelope_size bytes.
2926            let cur_offset: usize = (4 - 1) * envelope_size;
2927
2928            // Zero reserved fields.
2929            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2930
2931            // Safety:
2932            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2933            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2934            //   envelope_size bytes, there is always sufficient room.
2935            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2936                self.koid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2937                encoder,
2938                offset + cur_offset,
2939                depth,
2940            )?;
2941
2942            _prev_end_offset = cur_offset + envelope_size;
2943
2944            Ok(())
2945        }
2946    }
2947
2948    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmoReference {
2949        #[inline(always)]
2950        fn new_empty() -> Self {
2951            Self::default()
2952        }
2953
2954        unsafe fn decode(
2955            &mut self,
2956            decoder: &mut fidl::encoding::Decoder<'_, D>,
2957            offset: usize,
2958            mut depth: fidl::encoding::Depth,
2959        ) -> fidl::Result<()> {
2960            decoder.debug_check_bounds::<Self>(offset);
2961            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2962                None => return Err(fidl::Error::NotNullable),
2963                Some(len) => len,
2964            };
2965            // Calling decoder.out_of_line_offset(0) is not allowed.
2966            if len == 0 {
2967                return Ok(());
2968            };
2969            depth.increment()?;
2970            let envelope_size = 8;
2971            let bytes_len = len * envelope_size;
2972            let offset = decoder.out_of_line_offset(bytes_len)?;
2973            // Decode the envelope for each type.
2974            let mut _next_ordinal_to_read = 0;
2975            let mut next_offset = offset;
2976            let end_offset = offset + bytes_len;
2977            _next_ordinal_to_read += 1;
2978            if next_offset >= end_offset {
2979                return Ok(());
2980            }
2981
2982            // Decode unknown envelopes for gaps in ordinals.
2983            while _next_ordinal_to_read < 1 {
2984                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2985                _next_ordinal_to_read += 1;
2986                next_offset += envelope_size;
2987            }
2988
2989            let next_out_of_line = decoder.next_out_of_line();
2990            let handles_before = decoder.remaining_handles();
2991            if let Some((inlined, num_bytes, num_handles)) =
2992                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2993            {
2994                let member_inline_size =
2995                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2996                        decoder.context,
2997                    );
2998                if inlined != (member_inline_size <= 4) {
2999                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3000                }
3001                let inner_offset;
3002                let mut inner_depth = depth.clone();
3003                if inlined {
3004                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3005                    inner_offset = next_offset;
3006                } else {
3007                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3008                    inner_depth.increment()?;
3009                }
3010                let val_ref = self
3011                    .process_name
3012                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3013                fidl::decode!(
3014                    fidl::encoding::UnboundedString,
3015                    D,
3016                    val_ref,
3017                    decoder,
3018                    inner_offset,
3019                    inner_depth
3020                )?;
3021                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3022                {
3023                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3024                }
3025                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3026                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3027                }
3028            }
3029
3030            next_offset += envelope_size;
3031            _next_ordinal_to_read += 1;
3032            if next_offset >= end_offset {
3033                return Ok(());
3034            }
3035
3036            // Decode unknown envelopes for gaps in ordinals.
3037            while _next_ordinal_to_read < 2 {
3038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3039                _next_ordinal_to_read += 1;
3040                next_offset += envelope_size;
3041            }
3042
3043            let next_out_of_line = decoder.next_out_of_line();
3044            let handles_before = decoder.remaining_handles();
3045            if let Some((inlined, num_bytes, num_handles)) =
3046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3047            {
3048                let member_inline_size =
3049                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3050                if inlined != (member_inline_size <= 4) {
3051                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3052                }
3053                let inner_offset;
3054                let mut inner_depth = depth.clone();
3055                if inlined {
3056                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3057                    inner_offset = next_offset;
3058                } else {
3059                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3060                    inner_depth.increment()?;
3061                }
3062                let val_ref = self.pid.get_or_insert_with(|| fidl::new_empty!(u64, D));
3063                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3064                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3065                {
3066                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3067                }
3068                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3069                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3070                }
3071            }
3072
3073            next_offset += envelope_size;
3074            _next_ordinal_to_read += 1;
3075            if next_offset >= end_offset {
3076                return Ok(());
3077            }
3078
3079            // Decode unknown envelopes for gaps in ordinals.
3080            while _next_ordinal_to_read < 3 {
3081                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3082                _next_ordinal_to_read += 1;
3083                next_offset += envelope_size;
3084            }
3085
3086            let next_out_of_line = decoder.next_out_of_line();
3087            let handles_before = decoder.remaining_handles();
3088            if let Some((inlined, num_bytes, num_handles)) =
3089                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3090            {
3091                let member_inline_size =
3092                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3093                if inlined != (member_inline_size <= 4) {
3094                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3095                }
3096                let inner_offset;
3097                let mut inner_depth = depth.clone();
3098                if inlined {
3099                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3100                    inner_offset = next_offset;
3101                } else {
3102                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3103                    inner_depth.increment()?;
3104                }
3105                let val_ref = self.fd.get_or_insert_with(|| fidl::new_empty!(i32, D));
3106                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3108                {
3109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3110                }
3111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3113                }
3114            }
3115
3116            next_offset += envelope_size;
3117            _next_ordinal_to_read += 1;
3118            if next_offset >= end_offset {
3119                return Ok(());
3120            }
3121
3122            // Decode unknown envelopes for gaps in ordinals.
3123            while _next_ordinal_to_read < 4 {
3124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3125                _next_ordinal_to_read += 1;
3126                next_offset += envelope_size;
3127            }
3128
3129            let next_out_of_line = decoder.next_out_of_line();
3130            let handles_before = decoder.remaining_handles();
3131            if let Some((inlined, num_bytes, num_handles)) =
3132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3133            {
3134                let member_inline_size =
3135                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3136                if inlined != (member_inline_size <= 4) {
3137                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3138                }
3139                let inner_offset;
3140                let mut inner_depth = depth.clone();
3141                if inlined {
3142                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3143                    inner_offset = next_offset;
3144                } else {
3145                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3146                    inner_depth.increment()?;
3147                }
3148                let val_ref = self.koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
3149                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3151                {
3152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3153                }
3154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3156                }
3157            }
3158
3159            next_offset += envelope_size;
3160
3161            // Decode the remaining unknown envelopes.
3162            while next_offset < end_offset {
3163                _next_ordinal_to_read += 1;
3164                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3165                next_offset += envelope_size;
3166            }
3167
3168            Ok(())
3169        }
3170    }
3171}