1#![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 InvalidArgs,
17 Canceled,
19 #[doc(hidden)]
20 __SourceBreaking { unknown_ordinal: u32 },
21}
22
23#[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 pub process_name: Option<String>,
156 pub pid: Option<u64>,
158 pub fd: Option<i32>,
160 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 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 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 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 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 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 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 pub fn take_event_stream(&self) -> ControllerEventStream {
352 ControllerEventStream { event_receiver: self.client.take_event_receiver() }
353 }
354
355 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 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 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 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: u64,
533 },
534}
535
536impl ControllerEvent {
537 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
556pub 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 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 VsockConnect { payload: ControllerVsockConnectRequest, control_handle: ControllerControlHandle },
732 SpawnConsole {
737 payload: ControllerSpawnConsoleRequest,
738 responder: ControllerSpawnConsoleResponder,
739 },
740 GetVmoReferences {
742 payload: ControllerGetVmoReferencesRequest,
743 responder: ControllerGetVmoReferencesResponder,
744 },
745 GetJobHandle { responder: ControllerGetJobHandleResponder },
747 #[non_exhaustive]
749 _UnknownMethod {
750 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 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
857impl std::ops::Drop for ControllerSpawnConsoleResponder {
861 fn drop(&mut self) {
862 self.control_handle.shutdown();
863 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
878 std::mem::forget(self);
880 }
881}
882
883impl ControllerSpawnConsoleResponder {
884 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 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
926impl std::ops::Drop for ControllerGetVmoReferencesResponder {
930 fn drop(&mut self) {
931 self.control_handle.shutdown();
932 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
947 std::mem::forget(self);
949 }
950}
951
952impl ControllerGetVmoReferencesResponder {
953 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 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
997impl std::ops::Drop for ControllerGetJobHandleResponder {
1001 fn drop(&mut self) {
1002 self.control_handle.shutdown();
1003 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 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1018 std::mem::forget(self);
1020 }
1021}
1022
1023impl ControllerGetJobHandleResponder {
1024 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 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 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 }
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 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 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 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 }
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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1398
1399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1401
1402 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1590
1591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1593
1594 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 let cur_offset: usize = (2 - 1) * envelope_size;
1626
1627 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1629
1630 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 let cur_offset: usize = (3 - 1) * envelope_size;
1662
1663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1665
1666 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 let cur_offset: usize = (4 - 1) * envelope_size;
1690
1691 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1693
1694 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 let cur_offset: usize = (5 - 1) * envelope_size;
1711
1712 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1714
1715 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 let cur_offset: usize = (6 - 1) * envelope_size;
1732
1733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1735
1736 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 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 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 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2203
2204 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2206
2207 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 let cur_offset: usize = (2 - 1) * envelope_size;
2229
2230 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2232
2233 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2480
2481 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2483
2484 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2672
2673 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2675
2676 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2856
2857 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2859
2860 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 let cur_offset: usize = (2 - 1) * envelope_size;
2881
2882 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2884
2885 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 let cur_offset: usize = (3 - 1) * envelope_size;
2904
2905 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2907
2908 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 let cur_offset: usize = (4 - 1) * envelope_size;
2927
2928 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2930
2931 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 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 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 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 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 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 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 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}