1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_process::natural::*;
8
9 #[doc = " Information about a handle provided to a process at startup.\n\n Processes are given a set of initial handles as part of the bootstrapping\n sequence. Some of these handles are associated with process argument\n identifiers that designate their intended use by the new process.\n\n This structure represents one such handle and its associated identifier.\n"]
10 #[derive(Debug, PartialEq)]
11 #[repr(C)]
12 pub struct HandleInfo {
13 pub handle: ::fidl_next::fuchsia::zx::NullableHandle,
14
15 pub id: u32,
16 }
17
18 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HandleInfo, ___E> for HandleInfo
19 where
20 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
21 ___E: ::fidl_next::fuchsia::HandleEncoder,
22 {
23 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::HandleInfo> = unsafe {
24 ::fidl_next::CopyOptimization::enable_if(
25 true
26
27 && <
28 ::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>
29 >::COPY_OPTIMIZATION.is_enabled()
30
31 && <
32 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
33 >::COPY_OPTIMIZATION.is_enabled()
34
35 )
36 };
37
38 #[inline]
39 fn encode(
40 self,
41 encoder_: &mut ___E,
42 out_: &mut ::core::mem::MaybeUninit<crate::wire::HandleInfo>,
43 _: (),
44 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
45 ::fidl_next::munge! {
46 let crate::wire::HandleInfo {
47 handle,
48 id,
49
50 } = out_;
51 }
52
53 ::fidl_next::Encode::encode(self.handle, encoder_, handle, ())?;
54
55 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle.as_mut_ptr()) };
56
57 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
58
59 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
60
61 Ok(())
62 }
63 }
64
65 unsafe impl<___E>
66 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::HandleInfo>, ___E>
67 for HandleInfo
68 where
69 ___E: ::fidl_next::Encoder + ?Sized,
70 HandleInfo: ::fidl_next::Encode<crate::wire::HandleInfo, ___E>,
71 {
72 #[inline]
73 fn encode_option(
74 this: ::core::option::Option<Self>,
75 encoder: &mut ___E,
76 out: &mut ::core::mem::MaybeUninit<
77 ::fidl_next::wire::Box<'static, crate::wire::HandleInfo>,
78 >,
79 _: (),
80 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
81 if let Some(inner) = this {
82 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
83 ::fidl_next::wire::Box::encode_present(out);
84 } else {
85 ::fidl_next::wire::Box::encode_absent(out);
86 }
87
88 Ok(())
89 }
90 }
91
92 impl ::fidl_next::FromWire<crate::wire::HandleInfo> for HandleInfo {
93 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::HandleInfo, Self> = unsafe {
94 ::fidl_next::CopyOptimization::enable_if(
95 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::FromWire<
96 ::fidl_next::wire::fuchsia::NullableHandle,
97 >>::COPY_OPTIMIZATION
98 .is_enabled()
99 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
100 .is_enabled(),
101 )
102 };
103
104 #[inline]
105 fn from_wire(wire: crate::wire::HandleInfo) -> Self {
106 Self {
107 handle: ::fidl_next::FromWire::from_wire(wire.handle),
108
109 id: ::fidl_next::FromWire::from_wire(wire.id),
110 }
111 }
112 }
113
114 #[doc = " The information needed to launch a process.\n"]
115 #[derive(Debug, PartialEq)]
116 pub struct LaunchInfo {
117 pub executable: ::fidl_next::fuchsia::zx::Vmo,
118
119 pub job: ::fidl_next::fuchsia::zx::Job,
120
121 pub name: ::std::string::String,
122 }
123
124 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E> for LaunchInfo
125 where
126 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
127 ___E: ::fidl_next::Encoder,
128 ___E: ::fidl_next::fuchsia::HandleEncoder,
129 {
130 #[inline]
131 fn encode(
132 self,
133 encoder_: &mut ___E,
134 out_: &mut ::core::mem::MaybeUninit<crate::wire::LaunchInfo<'static>>,
135 _: (),
136 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
137 ::fidl_next::munge! {
138 let crate::wire::LaunchInfo {
139 executable,
140 job,
141 name,
142
143 } = out_;
144 }
145
146 ::fidl_next::Encode::encode(self.executable, encoder_, executable, ())?;
147
148 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(executable.as_mut_ptr()) };
149
150 ::fidl_next::Encode::encode(self.job, encoder_, job, ())?;
151
152 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(job.as_mut_ptr()) };
153
154 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
155
156 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
157 ::fidl_next::Constrained::validate(_field, 32)?;
158
159 Ok(())
160 }
161 }
162
163 unsafe impl<___E>
164 ::fidl_next::EncodeOption<
165 ::fidl_next::wire::Box<'static, crate::wire::LaunchInfo<'static>>,
166 ___E,
167 > for LaunchInfo
168 where
169 ___E: ::fidl_next::Encoder + ?Sized,
170 LaunchInfo: ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>,
171 {
172 #[inline]
173 fn encode_option(
174 this: ::core::option::Option<Self>,
175 encoder: &mut ___E,
176 out: &mut ::core::mem::MaybeUninit<
177 ::fidl_next::wire::Box<'static, crate::wire::LaunchInfo<'static>>,
178 >,
179 _: (),
180 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
181 if let Some(inner) = this {
182 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
183 ::fidl_next::wire::Box::encode_present(out);
184 } else {
185 ::fidl_next::wire::Box::encode_absent(out);
186 }
187
188 Ok(())
189 }
190 }
191
192 impl<'de> ::fidl_next::FromWire<crate::wire::LaunchInfo<'de>> for LaunchInfo {
193 #[inline]
194 fn from_wire(wire: crate::wire::LaunchInfo<'de>) -> Self {
195 Self {
196 executable: ::fidl_next::FromWire::from_wire(wire.executable),
197
198 job: ::fidl_next::FromWire::from_wire(wire.job),
199
200 name: ::fidl_next::FromWire::from_wire(wire.name),
201 }
202 }
203 }
204
205 #[derive(Debug, PartialEq)]
206 pub struct LauncherLaunchRequest {
207 pub info: crate::natural::LaunchInfo,
208 }
209
210 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LauncherLaunchRequest<'static>, ___E>
211 for LauncherLaunchRequest
212 where
213 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
214 ___E: ::fidl_next::Encoder,
215 ___E: ::fidl_next::fuchsia::HandleEncoder,
216 {
217 #[inline]
218 fn encode(
219 self,
220 encoder_: &mut ___E,
221 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherLaunchRequest<'static>>,
222 _: (),
223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
224 ::fidl_next::munge! {
225 let crate::wire::LauncherLaunchRequest {
226 info,
227
228 } = out_;
229 }
230
231 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
232
233 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
234
235 Ok(())
236 }
237 }
238
239 unsafe impl<___E>
240 ::fidl_next::EncodeOption<
241 ::fidl_next::wire::Box<'static, crate::wire::LauncherLaunchRequest<'static>>,
242 ___E,
243 > for LauncherLaunchRequest
244 where
245 ___E: ::fidl_next::Encoder + ?Sized,
246 LauncherLaunchRequest:
247 ::fidl_next::Encode<crate::wire::LauncherLaunchRequest<'static>, ___E>,
248 {
249 #[inline]
250 fn encode_option(
251 this: ::core::option::Option<Self>,
252 encoder: &mut ___E,
253 out: &mut ::core::mem::MaybeUninit<
254 ::fidl_next::wire::Box<'static, crate::wire::LauncherLaunchRequest<'static>>,
255 >,
256 _: (),
257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
258 if let Some(inner) = this {
259 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
260 ::fidl_next::wire::Box::encode_present(out);
261 } else {
262 ::fidl_next::wire::Box::encode_absent(out);
263 }
264
265 Ok(())
266 }
267 }
268
269 impl<'de> ::fidl_next::FromWire<crate::wire::LauncherLaunchRequest<'de>> for LauncherLaunchRequest {
270 #[inline]
271 fn from_wire(wire: crate::wire::LauncherLaunchRequest<'de>) -> Self {
272 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
273 }
274 }
275
276 #[derive(Debug, PartialEq)]
277 #[repr(C)]
278 pub struct LauncherLaunchResponse {
279 pub status: i32,
280
281 pub process: ::core::option::Option<::fidl_next::fuchsia::zx::Process>,
282 }
283
284 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LauncherLaunchResponse, ___E>
285 for LauncherLaunchResponse
286 where
287 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
288 ___E: ::fidl_next::fuchsia::HandleEncoder,
289 {
290 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
291 Self,
292 crate::wire::LauncherLaunchResponse,
293 > = unsafe {
294 ::fidl_next::CopyOptimization::enable_if(
295 true
296
297 && <
298 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
299 >::COPY_OPTIMIZATION.is_enabled()
300
301 && <
302 ::core::option::Option<::fidl_next::fuchsia::zx::Process> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalProcess, ___E>
303 >::COPY_OPTIMIZATION.is_enabled()
304
305 )
306 };
307
308 #[inline]
309 fn encode(
310 self,
311 encoder_: &mut ___E,
312 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherLaunchResponse>,
313 _: (),
314 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
315 ::fidl_next::munge! {
316 let crate::wire::LauncherLaunchResponse {
317 status,
318 process,
319
320 } = out_;
321 }
322
323 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
324
325 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
326
327 ::fidl_next::Encode::encode(self.process, encoder_, process, ())?;
328
329 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(process.as_mut_ptr()) };
330
331 Ok(())
332 }
333 }
334
335 unsafe impl<___E>
336 ::fidl_next::EncodeOption<
337 ::fidl_next::wire::Box<'static, crate::wire::LauncherLaunchResponse>,
338 ___E,
339 > for LauncherLaunchResponse
340 where
341 ___E: ::fidl_next::Encoder + ?Sized,
342 LauncherLaunchResponse: ::fidl_next::Encode<crate::wire::LauncherLaunchResponse, ___E>,
343 {
344 #[inline]
345 fn encode_option(
346 this: ::core::option::Option<Self>,
347 encoder: &mut ___E,
348 out: &mut ::core::mem::MaybeUninit<
349 ::fidl_next::wire::Box<'static, crate::wire::LauncherLaunchResponse>,
350 >,
351 _: (),
352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
353 if let Some(inner) = this {
354 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
355 ::fidl_next::wire::Box::encode_present(out);
356 } else {
357 ::fidl_next::wire::Box::encode_absent(out);
358 }
359
360 Ok(())
361 }
362 }
363
364 impl ::fidl_next::FromWire<crate::wire::LauncherLaunchResponse> for LauncherLaunchResponse {
365 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
366 crate::wire::LauncherLaunchResponse,
367 Self,
368 > = unsafe {
369 ::fidl_next::CopyOptimization::enable_if(
370 true
371
372 && <
373 i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>
374 >::COPY_OPTIMIZATION.is_enabled()
375
376 && <
377 ::core::option::Option<::fidl_next::fuchsia::zx::Process> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalProcess>
378 >::COPY_OPTIMIZATION.is_enabled()
379
380 )
381 };
382
383 #[inline]
384 fn from_wire(wire: crate::wire::LauncherLaunchResponse) -> Self {
385 Self {
386 status: ::fidl_next::FromWire::from_wire(wire.status),
387
388 process: ::fidl_next::FromWire::from_wire(wire.process),
389 }
390 }
391 }
392
393 #[derive(Debug, PartialEq)]
394 pub struct LauncherCreateWithoutStartingRequest {
395 pub info: crate::natural::LaunchInfo,
396 }
397
398 unsafe impl<___E>
399 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingRequest<'static>, ___E>
400 for LauncherCreateWithoutStartingRequest
401 where
402 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
403 ___E: ::fidl_next::Encoder,
404 ___E: ::fidl_next::fuchsia::HandleEncoder,
405 {
406 #[inline]
407 fn encode(
408 self,
409 encoder_: &mut ___E,
410 out_: &mut ::core::mem::MaybeUninit<
411 crate::wire::LauncherCreateWithoutStartingRequest<'static>,
412 >,
413 _: (),
414 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
415 ::fidl_next::munge! {
416 let crate::wire::LauncherCreateWithoutStartingRequest {
417 info,
418
419 } = out_;
420 }
421
422 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
423
424 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
425
426 Ok(())
427 }
428 }
429
430 unsafe impl<___E>
431 ::fidl_next::EncodeOption<
432 ::fidl_next::wire::Box<
433 'static,
434 crate::wire::LauncherCreateWithoutStartingRequest<'static>,
435 >,
436 ___E,
437 > for LauncherCreateWithoutStartingRequest
438 where
439 ___E: ::fidl_next::Encoder + ?Sized,
440 LauncherCreateWithoutStartingRequest:
441 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingRequest<'static>, ___E>,
442 {
443 #[inline]
444 fn encode_option(
445 this: ::core::option::Option<Self>,
446 encoder: &mut ___E,
447 out: &mut ::core::mem::MaybeUninit<
448 ::fidl_next::wire::Box<
449 'static,
450 crate::wire::LauncherCreateWithoutStartingRequest<'static>,
451 >,
452 >,
453 _: (),
454 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
455 if let Some(inner) = this {
456 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
457 ::fidl_next::wire::Box::encode_present(out);
458 } else {
459 ::fidl_next::wire::Box::encode_absent(out);
460 }
461
462 Ok(())
463 }
464 }
465
466 impl<'de> ::fidl_next::FromWire<crate::wire::LauncherCreateWithoutStartingRequest<'de>>
467 for LauncherCreateWithoutStartingRequest
468 {
469 #[inline]
470 fn from_wire(wire: crate::wire::LauncherCreateWithoutStartingRequest<'de>) -> Self {
471 Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
472 }
473 }
474
475 #[derive(Debug, PartialEq)]
476 pub struct LauncherCreateWithoutStartingResponse {
477 pub status: i32,
478
479 pub data: ::core::option::Option<::std::boxed::Box<crate::natural::ProcessStartData>>,
480 }
481
482 unsafe impl<___E>
483 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingResponse<'static>, ___E>
484 for LauncherCreateWithoutStartingResponse
485 where
486 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
487 ___E: ::fidl_next::Encoder,
488 ___E: ::fidl_next::fuchsia::HandleEncoder,
489 {
490 #[inline]
491 fn encode(
492 self,
493 encoder_: &mut ___E,
494 out_: &mut ::core::mem::MaybeUninit<
495 crate::wire::LauncherCreateWithoutStartingResponse<'static>,
496 >,
497 _: (),
498 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
499 ::fidl_next::munge! {
500 let crate::wire::LauncherCreateWithoutStartingResponse {
501 status,
502 data,
503
504 } = out_;
505 }
506
507 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
508
509 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
510
511 ::fidl_next::Encode::encode(self.data, encoder_, data, ())?;
512
513 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
514
515 Ok(())
516 }
517 }
518
519 unsafe impl<___E>
520 ::fidl_next::EncodeOption<
521 ::fidl_next::wire::Box<
522 'static,
523 crate::wire::LauncherCreateWithoutStartingResponse<'static>,
524 >,
525 ___E,
526 > for LauncherCreateWithoutStartingResponse
527 where
528 ___E: ::fidl_next::Encoder + ?Sized,
529 LauncherCreateWithoutStartingResponse:
530 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingResponse<'static>, ___E>,
531 {
532 #[inline]
533 fn encode_option(
534 this: ::core::option::Option<Self>,
535 encoder: &mut ___E,
536 out: &mut ::core::mem::MaybeUninit<
537 ::fidl_next::wire::Box<
538 'static,
539 crate::wire::LauncherCreateWithoutStartingResponse<'static>,
540 >,
541 >,
542 _: (),
543 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
544 if let Some(inner) = this {
545 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
546 ::fidl_next::wire::Box::encode_present(out);
547 } else {
548 ::fidl_next::wire::Box::encode_absent(out);
549 }
550
551 Ok(())
552 }
553 }
554
555 impl<'de> ::fidl_next::FromWire<crate::wire::LauncherCreateWithoutStartingResponse<'de>>
556 for LauncherCreateWithoutStartingResponse
557 {
558 #[inline]
559 fn from_wire(wire: crate::wire::LauncherCreateWithoutStartingResponse<'de>) -> Self {
560 Self {
561 status: ::fidl_next::FromWire::from_wire(wire.status),
562
563 data: ::fidl_next::FromWire::from_wire(wire.data),
564 }
565 }
566 }
567
568 #[derive(Debug, PartialEq)]
569 pub struct LauncherAddHandlesRequest {
570 pub handles: ::std::vec::Vec<crate::natural::HandleInfo>,
571 }
572
573 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LauncherAddHandlesRequest<'static>, ___E>
574 for LauncherAddHandlesRequest
575 where
576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
577 ___E: ::fidl_next::Encoder,
578 ___E: ::fidl_next::fuchsia::HandleEncoder,
579 {
580 #[inline]
581 fn encode(
582 self,
583 encoder_: &mut ___E,
584 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherAddHandlesRequest<'static>>,
585 _: (),
586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
587 ::fidl_next::munge! {
588 let crate::wire::LauncherAddHandlesRequest {
589 handles,
590
591 } = out_;
592 }
593
594 ::fidl_next::Encode::encode(self.handles, encoder_, handles, (4294967295, ()))?;
595
596 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
597 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
598
599 Ok(())
600 }
601 }
602
603 unsafe impl<___E>
604 ::fidl_next::EncodeOption<
605 ::fidl_next::wire::Box<'static, crate::wire::LauncherAddHandlesRequest<'static>>,
606 ___E,
607 > for LauncherAddHandlesRequest
608 where
609 ___E: ::fidl_next::Encoder + ?Sized,
610 LauncherAddHandlesRequest:
611 ::fidl_next::Encode<crate::wire::LauncherAddHandlesRequest<'static>, ___E>,
612 {
613 #[inline]
614 fn encode_option(
615 this: ::core::option::Option<Self>,
616 encoder: &mut ___E,
617 out: &mut ::core::mem::MaybeUninit<
618 ::fidl_next::wire::Box<'static, crate::wire::LauncherAddHandlesRequest<'static>>,
619 >,
620 _: (),
621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
622 if let Some(inner) = this {
623 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
624 ::fidl_next::wire::Box::encode_present(out);
625 } else {
626 ::fidl_next::wire::Box::encode_absent(out);
627 }
628
629 Ok(())
630 }
631 }
632
633 impl<'de> ::fidl_next::FromWire<crate::wire::LauncherAddHandlesRequest<'de>>
634 for LauncherAddHandlesRequest
635 {
636 #[inline]
637 fn from_wire(wire: crate::wire::LauncherAddHandlesRequest<'de>) -> Self {
638 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
639 }
640 }
641
642 #[doc = " A namespace entry provided to a process at startup.\n\n Processes are given a set of initial handles as part of the bootstrapping\n sequence. Some of these handles are associated with paths that designate\n their intended use by the new process as namespace entries.\n\n This structure represents one such handle and its associated namespace path.\n"]
643 #[derive(Debug, PartialEq)]
644 pub struct NameInfo {
645 pub path: ::std::string::String,
646
647 pub directory: ::fidl_next::ClientEnd<
648 ::fidl_next_fuchsia_io::Directory,
649 ::fidl_next::fuchsia::zx::Channel,
650 >,
651 }
652
653 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NameInfo<'static>, ___E> for NameInfo
654 where
655 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
656 ___E: ::fidl_next::Encoder,
657 ___E: ::fidl_next::fuchsia::HandleEncoder,
658 {
659 #[inline]
660 fn encode(
661 self,
662 encoder_: &mut ___E,
663 out_: &mut ::core::mem::MaybeUninit<crate::wire::NameInfo<'static>>,
664 _: (),
665 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
666 ::fidl_next::munge! {
667 let crate::wire::NameInfo {
668 path,
669 directory,
670
671 } = out_;
672 }
673
674 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
675
676 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
677 ::fidl_next::Constrained::validate(_field, 4095)?;
678
679 ::fidl_next::Encode::encode(self.directory, encoder_, directory, ())?;
680
681 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(directory.as_mut_ptr()) };
682
683 Ok(())
684 }
685 }
686
687 unsafe impl<___E>
688 ::fidl_next::EncodeOption<
689 ::fidl_next::wire::Box<'static, crate::wire::NameInfo<'static>>,
690 ___E,
691 > for NameInfo
692 where
693 ___E: ::fidl_next::Encoder + ?Sized,
694 NameInfo: ::fidl_next::Encode<crate::wire::NameInfo<'static>, ___E>,
695 {
696 #[inline]
697 fn encode_option(
698 this: ::core::option::Option<Self>,
699 encoder: &mut ___E,
700 out: &mut ::core::mem::MaybeUninit<
701 ::fidl_next::wire::Box<'static, crate::wire::NameInfo<'static>>,
702 >,
703 _: (),
704 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
705 if let Some(inner) = this {
706 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
707 ::fidl_next::wire::Box::encode_present(out);
708 } else {
709 ::fidl_next::wire::Box::encode_absent(out);
710 }
711
712 Ok(())
713 }
714 }
715
716 impl<'de> ::fidl_next::FromWire<crate::wire::NameInfo<'de>> for NameInfo {
717 #[inline]
718 fn from_wire(wire: crate::wire::NameInfo<'de>) -> Self {
719 Self {
720 path: ::fidl_next::FromWire::from_wire(wire.path),
721
722 directory: ::fidl_next::FromWire::from_wire(wire.directory),
723 }
724 }
725 }
726
727 #[derive(Debug, PartialEq)]
728 pub struct LauncherAddNamesRequest {
729 pub names: ::std::vec::Vec<crate::natural::NameInfo>,
730 }
731
732 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LauncherAddNamesRequest<'static>, ___E>
733 for LauncherAddNamesRequest
734 where
735 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
736 ___E: ::fidl_next::Encoder,
737 ___E: ::fidl_next::fuchsia::HandleEncoder,
738 {
739 #[inline]
740 fn encode(
741 self,
742 encoder_: &mut ___E,
743 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherAddNamesRequest<'static>>,
744 _: (),
745 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
746 ::fidl_next::munge! {
747 let crate::wire::LauncherAddNamesRequest {
748 names,
749
750 } = out_;
751 }
752
753 ::fidl_next::Encode::encode(self.names, encoder_, names, (4294967295, ()))?;
754
755 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(names.as_mut_ptr()) };
756 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
757
758 Ok(())
759 }
760 }
761
762 unsafe impl<___E>
763 ::fidl_next::EncodeOption<
764 ::fidl_next::wire::Box<'static, crate::wire::LauncherAddNamesRequest<'static>>,
765 ___E,
766 > for LauncherAddNamesRequest
767 where
768 ___E: ::fidl_next::Encoder + ?Sized,
769 LauncherAddNamesRequest:
770 ::fidl_next::Encode<crate::wire::LauncherAddNamesRequest<'static>, ___E>,
771 {
772 #[inline]
773 fn encode_option(
774 this: ::core::option::Option<Self>,
775 encoder: &mut ___E,
776 out: &mut ::core::mem::MaybeUninit<
777 ::fidl_next::wire::Box<'static, crate::wire::LauncherAddNamesRequest<'static>>,
778 >,
779 _: (),
780 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
781 if let Some(inner) = this {
782 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
783 ::fidl_next::wire::Box::encode_present(out);
784 } else {
785 ::fidl_next::wire::Box::encode_absent(out);
786 }
787
788 Ok(())
789 }
790 }
791
792 impl<'de> ::fidl_next::FromWire<crate::wire::LauncherAddNamesRequest<'de>>
793 for LauncherAddNamesRequest
794 {
795 #[inline]
796 fn from_wire(wire: crate::wire::LauncherAddNamesRequest<'de>) -> Self {
797 Self { names: ::fidl_next::FromWire::from_wire(wire.names) }
798 }
799 }
800
801 #[doc = " The information required to start a process.\n\n To start the process, call `zx_process_start` with the arguments provided.\n"]
802 #[derive(Debug, PartialEq)]
803 pub struct ProcessStartData {
804 pub process: ::fidl_next::fuchsia::zx::Process,
805
806 pub root_vmar: ::fidl_next::fuchsia::zx::Vmar,
807
808 pub thread: ::fidl_next::fuchsia::zx::Thread,
809
810 pub entry: u64,
811
812 pub stack: u64,
813
814 pub bootstrap: ::fidl_next::fuchsia::zx::Channel,
815
816 pub vdso_base: u64,
817
818 pub base: u64,
819 }
820
821 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProcessStartData, ___E> for ProcessStartData
822 where
823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
824 ___E: ::fidl_next::fuchsia::HandleEncoder,
825 {
826 #[inline]
827 fn encode(
828 self,
829 encoder_: &mut ___E,
830 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProcessStartData>,
831 _: (),
832 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
833 ::fidl_next::munge! {
834 let crate::wire::ProcessStartData {
835 process,
836 root_vmar,
837 thread,
838 entry,
839 stack,
840 bootstrap,
841 vdso_base,
842 base,
843
844 } = out_;
845 }
846
847 ::fidl_next::Encode::encode(self.process, encoder_, process, ())?;
848
849 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(process.as_mut_ptr()) };
850
851 ::fidl_next::Encode::encode(self.root_vmar, encoder_, root_vmar, ())?;
852
853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(root_vmar.as_mut_ptr()) };
854
855 ::fidl_next::Encode::encode(self.thread, encoder_, thread, ())?;
856
857 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(thread.as_mut_ptr()) };
858
859 ::fidl_next::Encode::encode(self.entry, encoder_, entry, ())?;
860
861 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entry.as_mut_ptr()) };
862
863 ::fidl_next::Encode::encode(self.stack, encoder_, stack, ())?;
864
865 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stack.as_mut_ptr()) };
866
867 ::fidl_next::Encode::encode(self.bootstrap, encoder_, bootstrap, ())?;
868
869 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bootstrap.as_mut_ptr()) };
870
871 ::fidl_next::Encode::encode(self.vdso_base, encoder_, vdso_base, ())?;
872
873 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vdso_base.as_mut_ptr()) };
874
875 ::fidl_next::Encode::encode(self.base, encoder_, base, ())?;
876
877 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(base.as_mut_ptr()) };
878
879 Ok(())
880 }
881 }
882
883 unsafe impl<___E>
884 ::fidl_next::EncodeOption<
885 ::fidl_next::wire::Box<'static, crate::wire::ProcessStartData>,
886 ___E,
887 > for ProcessStartData
888 where
889 ___E: ::fidl_next::Encoder + ?Sized,
890 ProcessStartData: ::fidl_next::Encode<crate::wire::ProcessStartData, ___E>,
891 {
892 #[inline]
893 fn encode_option(
894 this: ::core::option::Option<Self>,
895 encoder: &mut ___E,
896 out: &mut ::core::mem::MaybeUninit<
897 ::fidl_next::wire::Box<'static, crate::wire::ProcessStartData>,
898 >,
899 _: (),
900 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
901 if let Some(inner) = this {
902 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
903 ::fidl_next::wire::Box::encode_present(out);
904 } else {
905 ::fidl_next::wire::Box::encode_absent(out);
906 }
907
908 Ok(())
909 }
910 }
911
912 impl ::fidl_next::FromWire<crate::wire::ProcessStartData> for ProcessStartData {
913 #[inline]
914 fn from_wire(wire: crate::wire::ProcessStartData) -> Self {
915 Self {
916 process: ::fidl_next::FromWire::from_wire(wire.process),
917
918 root_vmar: ::fidl_next::FromWire::from_wire(wire.root_vmar),
919
920 thread: ::fidl_next::FromWire::from_wire(wire.thread),
921
922 entry: ::fidl_next::FromWire::from_wire(wire.entry),
923
924 stack: ::fidl_next::FromWire::from_wire(wire.stack),
925
926 bootstrap: ::fidl_next::FromWire::from_wire(wire.bootstrap),
927
928 vdso_base: ::fidl_next::FromWire::from_wire(wire.vdso_base),
929
930 base: ::fidl_next::FromWire::from_wire(wire.base),
931 }
932 }
933 }
934
935 #[derive(Debug, PartialEq)]
936 #[repr(C)]
937 pub struct ResolverResolveResponse {
938 pub status: i32,
939
940 pub executable: ::core::option::Option<::fidl_next::fuchsia::zx::Vmo>,
941
942 pub ldsvc: ::core::option::Option<
943 ::fidl_next::ClientEnd<
944 ::fidl_next_fuchsia_ldsvc::Loader,
945 ::fidl_next::fuchsia::zx::Channel,
946 >,
947 >,
948 }
949
950 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolverResolveResponse, ___E>
951 for ResolverResolveResponse
952 where
953 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
954 ___E: ::fidl_next::fuchsia::HandleEncoder,
955 {
956 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
957 Self,
958 crate::wire::ResolverResolveResponse,
959 > = unsafe {
960 ::fidl_next::CopyOptimization::enable_if(
961 true
962
963 && <
964 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
965 >::COPY_OPTIMIZATION.is_enabled()
966
967 && <
968 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>
969 >::COPY_OPTIMIZATION.is_enabled()
970
971 && <
972 ::core::option::Option<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::Encode<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::wire::fuchsia::OptionalChannel>, ___E>
973 >::COPY_OPTIMIZATION.is_enabled()
974
975 )
976 };
977
978 #[inline]
979 fn encode(
980 self,
981 encoder_: &mut ___E,
982 out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolverResolveResponse>,
983 _: (),
984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
985 ::fidl_next::munge! {
986 let crate::wire::ResolverResolveResponse {
987 status,
988 executable,
989 ldsvc,
990
991 } = out_;
992 }
993
994 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
995
996 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
997
998 ::fidl_next::Encode::encode(self.executable, encoder_, executable, ())?;
999
1000 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(executable.as_mut_ptr()) };
1001
1002 ::fidl_next::Encode::encode(self.ldsvc, encoder_, ldsvc, ())?;
1003
1004 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(ldsvc.as_mut_ptr()) };
1005
1006 Ok(())
1007 }
1008 }
1009
1010 unsafe impl<___E>
1011 ::fidl_next::EncodeOption<
1012 ::fidl_next::wire::Box<'static, crate::wire::ResolverResolveResponse>,
1013 ___E,
1014 > for ResolverResolveResponse
1015 where
1016 ___E: ::fidl_next::Encoder + ?Sized,
1017 ResolverResolveResponse: ::fidl_next::Encode<crate::wire::ResolverResolveResponse, ___E>,
1018 {
1019 #[inline]
1020 fn encode_option(
1021 this: ::core::option::Option<Self>,
1022 encoder: &mut ___E,
1023 out: &mut ::core::mem::MaybeUninit<
1024 ::fidl_next::wire::Box<'static, crate::wire::ResolverResolveResponse>,
1025 >,
1026 _: (),
1027 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1028 if let Some(inner) = this {
1029 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1030 ::fidl_next::wire::Box::encode_present(out);
1031 } else {
1032 ::fidl_next::wire::Box::encode_absent(out);
1033 }
1034
1035 Ok(())
1036 }
1037 }
1038
1039 impl ::fidl_next::FromWire<crate::wire::ResolverResolveResponse> for ResolverResolveResponse {
1040 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1041 crate::wire::ResolverResolveResponse,
1042 Self,
1043 > = unsafe {
1044 ::fidl_next::CopyOptimization::enable_if(
1045 true
1046
1047 && <
1048 i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>
1049 >::COPY_OPTIMIZATION.is_enabled()
1050
1051 && <
1052 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalVmo>
1053 >::COPY_OPTIMIZATION.is_enabled()
1054
1055 && <
1056 ::core::option::Option<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::FromWire<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::wire::fuchsia::OptionalChannel>>
1057 >::COPY_OPTIMIZATION.is_enabled()
1058
1059 )
1060 };
1061
1062 #[inline]
1063 fn from_wire(wire: crate::wire::ResolverResolveResponse) -> Self {
1064 Self {
1065 status: ::fidl_next::FromWire::from_wire(wire.status),
1066
1067 executable: ::fidl_next::FromWire::from_wire(wire.executable),
1068
1069 ldsvc: ::fidl_next::FromWire::from_wire(wire.ldsvc),
1070 }
1071 }
1072 }
1073}
1074
1075pub mod wire {
1076
1077 pub use fidl_next_common_fuchsia_process::wire::*;
1078
1079 #[derive(Debug)]
1081 #[repr(C)]
1082 pub struct HandleInfo {
1083 pub handle: ::fidl_next::wire::fuchsia::NullableHandle,
1084
1085 pub id: ::fidl_next::wire::Uint32,
1086 }
1087
1088 static_assertions::const_assert_eq!(std::mem::size_of::<HandleInfo>(), 8);
1089 static_assertions::const_assert_eq!(std::mem::align_of::<HandleInfo>(), 4);
1090
1091 static_assertions::const_assert_eq!(std::mem::offset_of!(HandleInfo, handle), 0);
1092
1093 static_assertions::const_assert_eq!(std::mem::offset_of!(HandleInfo, id), 4);
1094
1095 impl ::fidl_next::Constrained for HandleInfo {
1096 type Constraint = ();
1097
1098 fn validate(
1099 _: ::fidl_next::Slot<'_, Self>,
1100 _: Self::Constraint,
1101 ) -> Result<(), ::fidl_next::ValidationError> {
1102 Ok(())
1103 }
1104 }
1105
1106 unsafe impl ::fidl_next::Wire for HandleInfo {
1107 type Narrowed<'de> = HandleInfo;
1108
1109 #[inline]
1110 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1111 ::fidl_next::munge! {
1112 let Self {
1113
1114 handle,
1115 id,
1116
1117 } = &mut *out_;
1118 }
1119
1120 ::fidl_next::Wire::zero_padding(handle);
1121
1122 ::fidl_next::Wire::zero_padding(id);
1123 }
1124 }
1125
1126 unsafe impl<___D> ::fidl_next::Decode<___D> for HandleInfo
1127 where
1128 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1129 ___D: ::fidl_next::fuchsia::HandleDecoder,
1130 {
1131 fn decode(
1132 slot_: ::fidl_next::Slot<'_, Self>,
1133 decoder_: &mut ___D,
1134 _: (),
1135 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1136 ::fidl_next::munge! {
1137 let Self {
1138
1139 mut handle,
1140 mut id,
1141
1142 } = slot_;
1143 }
1144
1145 let _field = handle.as_mut();
1146
1147 ::fidl_next::Decode::decode(handle.as_mut(), decoder_, ())?;
1148
1149 let _field = id.as_mut();
1150
1151 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
1152
1153 Ok(())
1154 }
1155 }
1156
1157 impl ::fidl_next::IntoNatural for HandleInfo {
1158 type Natural = crate::natural::HandleInfo;
1159 }
1160
1161 #[derive(Debug)]
1163 #[repr(C)]
1164 pub struct LaunchInfo<'de> {
1165 pub executable: ::fidl_next::wire::fuchsia::Vmo,
1166
1167 pub job: ::fidl_next::wire::fuchsia::Job,
1168
1169 pub name: ::fidl_next::wire::String<'de>,
1170 }
1171
1172 static_assertions::const_assert_eq!(std::mem::size_of::<LaunchInfo<'_>>(), 24);
1173 static_assertions::const_assert_eq!(std::mem::align_of::<LaunchInfo<'_>>(), 8);
1174
1175 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, executable), 0);
1176
1177 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, job), 4);
1178
1179 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, name), 8);
1180
1181 impl ::fidl_next::Constrained for LaunchInfo<'_> {
1182 type Constraint = ();
1183
1184 fn validate(
1185 _: ::fidl_next::Slot<'_, Self>,
1186 _: Self::Constraint,
1187 ) -> Result<(), ::fidl_next::ValidationError> {
1188 Ok(())
1189 }
1190 }
1191
1192 unsafe impl ::fidl_next::Wire for LaunchInfo<'static> {
1193 type Narrowed<'de> = LaunchInfo<'de>;
1194
1195 #[inline]
1196 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1197 ::fidl_next::munge! {
1198 let Self {
1199
1200 executable,
1201 job,
1202 name,
1203
1204 } = &mut *out_;
1205 }
1206
1207 ::fidl_next::Wire::zero_padding(executable);
1208
1209 ::fidl_next::Wire::zero_padding(job);
1210
1211 ::fidl_next::Wire::zero_padding(name);
1212 }
1213 }
1214
1215 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LaunchInfo<'de>
1216 where
1217 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1218 ___D: ::fidl_next::Decoder<'de>,
1219 ___D: ::fidl_next::fuchsia::HandleDecoder,
1220 {
1221 fn decode(
1222 slot_: ::fidl_next::Slot<'_, Self>,
1223 decoder_: &mut ___D,
1224 _: (),
1225 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1226 ::fidl_next::munge! {
1227 let Self {
1228
1229 mut executable,
1230 mut job,
1231 mut name,
1232
1233 } = slot_;
1234 }
1235
1236 let _field = executable.as_mut();
1237
1238 ::fidl_next::Decode::decode(executable.as_mut(), decoder_, ())?;
1239
1240 let _field = job.as_mut();
1241
1242 ::fidl_next::Decode::decode(job.as_mut(), decoder_, ())?;
1243
1244 let _field = name.as_mut();
1245 ::fidl_next::Constrained::validate(_field, 32)?;
1246 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 32)?;
1247
1248 let name = unsafe { name.deref_unchecked() };
1249
1250 if name.len() > 32 {
1251 return Err(::fidl_next::DecodeError::VectorTooLong {
1252 size: name.len() as u64,
1253 limit: 32,
1254 });
1255 }
1256
1257 Ok(())
1258 }
1259 }
1260
1261 impl<'de> ::fidl_next::IntoNatural for LaunchInfo<'de> {
1262 type Natural = crate::natural::LaunchInfo;
1263 }
1264
1265 #[derive(Debug)]
1267 #[repr(C)]
1268 pub struct LauncherLaunchRequest<'de> {
1269 pub info: crate::wire::LaunchInfo<'de>,
1270 }
1271
1272 static_assertions::const_assert_eq!(std::mem::size_of::<LauncherLaunchRequest<'_>>(), 24);
1273 static_assertions::const_assert_eq!(std::mem::align_of::<LauncherLaunchRequest<'_>>(), 8);
1274
1275 static_assertions::const_assert_eq!(std::mem::offset_of!(LauncherLaunchRequest<'_>, info), 0);
1276
1277 impl ::fidl_next::Constrained for LauncherLaunchRequest<'_> {
1278 type Constraint = ();
1279
1280 fn validate(
1281 _: ::fidl_next::Slot<'_, Self>,
1282 _: Self::Constraint,
1283 ) -> Result<(), ::fidl_next::ValidationError> {
1284 Ok(())
1285 }
1286 }
1287
1288 unsafe impl ::fidl_next::Wire for LauncherLaunchRequest<'static> {
1289 type Narrowed<'de> = LauncherLaunchRequest<'de>;
1290
1291 #[inline]
1292 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1293 ::fidl_next::munge! {
1294 let Self {
1295
1296 info,
1297
1298 } = &mut *out_;
1299 }
1300
1301 ::fidl_next::Wire::zero_padding(info);
1302 }
1303 }
1304
1305 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LauncherLaunchRequest<'de>
1306 where
1307 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1308 ___D: ::fidl_next::Decoder<'de>,
1309 ___D: ::fidl_next::fuchsia::HandleDecoder,
1310 {
1311 fn decode(
1312 slot_: ::fidl_next::Slot<'_, Self>,
1313 decoder_: &mut ___D,
1314 _: (),
1315 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1316 ::fidl_next::munge! {
1317 let Self {
1318
1319 mut info,
1320
1321 } = slot_;
1322 }
1323
1324 let _field = info.as_mut();
1325
1326 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
1327
1328 Ok(())
1329 }
1330 }
1331
1332 impl<'de> ::fidl_next::IntoNatural for LauncherLaunchRequest<'de> {
1333 type Natural = crate::natural::LauncherLaunchRequest;
1334 }
1335
1336 #[derive(Debug)]
1338 #[repr(C)]
1339 pub struct LauncherLaunchResponse {
1340 pub status: ::fidl_next::wire::Int32,
1341
1342 pub process: ::fidl_next::wire::fuchsia::OptionalProcess,
1343 }
1344
1345 static_assertions::const_assert_eq!(std::mem::size_of::<LauncherLaunchResponse>(), 8);
1346 static_assertions::const_assert_eq!(std::mem::align_of::<LauncherLaunchResponse>(), 4);
1347
1348 static_assertions::const_assert_eq!(std::mem::offset_of!(LauncherLaunchResponse, status), 0);
1349
1350 static_assertions::const_assert_eq!(std::mem::offset_of!(LauncherLaunchResponse, process), 4);
1351
1352 impl ::fidl_next::Constrained for LauncherLaunchResponse {
1353 type Constraint = ();
1354
1355 fn validate(
1356 _: ::fidl_next::Slot<'_, Self>,
1357 _: Self::Constraint,
1358 ) -> Result<(), ::fidl_next::ValidationError> {
1359 Ok(())
1360 }
1361 }
1362
1363 unsafe impl ::fidl_next::Wire for LauncherLaunchResponse {
1364 type Narrowed<'de> = LauncherLaunchResponse;
1365
1366 #[inline]
1367 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1368 ::fidl_next::munge! {
1369 let Self {
1370
1371 status,
1372 process,
1373
1374 } = &mut *out_;
1375 }
1376
1377 ::fidl_next::Wire::zero_padding(status);
1378
1379 ::fidl_next::Wire::zero_padding(process);
1380 }
1381 }
1382
1383 unsafe impl<___D> ::fidl_next::Decode<___D> for LauncherLaunchResponse
1384 where
1385 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1386 ___D: ::fidl_next::fuchsia::HandleDecoder,
1387 {
1388 fn decode(
1389 slot_: ::fidl_next::Slot<'_, Self>,
1390 decoder_: &mut ___D,
1391 _: (),
1392 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1393 ::fidl_next::munge! {
1394 let Self {
1395
1396 mut status,
1397 mut process,
1398
1399 } = slot_;
1400 }
1401
1402 let _field = status.as_mut();
1403
1404 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
1405
1406 let _field = process.as_mut();
1407
1408 ::fidl_next::Decode::decode(process.as_mut(), decoder_, ())?;
1409
1410 Ok(())
1411 }
1412 }
1413
1414 impl ::fidl_next::IntoNatural for LauncherLaunchResponse {
1415 type Natural = crate::natural::LauncherLaunchResponse;
1416 }
1417
1418 #[derive(Debug)]
1420 #[repr(C)]
1421 pub struct LauncherCreateWithoutStartingRequest<'de> {
1422 pub info: crate::wire::LaunchInfo<'de>,
1423 }
1424
1425 static_assertions::const_assert_eq!(
1426 std::mem::size_of::<LauncherCreateWithoutStartingRequest<'_>>(),
1427 24
1428 );
1429 static_assertions::const_assert_eq!(
1430 std::mem::align_of::<LauncherCreateWithoutStartingRequest<'_>>(),
1431 8
1432 );
1433
1434 static_assertions::const_assert_eq!(
1435 std::mem::offset_of!(LauncherCreateWithoutStartingRequest<'_>, info),
1436 0
1437 );
1438
1439 impl ::fidl_next::Constrained for LauncherCreateWithoutStartingRequest<'_> {
1440 type Constraint = ();
1441
1442 fn validate(
1443 _: ::fidl_next::Slot<'_, Self>,
1444 _: Self::Constraint,
1445 ) -> Result<(), ::fidl_next::ValidationError> {
1446 Ok(())
1447 }
1448 }
1449
1450 unsafe impl ::fidl_next::Wire for LauncherCreateWithoutStartingRequest<'static> {
1451 type Narrowed<'de> = LauncherCreateWithoutStartingRequest<'de>;
1452
1453 #[inline]
1454 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1455 ::fidl_next::munge! {
1456 let Self {
1457
1458 info,
1459
1460 } = &mut *out_;
1461 }
1462
1463 ::fidl_next::Wire::zero_padding(info);
1464 }
1465 }
1466
1467 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LauncherCreateWithoutStartingRequest<'de>
1468 where
1469 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1470 ___D: ::fidl_next::Decoder<'de>,
1471 ___D: ::fidl_next::fuchsia::HandleDecoder,
1472 {
1473 fn decode(
1474 slot_: ::fidl_next::Slot<'_, Self>,
1475 decoder_: &mut ___D,
1476 _: (),
1477 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1478 ::fidl_next::munge! {
1479 let Self {
1480
1481 mut info,
1482
1483 } = slot_;
1484 }
1485
1486 let _field = info.as_mut();
1487
1488 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
1489
1490 Ok(())
1491 }
1492 }
1493
1494 impl<'de> ::fidl_next::IntoNatural for LauncherCreateWithoutStartingRequest<'de> {
1495 type Natural = crate::natural::LauncherCreateWithoutStartingRequest;
1496 }
1497
1498 #[derive(Debug)]
1500 #[repr(C)]
1501 pub struct LauncherCreateWithoutStartingResponse<'de> {
1502 pub status: ::fidl_next::wire::Int32,
1503
1504 pub data: ::fidl_next::wire::Box<'de, crate::wire::ProcessStartData>,
1505 }
1506
1507 static_assertions::const_assert_eq!(
1508 std::mem::size_of::<LauncherCreateWithoutStartingResponse<'_>>(),
1509 16
1510 );
1511 static_assertions::const_assert_eq!(
1512 std::mem::align_of::<LauncherCreateWithoutStartingResponse<'_>>(),
1513 8
1514 );
1515
1516 static_assertions::const_assert_eq!(
1517 std::mem::offset_of!(LauncherCreateWithoutStartingResponse<'_>, status),
1518 0
1519 );
1520
1521 static_assertions::const_assert_eq!(
1522 std::mem::offset_of!(LauncherCreateWithoutStartingResponse<'_>, data),
1523 8
1524 );
1525
1526 impl ::fidl_next::Constrained for LauncherCreateWithoutStartingResponse<'_> {
1527 type Constraint = ();
1528
1529 fn validate(
1530 _: ::fidl_next::Slot<'_, Self>,
1531 _: Self::Constraint,
1532 ) -> Result<(), ::fidl_next::ValidationError> {
1533 Ok(())
1534 }
1535 }
1536
1537 unsafe impl ::fidl_next::Wire for LauncherCreateWithoutStartingResponse<'static> {
1538 type Narrowed<'de> = LauncherCreateWithoutStartingResponse<'de>;
1539
1540 #[inline]
1541 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1542 ::fidl_next::munge! {
1543 let Self {
1544
1545 status,
1546 data,
1547
1548 } = &mut *out_;
1549 }
1550
1551 ::fidl_next::Wire::zero_padding(status);
1552
1553 ::fidl_next::Wire::zero_padding(data);
1554
1555 unsafe {
1556 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
1557 }
1558 }
1559 }
1560
1561 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LauncherCreateWithoutStartingResponse<'de>
1562 where
1563 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1564 ___D: ::fidl_next::Decoder<'de>,
1565 ___D: ::fidl_next::fuchsia::HandleDecoder,
1566 {
1567 fn decode(
1568 slot_: ::fidl_next::Slot<'_, Self>,
1569 decoder_: &mut ___D,
1570 _: (),
1571 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1572 if slot_.as_bytes()[4..8] != [0u8; 4] {
1573 return Err(::fidl_next::DecodeError::InvalidPadding);
1574 }
1575
1576 ::fidl_next::munge! {
1577 let Self {
1578
1579 mut status,
1580 mut data,
1581
1582 } = slot_;
1583 }
1584
1585 let _field = status.as_mut();
1586
1587 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
1588
1589 let _field = data.as_mut();
1590
1591 ::fidl_next::Decode::decode(data.as_mut(), decoder_, ())?;
1592
1593 Ok(())
1594 }
1595 }
1596
1597 impl<'de> ::fidl_next::IntoNatural for LauncherCreateWithoutStartingResponse<'de> {
1598 type Natural = crate::natural::LauncherCreateWithoutStartingResponse;
1599 }
1600
1601 #[derive(Debug)]
1603 #[repr(C)]
1604 pub struct LauncherAddHandlesRequest<'de> {
1605 pub handles: ::fidl_next::wire::Vector<'de, crate::wire::HandleInfo>,
1606 }
1607
1608 static_assertions::const_assert_eq!(std::mem::size_of::<LauncherAddHandlesRequest<'_>>(), 16);
1609 static_assertions::const_assert_eq!(std::mem::align_of::<LauncherAddHandlesRequest<'_>>(), 8);
1610
1611 static_assertions::const_assert_eq!(
1612 std::mem::offset_of!(LauncherAddHandlesRequest<'_>, handles),
1613 0
1614 );
1615
1616 impl ::fidl_next::Constrained for LauncherAddHandlesRequest<'_> {
1617 type Constraint = ();
1618
1619 fn validate(
1620 _: ::fidl_next::Slot<'_, Self>,
1621 _: Self::Constraint,
1622 ) -> Result<(), ::fidl_next::ValidationError> {
1623 Ok(())
1624 }
1625 }
1626
1627 unsafe impl ::fidl_next::Wire for LauncherAddHandlesRequest<'static> {
1628 type Narrowed<'de> = LauncherAddHandlesRequest<'de>;
1629
1630 #[inline]
1631 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1632 ::fidl_next::munge! {
1633 let Self {
1634
1635 handles,
1636
1637 } = &mut *out_;
1638 }
1639
1640 ::fidl_next::Wire::zero_padding(handles);
1641 }
1642 }
1643
1644 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LauncherAddHandlesRequest<'de>
1645 where
1646 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1647 ___D: ::fidl_next::Decoder<'de>,
1648 ___D: ::fidl_next::fuchsia::HandleDecoder,
1649 {
1650 fn decode(
1651 slot_: ::fidl_next::Slot<'_, Self>,
1652 decoder_: &mut ___D,
1653 _: (),
1654 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1655 ::fidl_next::munge! {
1656 let Self {
1657
1658 mut handles,
1659
1660 } = slot_;
1661 }
1662
1663 let _field = handles.as_mut();
1664 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1665 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, (4294967295, ()))?;
1666
1667 Ok(())
1668 }
1669 }
1670
1671 impl<'de> ::fidl_next::IntoNatural for LauncherAddHandlesRequest<'de> {
1672 type Natural = crate::natural::LauncherAddHandlesRequest;
1673 }
1674
1675 #[derive(Debug)]
1677 #[repr(C)]
1678 pub struct NameInfo<'de> {
1679 pub path: ::fidl_next::wire::String<'de>,
1680
1681 pub directory: ::fidl_next::ClientEnd<
1682 ::fidl_next_fuchsia_io::Directory,
1683 ::fidl_next::wire::fuchsia::Channel,
1684 >,
1685 }
1686
1687 static_assertions::const_assert_eq!(std::mem::size_of::<NameInfo<'_>>(), 24);
1688 static_assertions::const_assert_eq!(std::mem::align_of::<NameInfo<'_>>(), 8);
1689
1690 static_assertions::const_assert_eq!(std::mem::offset_of!(NameInfo<'_>, path), 0);
1691
1692 static_assertions::const_assert_eq!(std::mem::offset_of!(NameInfo<'_>, directory), 16);
1693
1694 impl ::fidl_next::Constrained for NameInfo<'_> {
1695 type Constraint = ();
1696
1697 fn validate(
1698 _: ::fidl_next::Slot<'_, Self>,
1699 _: Self::Constraint,
1700 ) -> Result<(), ::fidl_next::ValidationError> {
1701 Ok(())
1702 }
1703 }
1704
1705 unsafe impl ::fidl_next::Wire for NameInfo<'static> {
1706 type Narrowed<'de> = NameInfo<'de>;
1707
1708 #[inline]
1709 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1710 ::fidl_next::munge! {
1711 let Self {
1712
1713 path,
1714 directory,
1715
1716 } = &mut *out_;
1717 }
1718
1719 ::fidl_next::Wire::zero_padding(path);
1720
1721 ::fidl_next::Wire::zero_padding(directory);
1722
1723 unsafe {
1724 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
1725 }
1726 }
1727 }
1728
1729 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NameInfo<'de>
1730 where
1731 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1732 ___D: ::fidl_next::Decoder<'de>,
1733 ___D: ::fidl_next::fuchsia::HandleDecoder,
1734 {
1735 fn decode(
1736 slot_: ::fidl_next::Slot<'_, Self>,
1737 decoder_: &mut ___D,
1738 _: (),
1739 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1740 if slot_.as_bytes()[20..24] != [0u8; 4] {
1741 return Err(::fidl_next::DecodeError::InvalidPadding);
1742 }
1743
1744 ::fidl_next::munge! {
1745 let Self {
1746
1747 mut path,
1748 mut directory,
1749
1750 } = slot_;
1751 }
1752
1753 let _field = path.as_mut();
1754 ::fidl_next::Constrained::validate(_field, 4095)?;
1755 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
1756
1757 let path = unsafe { path.deref_unchecked() };
1758
1759 if path.len() > 4095 {
1760 return Err(::fidl_next::DecodeError::VectorTooLong {
1761 size: path.len() as u64,
1762 limit: 4095,
1763 });
1764 }
1765
1766 let _field = directory.as_mut();
1767
1768 ::fidl_next::Decode::decode(directory.as_mut(), decoder_, ())?;
1769
1770 Ok(())
1771 }
1772 }
1773
1774 impl<'de> ::fidl_next::IntoNatural for NameInfo<'de> {
1775 type Natural = crate::natural::NameInfo;
1776 }
1777
1778 #[derive(Debug)]
1780 #[repr(C)]
1781 pub struct LauncherAddNamesRequest<'de> {
1782 pub names: ::fidl_next::wire::Vector<'de, crate::wire::NameInfo<'de>>,
1783 }
1784
1785 static_assertions::const_assert_eq!(std::mem::size_of::<LauncherAddNamesRequest<'_>>(), 16);
1786 static_assertions::const_assert_eq!(std::mem::align_of::<LauncherAddNamesRequest<'_>>(), 8);
1787
1788 static_assertions::const_assert_eq!(
1789 std::mem::offset_of!(LauncherAddNamesRequest<'_>, names),
1790 0
1791 );
1792
1793 impl ::fidl_next::Constrained for LauncherAddNamesRequest<'_> {
1794 type Constraint = ();
1795
1796 fn validate(
1797 _: ::fidl_next::Slot<'_, Self>,
1798 _: Self::Constraint,
1799 ) -> Result<(), ::fidl_next::ValidationError> {
1800 Ok(())
1801 }
1802 }
1803
1804 unsafe impl ::fidl_next::Wire for LauncherAddNamesRequest<'static> {
1805 type Narrowed<'de> = LauncherAddNamesRequest<'de>;
1806
1807 #[inline]
1808 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1809 ::fidl_next::munge! {
1810 let Self {
1811
1812 names,
1813
1814 } = &mut *out_;
1815 }
1816
1817 ::fidl_next::Wire::zero_padding(names);
1818 }
1819 }
1820
1821 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LauncherAddNamesRequest<'de>
1822 where
1823 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1824 ___D: ::fidl_next::Decoder<'de>,
1825 ___D: ::fidl_next::fuchsia::HandleDecoder,
1826 {
1827 fn decode(
1828 slot_: ::fidl_next::Slot<'_, Self>,
1829 decoder_: &mut ___D,
1830 _: (),
1831 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1832 ::fidl_next::munge! {
1833 let Self {
1834
1835 mut names,
1836
1837 } = slot_;
1838 }
1839
1840 let _field = names.as_mut();
1841 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1842 ::fidl_next::Decode::decode(names.as_mut(), decoder_, (4294967295, ()))?;
1843
1844 Ok(())
1845 }
1846 }
1847
1848 impl<'de> ::fidl_next::IntoNatural for LauncherAddNamesRequest<'de> {
1849 type Natural = crate::natural::LauncherAddNamesRequest;
1850 }
1851
1852 #[derive(Debug)]
1854 #[repr(C)]
1855 pub struct ProcessStartData {
1856 pub process: ::fidl_next::wire::fuchsia::Process,
1857
1858 pub root_vmar: ::fidl_next::wire::fuchsia::Vmar,
1859
1860 pub thread: ::fidl_next::wire::fuchsia::Thread,
1861
1862 pub entry: ::fidl_next::wire::Uint64,
1863
1864 pub stack: ::fidl_next::wire::Uint64,
1865
1866 pub bootstrap: ::fidl_next::wire::fuchsia::Channel,
1867
1868 pub vdso_base: ::fidl_next::wire::Uint64,
1869
1870 pub base: ::fidl_next::wire::Uint64,
1871 }
1872
1873 static_assertions::const_assert_eq!(std::mem::size_of::<ProcessStartData>(), 56);
1874 static_assertions::const_assert_eq!(std::mem::align_of::<ProcessStartData>(), 8);
1875
1876 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, process), 0);
1877
1878 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, root_vmar), 4);
1879
1880 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, thread), 8);
1881
1882 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, entry), 16);
1883
1884 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, stack), 24);
1885
1886 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, bootstrap), 32);
1887
1888 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, vdso_base), 40);
1889
1890 static_assertions::const_assert_eq!(std::mem::offset_of!(ProcessStartData, base), 48);
1891
1892 impl ::fidl_next::Constrained for ProcessStartData {
1893 type Constraint = ();
1894
1895 fn validate(
1896 _: ::fidl_next::Slot<'_, Self>,
1897 _: Self::Constraint,
1898 ) -> Result<(), ::fidl_next::ValidationError> {
1899 Ok(())
1900 }
1901 }
1902
1903 unsafe impl ::fidl_next::Wire for ProcessStartData {
1904 type Narrowed<'de> = ProcessStartData;
1905
1906 #[inline]
1907 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1908 ::fidl_next::munge! {
1909 let Self {
1910
1911 process,
1912 root_vmar,
1913 thread,
1914 entry,
1915 stack,
1916 bootstrap,
1917 vdso_base,
1918 base,
1919
1920 } = &mut *out_;
1921 }
1922
1923 ::fidl_next::Wire::zero_padding(process);
1924
1925 ::fidl_next::Wire::zero_padding(root_vmar);
1926
1927 ::fidl_next::Wire::zero_padding(thread);
1928
1929 ::fidl_next::Wire::zero_padding(entry);
1930
1931 ::fidl_next::Wire::zero_padding(stack);
1932
1933 ::fidl_next::Wire::zero_padding(bootstrap);
1934
1935 ::fidl_next::Wire::zero_padding(vdso_base);
1936
1937 ::fidl_next::Wire::zero_padding(base);
1938
1939 unsafe {
1940 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
1941 }
1942
1943 unsafe {
1944 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
1945 }
1946 }
1947 }
1948
1949 unsafe impl<___D> ::fidl_next::Decode<___D> for ProcessStartData
1950 where
1951 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1952 ___D: ::fidl_next::fuchsia::HandleDecoder,
1953 {
1954 fn decode(
1955 slot_: ::fidl_next::Slot<'_, Self>,
1956 decoder_: &mut ___D,
1957 _: (),
1958 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1959 if slot_.as_bytes()[36..40] != [0u8; 4] {
1960 return Err(::fidl_next::DecodeError::InvalidPadding);
1961 }
1962
1963 if slot_.as_bytes()[12..16] != [0u8; 4] {
1964 return Err(::fidl_next::DecodeError::InvalidPadding);
1965 }
1966
1967 ::fidl_next::munge! {
1968 let Self {
1969
1970 mut process,
1971 mut root_vmar,
1972 mut thread,
1973 mut entry,
1974 mut stack,
1975 mut bootstrap,
1976 mut vdso_base,
1977 mut base,
1978
1979 } = slot_;
1980 }
1981
1982 let _field = process.as_mut();
1983
1984 ::fidl_next::Decode::decode(process.as_mut(), decoder_, ())?;
1985
1986 let _field = root_vmar.as_mut();
1987
1988 ::fidl_next::Decode::decode(root_vmar.as_mut(), decoder_, ())?;
1989
1990 let _field = thread.as_mut();
1991
1992 ::fidl_next::Decode::decode(thread.as_mut(), decoder_, ())?;
1993
1994 let _field = entry.as_mut();
1995
1996 ::fidl_next::Decode::decode(entry.as_mut(), decoder_, ())?;
1997
1998 let _field = stack.as_mut();
1999
2000 ::fidl_next::Decode::decode(stack.as_mut(), decoder_, ())?;
2001
2002 let _field = bootstrap.as_mut();
2003
2004 ::fidl_next::Decode::decode(bootstrap.as_mut(), decoder_, ())?;
2005
2006 let _field = vdso_base.as_mut();
2007
2008 ::fidl_next::Decode::decode(vdso_base.as_mut(), decoder_, ())?;
2009
2010 let _field = base.as_mut();
2011
2012 ::fidl_next::Decode::decode(base.as_mut(), decoder_, ())?;
2013
2014 Ok(())
2015 }
2016 }
2017
2018 impl ::fidl_next::IntoNatural for ProcessStartData {
2019 type Natural = crate::natural::ProcessStartData;
2020 }
2021
2022 #[derive(Debug)]
2024 #[repr(C)]
2025 pub struct ResolverResolveResponse {
2026 pub status: ::fidl_next::wire::Int32,
2027
2028 pub executable: ::fidl_next::wire::fuchsia::OptionalVmo,
2029
2030 pub ldsvc: ::fidl_next::ClientEnd<
2031 ::fidl_next_fuchsia_ldsvc::Loader,
2032 ::fidl_next::wire::fuchsia::OptionalChannel,
2033 >,
2034 }
2035
2036 static_assertions::const_assert_eq!(std::mem::size_of::<ResolverResolveResponse>(), 12);
2037 static_assertions::const_assert_eq!(std::mem::align_of::<ResolverResolveResponse>(), 4);
2038
2039 static_assertions::const_assert_eq!(std::mem::offset_of!(ResolverResolveResponse, status), 0);
2040
2041 static_assertions::const_assert_eq!(
2042 std::mem::offset_of!(ResolverResolveResponse, executable),
2043 4
2044 );
2045
2046 static_assertions::const_assert_eq!(std::mem::offset_of!(ResolverResolveResponse, ldsvc), 8);
2047
2048 impl ::fidl_next::Constrained for ResolverResolveResponse {
2049 type Constraint = ();
2050
2051 fn validate(
2052 _: ::fidl_next::Slot<'_, Self>,
2053 _: Self::Constraint,
2054 ) -> Result<(), ::fidl_next::ValidationError> {
2055 Ok(())
2056 }
2057 }
2058
2059 unsafe impl ::fidl_next::Wire for ResolverResolveResponse {
2060 type Narrowed<'de> = ResolverResolveResponse;
2061
2062 #[inline]
2063 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2064 ::fidl_next::munge! {
2065 let Self {
2066
2067 status,
2068 executable,
2069 ldsvc,
2070
2071 } = &mut *out_;
2072 }
2073
2074 ::fidl_next::Wire::zero_padding(status);
2075
2076 ::fidl_next::Wire::zero_padding(executable);
2077
2078 ::fidl_next::Wire::zero_padding(ldsvc);
2079 }
2080 }
2081
2082 unsafe impl<___D> ::fidl_next::Decode<___D> for ResolverResolveResponse
2083 where
2084 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2085 ___D: ::fidl_next::fuchsia::HandleDecoder,
2086 {
2087 fn decode(
2088 slot_: ::fidl_next::Slot<'_, Self>,
2089 decoder_: &mut ___D,
2090 _: (),
2091 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2092 ::fidl_next::munge! {
2093 let Self {
2094
2095 mut status,
2096 mut executable,
2097 mut ldsvc,
2098
2099 } = slot_;
2100 }
2101
2102 let _field = status.as_mut();
2103
2104 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
2105
2106 let _field = executable.as_mut();
2107
2108 ::fidl_next::Decode::decode(executable.as_mut(), decoder_, ())?;
2109
2110 let _field = ldsvc.as_mut();
2111
2112 ::fidl_next::Decode::decode(ldsvc.as_mut(), decoder_, ())?;
2113
2114 Ok(())
2115 }
2116 }
2117
2118 impl ::fidl_next::IntoNatural for ResolverResolveResponse {
2119 type Natural = crate::natural::ResolverResolveResponse;
2120 }
2121}
2122
2123pub mod wire_optional {
2124
2125 pub use fidl_next_common_fuchsia_process::wire_optional::*;
2126}
2127
2128pub mod generic {
2129
2130 pub use fidl_next_common_fuchsia_process::generic::*;
2131
2132 pub struct HandleInfo<T0, T1> {
2133 pub handle: T0,
2134
2135 pub id: T1,
2136 }
2137
2138 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::HandleInfo, ___E> for HandleInfo<T0, T1>
2139 where
2140 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2141 ___E: ::fidl_next::fuchsia::HandleEncoder,
2142 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
2143 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2144 {
2145 #[inline]
2146 fn encode(
2147 self,
2148 encoder_: &mut ___E,
2149 out_: &mut ::core::mem::MaybeUninit<crate::wire::HandleInfo>,
2150 _: (),
2151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2152 ::fidl_next::munge! {
2153 let crate::wire::HandleInfo {
2154
2155 handle,
2156 id,
2157
2158 } = out_;
2159 }
2160
2161 ::fidl_next::Encode::encode(self.handle, encoder_, handle, ())?;
2162
2163 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2164
2165 Ok(())
2166 }
2167 }
2168
2169 pub struct LaunchInfo<T0, T1, T2> {
2170 pub executable: T0,
2171
2172 pub job: T1,
2173
2174 pub name: T2,
2175 }
2176
2177 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>
2178 for LaunchInfo<T0, T1, T2>
2179 where
2180 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2181 ___E: ::fidl_next::Encoder,
2182 ___E: ::fidl_next::fuchsia::HandleEncoder,
2183 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2184 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Job, ___E>,
2185 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2186 {
2187 #[inline]
2188 fn encode(
2189 self,
2190 encoder_: &mut ___E,
2191 out_: &mut ::core::mem::MaybeUninit<crate::wire::LaunchInfo<'static>>,
2192 _: (),
2193 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2194 ::fidl_next::munge! {
2195 let crate::wire::LaunchInfo {
2196
2197 executable,
2198 job,
2199 name,
2200
2201 } = out_;
2202 }
2203
2204 ::fidl_next::Encode::encode(self.executable, encoder_, executable, ())?;
2205
2206 ::fidl_next::Encode::encode(self.job, encoder_, job, ())?;
2207
2208 ::fidl_next::Encode::encode(self.name, encoder_, name, 32)?;
2209
2210 Ok(())
2211 }
2212 }
2213
2214 pub struct LauncherLaunchRequest<T0> {
2215 pub info: T0,
2216 }
2217
2218 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::LauncherLaunchRequest<'static>, ___E>
2219 for LauncherLaunchRequest<T0>
2220 where
2221 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2222 ___E: ::fidl_next::Encoder,
2223 ___E: ::fidl_next::fuchsia::HandleEncoder,
2224 T0: ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>,
2225 {
2226 #[inline]
2227 fn encode(
2228 self,
2229 encoder_: &mut ___E,
2230 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherLaunchRequest<'static>>,
2231 _: (),
2232 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2233 ::fidl_next::munge! {
2234 let crate::wire::LauncherLaunchRequest {
2235
2236 info,
2237
2238 } = out_;
2239 }
2240
2241 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
2242
2243 Ok(())
2244 }
2245 }
2246
2247 pub struct LauncherLaunchResponse<T0, T1> {
2248 pub status: T0,
2249
2250 pub process: T1,
2251 }
2252
2253 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::LauncherLaunchResponse, ___E>
2254 for LauncherLaunchResponse<T0, T1>
2255 where
2256 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2257 ___E: ::fidl_next::fuchsia::HandleEncoder,
2258 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
2259 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalProcess, ___E>,
2260 {
2261 #[inline]
2262 fn encode(
2263 self,
2264 encoder_: &mut ___E,
2265 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherLaunchResponse>,
2266 _: (),
2267 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2268 ::fidl_next::munge! {
2269 let crate::wire::LauncherLaunchResponse {
2270
2271 status,
2272 process,
2273
2274 } = out_;
2275 }
2276
2277 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2278
2279 ::fidl_next::Encode::encode(self.process, encoder_, process, ())?;
2280
2281 Ok(())
2282 }
2283 }
2284
2285 pub struct LauncherCreateWithoutStartingRequest<T0> {
2286 pub info: T0,
2287 }
2288
2289 unsafe impl<___E, T0>
2290 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingRequest<'static>, ___E>
2291 for LauncherCreateWithoutStartingRequest<T0>
2292 where
2293 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2294 ___E: ::fidl_next::Encoder,
2295 ___E: ::fidl_next::fuchsia::HandleEncoder,
2296 T0: ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>,
2297 {
2298 #[inline]
2299 fn encode(
2300 self,
2301 encoder_: &mut ___E,
2302 out_: &mut ::core::mem::MaybeUninit<
2303 crate::wire::LauncherCreateWithoutStartingRequest<'static>,
2304 >,
2305 _: (),
2306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2307 ::fidl_next::munge! {
2308 let crate::wire::LauncherCreateWithoutStartingRequest {
2309
2310 info,
2311
2312 } = out_;
2313 }
2314
2315 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
2316
2317 Ok(())
2318 }
2319 }
2320
2321 pub struct LauncherCreateWithoutStartingResponse<T0, T1> {
2322 pub status: T0,
2323
2324 pub data: T1,
2325 }
2326
2327 unsafe impl<___E, T0, T1>
2328 ::fidl_next::Encode<crate::wire::LauncherCreateWithoutStartingResponse<'static>, ___E>
2329 for LauncherCreateWithoutStartingResponse<T0, T1>
2330 where
2331 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2332 ___E: ::fidl_next::Encoder,
2333 ___E: ::fidl_next::fuchsia::HandleEncoder,
2334 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
2335 T1: ::fidl_next::Encode<
2336 ::fidl_next::wire::Box<'static, crate::wire::ProcessStartData>,
2337 ___E,
2338 >,
2339 {
2340 #[inline]
2341 fn encode(
2342 self,
2343 encoder_: &mut ___E,
2344 out_: &mut ::core::mem::MaybeUninit<
2345 crate::wire::LauncherCreateWithoutStartingResponse<'static>,
2346 >,
2347 _: (),
2348 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2349 ::fidl_next::munge! {
2350 let crate::wire::LauncherCreateWithoutStartingResponse {
2351
2352 status,
2353 data,
2354
2355 } = out_;
2356 }
2357
2358 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2359
2360 ::fidl_next::Encode::encode(self.data, encoder_, data, ())?;
2361
2362 Ok(())
2363 }
2364 }
2365
2366 pub struct LauncherAddHandlesRequest<T0> {
2367 pub handles: T0,
2368 }
2369
2370 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::LauncherAddHandlesRequest<'static>, ___E>
2371 for LauncherAddHandlesRequest<T0>
2372 where
2373 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2374 ___E: ::fidl_next::Encoder,
2375 ___E: ::fidl_next::fuchsia::HandleEncoder,
2376 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::HandleInfo>, ___E>,
2377 {
2378 #[inline]
2379 fn encode(
2380 self,
2381 encoder_: &mut ___E,
2382 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherAddHandlesRequest<'static>>,
2383 _: (),
2384 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2385 ::fidl_next::munge! {
2386 let crate::wire::LauncherAddHandlesRequest {
2387
2388 handles,
2389
2390 } = out_;
2391 }
2392
2393 ::fidl_next::Encode::encode(self.handles, encoder_, handles, (4294967295, ()))?;
2394
2395 Ok(())
2396 }
2397 }
2398
2399 pub struct NameInfo<T0, T1> {
2400 pub path: T0,
2401
2402 pub directory: T1,
2403 }
2404
2405 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NameInfo<'static>, ___E>
2406 for NameInfo<T0, T1>
2407 where
2408 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2409 ___E: ::fidl_next::Encoder,
2410 ___E: ::fidl_next::fuchsia::HandleEncoder,
2411 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2412 T1: ::fidl_next::Encode<
2413 ::fidl_next::ClientEnd<
2414 ::fidl_next_fuchsia_io::Directory,
2415 ::fidl_next::wire::fuchsia::Channel,
2416 >,
2417 ___E,
2418 >,
2419 {
2420 #[inline]
2421 fn encode(
2422 self,
2423 encoder_: &mut ___E,
2424 out_: &mut ::core::mem::MaybeUninit<crate::wire::NameInfo<'static>>,
2425 _: (),
2426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2427 ::fidl_next::munge! {
2428 let crate::wire::NameInfo {
2429
2430 path,
2431 directory,
2432
2433 } = out_;
2434 }
2435
2436 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
2437
2438 ::fidl_next::Encode::encode(self.directory, encoder_, directory, ())?;
2439
2440 Ok(())
2441 }
2442 }
2443
2444 pub struct LauncherAddNamesRequest<T0> {
2445 pub names: T0,
2446 }
2447
2448 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::LauncherAddNamesRequest<'static>, ___E>
2449 for LauncherAddNamesRequest<T0>
2450 where
2451 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2452 ___E: ::fidl_next::Encoder,
2453 ___E: ::fidl_next::fuchsia::HandleEncoder,
2454 T0: ::fidl_next::Encode<
2455 ::fidl_next::wire::Vector<'static, crate::wire::NameInfo<'static>>,
2456 ___E,
2457 >,
2458 {
2459 #[inline]
2460 fn encode(
2461 self,
2462 encoder_: &mut ___E,
2463 out_: &mut ::core::mem::MaybeUninit<crate::wire::LauncherAddNamesRequest<'static>>,
2464 _: (),
2465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2466 ::fidl_next::munge! {
2467 let crate::wire::LauncherAddNamesRequest {
2468
2469 names,
2470
2471 } = out_;
2472 }
2473
2474 ::fidl_next::Encode::encode(self.names, encoder_, names, (4294967295, ()))?;
2475
2476 Ok(())
2477 }
2478 }
2479
2480 pub struct ProcessStartData<T0, T1, T2, T3, T4, T5, T6, T7> {
2481 pub process: T0,
2482
2483 pub root_vmar: T1,
2484
2485 pub thread: T2,
2486
2487 pub entry: T3,
2488
2489 pub stack: T4,
2490
2491 pub bootstrap: T5,
2492
2493 pub vdso_base: T6,
2494
2495 pub base: T7,
2496 }
2497
2498 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7>
2499 ::fidl_next::Encode<crate::wire::ProcessStartData, ___E>
2500 for ProcessStartData<T0, T1, T2, T3, T4, T5, T6, T7>
2501 where
2502 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2503 ___E: ::fidl_next::fuchsia::HandleEncoder,
2504 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Process, ___E>,
2505 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmar, ___E>,
2506 T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Thread, ___E>,
2507 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2508 T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2509 T5: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
2510 T6: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2511 T7: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
2512 {
2513 #[inline]
2514 fn encode(
2515 self,
2516 encoder_: &mut ___E,
2517 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProcessStartData>,
2518 _: (),
2519 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2520 ::fidl_next::munge! {
2521 let crate::wire::ProcessStartData {
2522
2523 process,
2524 root_vmar,
2525 thread,
2526 entry,
2527 stack,
2528 bootstrap,
2529 vdso_base,
2530 base,
2531
2532 } = out_;
2533 }
2534
2535 ::fidl_next::Encode::encode(self.process, encoder_, process, ())?;
2536
2537 ::fidl_next::Encode::encode(self.root_vmar, encoder_, root_vmar, ())?;
2538
2539 ::fidl_next::Encode::encode(self.thread, encoder_, thread, ())?;
2540
2541 ::fidl_next::Encode::encode(self.entry, encoder_, entry, ())?;
2542
2543 ::fidl_next::Encode::encode(self.stack, encoder_, stack, ())?;
2544
2545 ::fidl_next::Encode::encode(self.bootstrap, encoder_, bootstrap, ())?;
2546
2547 ::fidl_next::Encode::encode(self.vdso_base, encoder_, vdso_base, ())?;
2548
2549 ::fidl_next::Encode::encode(self.base, encoder_, base, ())?;
2550
2551 Ok(())
2552 }
2553 }
2554
2555 pub struct ResolverResolveResponse<T0, T1, T2> {
2556 pub status: T0,
2557
2558 pub executable: T1,
2559
2560 pub ldsvc: T2,
2561 }
2562
2563 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::ResolverResolveResponse, ___E>
2564 for ResolverResolveResponse<T0, T1, T2>
2565 where
2566 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2567 ___E: ::fidl_next::fuchsia::HandleEncoder,
2568 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
2569 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>,
2570 T2: ::fidl_next::Encode<
2571 ::fidl_next::ClientEnd<
2572 ::fidl_next_fuchsia_ldsvc::Loader,
2573 ::fidl_next::wire::fuchsia::OptionalChannel,
2574 >,
2575 ___E,
2576 >,
2577 {
2578 #[inline]
2579 fn encode(
2580 self,
2581 encoder_: &mut ___E,
2582 out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolverResolveResponse>,
2583 _: (),
2584 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2585 ::fidl_next::munge! {
2586 let crate::wire::ResolverResolveResponse {
2587
2588 status,
2589 executable,
2590 ldsvc,
2591
2592 } = out_;
2593 }
2594
2595 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2596
2597 ::fidl_next::Encode::encode(self.executable, encoder_, executable, ())?;
2598
2599 ::fidl_next::Encode::encode(self.ldsvc, encoder_, ldsvc, ())?;
2600
2601 Ok(())
2602 }
2603 }
2604}
2605
2606pub use self::natural::*;
2607
2608#[doc = " A low-level interface for launching processes.\n\n This interface is used for manually assembling a process. The caller supplies\n all the capabilities for the newly created process.\n\n That create processes typically use `fdio_spawn` or `fdio_spawn_etc` rather\n than using this interface directly. The `fdio_spawn` and `fdio_spawn_etc`\n functions are implemented using this interface.\n\n Debuggers and other clients that need to create processes in a suspended\n state often use this interface directly. These clients use the\n `CreateWithoutStarting` method to create the process without actually\n starting it.\n"]
2610#[derive(PartialEq, Debug)]
2611pub struct Launcher;
2612
2613impl ::fidl_next::Discoverable for Launcher {
2614 const PROTOCOL_NAME: &'static str = "fuchsia.process.Launcher";
2615}
2616
2617#[cfg(target_os = "fuchsia")]
2618impl ::fidl_next::HasTransport for Launcher {
2619 type Transport = ::fidl_next::fuchsia::zx::Channel;
2620}
2621
2622pub mod launcher {
2623 pub mod prelude {
2624 pub use crate::{Launcher, LauncherClientHandler, LauncherServerHandler, launcher};
2625
2626 pub use crate::natural::LauncherAddArgsRequest;
2627
2628 pub use crate::natural::LauncherAddEnvironsRequest;
2629
2630 pub use crate::natural::LauncherAddHandlesRequest;
2631
2632 pub use crate::natural::LauncherAddNamesRequest;
2633
2634 pub use crate::natural::LauncherCreateWithoutStartingRequest;
2635
2636 pub use crate::natural::LauncherCreateWithoutStartingResponse;
2637
2638 pub use crate::natural::LauncherLaunchRequest;
2639
2640 pub use crate::natural::LauncherLaunchResponse;
2641
2642 pub use crate::natural::LauncherSetOptionsRequest;
2643 }
2644
2645 pub struct Launch;
2646
2647 impl ::fidl_next::Method for Launch {
2648 const ORDINAL: u64 = 1239433936316120996;
2649 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2650 ::fidl_next::protocol::Flexibility::Strict;
2651
2652 type Protocol = crate::Launcher;
2653
2654 type Request = crate::wire::LauncherLaunchRequest<'static>;
2655 }
2656
2657 impl ::fidl_next::TwoWayMethod for Launch {
2658 type Response = crate::wire::LauncherLaunchResponse;
2659 }
2660
2661 impl<___R> ::fidl_next::Respond<___R> for Launch {
2662 type Output = ___R;
2663
2664 fn respond(response: ___R) -> Self::Output {
2665 response
2666 }
2667 }
2668
2669 pub struct CreateWithoutStarting;
2670
2671 impl ::fidl_next::Method for CreateWithoutStarting {
2672 const ORDINAL: u64 = 8457621991205227361;
2673 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2674 ::fidl_next::protocol::Flexibility::Strict;
2675
2676 type Protocol = crate::Launcher;
2677
2678 type Request = crate::wire::LauncherCreateWithoutStartingRequest<'static>;
2679 }
2680
2681 impl ::fidl_next::TwoWayMethod for CreateWithoutStarting {
2682 type Response = crate::wire::LauncherCreateWithoutStartingResponse<'static>;
2683 }
2684
2685 impl<___R> ::fidl_next::Respond<___R> for CreateWithoutStarting {
2686 type Output = ___R;
2687
2688 fn respond(response: ___R) -> Self::Output {
2689 response
2690 }
2691 }
2692
2693 pub struct AddArgs;
2694
2695 impl ::fidl_next::Method for AddArgs {
2696 const ORDINAL: u64 = 4315651119310005522;
2697 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2698 ::fidl_next::protocol::Flexibility::Strict;
2699
2700 type Protocol = crate::Launcher;
2701
2702 type Request = crate::wire::LauncherAddArgsRequest<'static>;
2703 }
2704
2705 pub struct AddEnvirons;
2706
2707 impl ::fidl_next::Method for AddEnvirons {
2708 const ORDINAL: u64 = 8332725285682026361;
2709 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2710 ::fidl_next::protocol::Flexibility::Strict;
2711
2712 type Protocol = crate::Launcher;
2713
2714 type Request = crate::wire::LauncherAddEnvironsRequest<'static>;
2715 }
2716
2717 pub struct AddNames;
2718
2719 impl ::fidl_next::Method for AddNames {
2720 const ORDINAL: u64 = 2700451326409737826;
2721 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2722 ::fidl_next::protocol::Flexibility::Strict;
2723
2724 type Protocol = crate::Launcher;
2725
2726 type Request = crate::wire::LauncherAddNamesRequest<'static>;
2727 }
2728
2729 pub struct AddHandles;
2730
2731 impl ::fidl_next::Method for AddHandles {
2732 const ORDINAL: u64 = 5837318672132580885;
2733 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2734 ::fidl_next::protocol::Flexibility::Strict;
2735
2736 type Protocol = crate::Launcher;
2737
2738 type Request = crate::wire::LauncherAddHandlesRequest<'static>;
2739 }
2740
2741 pub struct SetOptions;
2742
2743 impl ::fidl_next::Method for SetOptions {
2744 const ORDINAL: u64 = 6598432479381290375;
2745 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2746 ::fidl_next::protocol::Flexibility::Strict;
2747
2748 type Protocol = crate::Launcher;
2749
2750 type Request = crate::wire::LauncherSetOptionsRequest;
2751 }
2752
2753 mod ___detail {
2754 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Launcher
2755 where
2756 ___T: ::fidl_next::Transport,
2757 {
2758 type Client = LauncherClient<___T>;
2759 type Server = LauncherServer<___T>;
2760 }
2761
2762 #[repr(transparent)]
2764 pub struct LauncherClient<___T: ::fidl_next::Transport> {
2765 #[allow(dead_code)]
2766 client: ::fidl_next::protocol::Client<___T>,
2767 }
2768
2769 impl<___T> LauncherClient<___T>
2770 where
2771 ___T: ::fidl_next::Transport,
2772 {
2773 #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
2774 pub fn launch(
2775 &self,
2776
2777 info: impl ::fidl_next::Encode<
2778 crate::wire::LaunchInfo<'static>,
2779 <___T as ::fidl_next::Transport>::SendBuffer,
2780 >,
2781 ) -> ::fidl_next::TwoWayFuture<'_, super::Launch, ___T>
2782 where
2783 <___T as ::fidl_next::Transport>::SendBuffer:
2784 ::fidl_next::encoder::InternalHandleEncoder,
2785 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2786 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
2787 {
2788 self.launch_with(crate::generic::LauncherLaunchRequest { info })
2789 }
2790
2791 #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
2792 pub fn launch_with<___R>(
2793 &self,
2794 request: ___R,
2795 ) -> ::fidl_next::TwoWayFuture<'_, super::Launch, ___T>
2796 where
2797 ___R: ::fidl_next::Encode<
2798 crate::wire::LauncherLaunchRequest<'static>,
2799 <___T as ::fidl_next::Transport>::SendBuffer,
2800 >,
2801 {
2802 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
2803 1239433936316120996,
2804 <super::Launch as ::fidl_next::Method>::FLEXIBILITY,
2805 request,
2806 ))
2807 }
2808
2809 #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
2810 pub fn create_without_starting(
2811 &self,
2812
2813 info: impl ::fidl_next::Encode<
2814 crate::wire::LaunchInfo<'static>,
2815 <___T as ::fidl_next::Transport>::SendBuffer,
2816 >,
2817 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateWithoutStarting, ___T>
2818 where
2819 <___T as ::fidl_next::Transport>::SendBuffer:
2820 ::fidl_next::encoder::InternalHandleEncoder,
2821 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2822 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
2823 {
2824 self.create_without_starting_with(
2825 crate::generic::LauncherCreateWithoutStartingRequest { info },
2826 )
2827 }
2828
2829 #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
2830 pub fn create_without_starting_with<___R>(
2831 &self,
2832 request: ___R,
2833 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateWithoutStarting, ___T>
2834 where
2835 ___R: ::fidl_next::Encode<
2836 crate::wire::LauncherCreateWithoutStartingRequest<'static>,
2837 <___T as ::fidl_next::Transport>::SendBuffer,
2838 >,
2839 {
2840 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
2841 8457621991205227361,
2842 <super::CreateWithoutStarting as ::fidl_next::Method>::FLEXIBILITY,
2843 request,
2844 ))
2845 }
2846
2847 #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
2848 pub fn add_args(
2849 &self,
2850
2851 args: impl ::fidl_next::Encode<
2852 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Vector<'static, u8>>,
2853 <___T as ::fidl_next::Transport>::SendBuffer,
2854 >,
2855 ) -> ::fidl_next::SendFuture<'_, ___T>
2856 where
2857 <___T as ::fidl_next::Transport>::SendBuffer:
2858 ::fidl_next::encoder::InternalHandleEncoder,
2859 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2860 {
2861 self.add_args_with(crate::generic::LauncherAddArgsRequest { args })
2862 }
2863
2864 #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
2865 pub fn add_args_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
2866 where
2867 ___R: ::fidl_next::Encode<
2868 crate::wire::LauncherAddArgsRequest<'static>,
2869 <___T as ::fidl_next::Transport>::SendBuffer,
2870 >,
2871 {
2872 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
2873 4315651119310005522,
2874 <super::AddArgs as ::fidl_next::Method>::FLEXIBILITY,
2875 request,
2876 ))
2877 }
2878
2879 #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
2880 pub fn add_environs(
2881 &self,
2882
2883 environ: impl ::fidl_next::Encode<
2884 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Vector<'static, u8>>,
2885 <___T as ::fidl_next::Transport>::SendBuffer,
2886 >,
2887 ) -> ::fidl_next::SendFuture<'_, ___T>
2888 where
2889 <___T as ::fidl_next::Transport>::SendBuffer:
2890 ::fidl_next::encoder::InternalHandleEncoder,
2891 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2892 {
2893 self.add_environs_with(crate::generic::LauncherAddEnvironsRequest { environ })
2894 }
2895
2896 #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
2897 pub fn add_environs_with<___R>(
2898 &self,
2899 request: ___R,
2900 ) -> ::fidl_next::SendFuture<'_, ___T>
2901 where
2902 ___R: ::fidl_next::Encode<
2903 crate::wire::LauncherAddEnvironsRequest<'static>,
2904 <___T as ::fidl_next::Transport>::SendBuffer,
2905 >,
2906 {
2907 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
2908 8332725285682026361,
2909 <super::AddEnvirons as ::fidl_next::Method>::FLEXIBILITY,
2910 request,
2911 ))
2912 }
2913
2914 #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
2915 pub fn add_names(
2916 &self,
2917
2918 names: impl ::fidl_next::Encode<
2919 ::fidl_next::wire::Vector<'static, crate::wire::NameInfo<'static>>,
2920 <___T as ::fidl_next::Transport>::SendBuffer,
2921 >,
2922 ) -> ::fidl_next::SendFuture<'_, ___T>
2923 where
2924 <___T as ::fidl_next::Transport>::SendBuffer:
2925 ::fidl_next::encoder::InternalHandleEncoder,
2926 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2927 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
2928 {
2929 self.add_names_with(crate::generic::LauncherAddNamesRequest { names })
2930 }
2931
2932 #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
2933 pub fn add_names_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
2934 where
2935 ___R: ::fidl_next::Encode<
2936 crate::wire::LauncherAddNamesRequest<'static>,
2937 <___T as ::fidl_next::Transport>::SendBuffer,
2938 >,
2939 {
2940 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
2941 2700451326409737826,
2942 <super::AddNames as ::fidl_next::Method>::FLEXIBILITY,
2943 request,
2944 ))
2945 }
2946
2947 #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
2948 pub fn add_handles(
2949 &self,
2950
2951 handles: impl ::fidl_next::Encode<
2952 ::fidl_next::wire::Vector<'static, crate::wire::HandleInfo>,
2953 <___T as ::fidl_next::Transport>::SendBuffer,
2954 >,
2955 ) -> ::fidl_next::SendFuture<'_, ___T>
2956 where
2957 <___T as ::fidl_next::Transport>::SendBuffer:
2958 ::fidl_next::encoder::InternalHandleEncoder,
2959 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
2960 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
2961 {
2962 self.add_handles_with(crate::generic::LauncherAddHandlesRequest { handles })
2963 }
2964
2965 #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
2966 pub fn add_handles_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
2967 where
2968 ___R: ::fidl_next::Encode<
2969 crate::wire::LauncherAddHandlesRequest<'static>,
2970 <___T as ::fidl_next::Transport>::SendBuffer,
2971 >,
2972 {
2973 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
2974 5837318672132580885,
2975 <super::AddHandles as ::fidl_next::Method>::FLEXIBILITY,
2976 request,
2977 ))
2978 }
2979
2980 #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
2981 pub fn set_options(
2982 &self,
2983
2984 options: impl ::fidl_next::Encode<
2985 ::fidl_next::wire::Uint32,
2986 <___T as ::fidl_next::Transport>::SendBuffer,
2987 >,
2988 ) -> ::fidl_next::SendFuture<'_, ___T>
2989 where
2990 <___T as ::fidl_next::Transport>::SendBuffer:
2991 ::fidl_next::encoder::InternalHandleEncoder,
2992 {
2993 self.set_options_with(crate::generic::LauncherSetOptionsRequest { options })
2994 }
2995
2996 #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
2997 pub fn set_options_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
2998 where
2999 ___R: ::fidl_next::Encode<
3000 crate::wire::LauncherSetOptionsRequest,
3001 <___T as ::fidl_next::Transport>::SendBuffer,
3002 >,
3003 {
3004 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
3005 6598432479381290375,
3006 <super::SetOptions as ::fidl_next::Method>::FLEXIBILITY,
3007 request,
3008 ))
3009 }
3010 }
3011
3012 #[repr(transparent)]
3014 pub struct LauncherServer<___T: ::fidl_next::Transport> {
3015 server: ::fidl_next::protocol::Server<___T>,
3016 }
3017
3018 impl<___T> LauncherServer<___T> where ___T: ::fidl_next::Transport {}
3019 }
3020}
3021
3022pub trait LauncherClientHandler<
3026 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3027 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3028>
3029{
3030}
3031
3032impl<___T> LauncherClientHandler<___T> for ::fidl_next::IgnoreEvents where
3033 ___T: ::fidl_next::Transport
3034{
3035}
3036
3037impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Launcher
3038where
3039 ___H: LauncherClientHandler<___T> + ::core::marker::Send,
3040 ___T: ::fidl_next::Transport,
3041{
3042 async fn on_event(
3043 handler: &mut ___H,
3044 ordinal: u64,
3045 flexibility: ::fidl_next::protocol::Flexibility,
3046 body: ::fidl_next::Body<___T>,
3047 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3048 match ordinal {
3049 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3050 }
3051 }
3052}
3053
3054pub trait LauncherServerHandler<
3058 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3059 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3060>
3061{
3062 #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
3063 fn launch(
3064 &mut self,
3065
3066 request: ::fidl_next::Request<launcher::Launch, ___T>,
3067
3068 responder: ::fidl_next::Responder<launcher::Launch, ___T>,
3069 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3070
3071 #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
3072 fn create_without_starting(
3073 &mut self,
3074
3075 request: ::fidl_next::Request<launcher::CreateWithoutStarting, ___T>,
3076
3077 responder: ::fidl_next::Responder<launcher::CreateWithoutStarting, ___T>,
3078 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3079
3080 #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
3081 fn add_args(
3082 &mut self,
3083
3084 request: ::fidl_next::Request<launcher::AddArgs, ___T>,
3085 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3086
3087 #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
3088 fn add_environs(
3089 &mut self,
3090
3091 request: ::fidl_next::Request<launcher::AddEnvirons, ___T>,
3092 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3093
3094 #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
3095 fn add_names(
3096 &mut self,
3097
3098 request: ::fidl_next::Request<launcher::AddNames, ___T>,
3099 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3100
3101 #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
3102 fn add_handles(
3103 &mut self,
3104
3105 request: ::fidl_next::Request<launcher::AddHandles, ___T>,
3106 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3107
3108 #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
3109 fn set_options(
3110 &mut self,
3111
3112 request: ::fidl_next::Request<launcher::SetOptions, ___T>,
3113 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3114}
3115
3116impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Launcher
3117where
3118 ___H: LauncherServerHandler<___T> + ::core::marker::Send,
3119 ___T: ::fidl_next::Transport,
3120 for<'de> crate::wire::LauncherLaunchRequest<'de>: ::fidl_next::Decode<
3121 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3122 Constraint = (),
3123 >,
3124 for<'de> crate::wire::LauncherCreateWithoutStartingRequest<'de>: ::fidl_next::Decode<
3125 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3126 Constraint = (),
3127 >,
3128 for<'de> crate::wire::LauncherAddArgsRequest<'de>: ::fidl_next::Decode<
3129 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3130 Constraint = (),
3131 >,
3132 for<'de> crate::wire::LauncherAddEnvironsRequest<'de>: ::fidl_next::Decode<
3133 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3134 Constraint = (),
3135 >,
3136 for<'de> crate::wire::LauncherAddNamesRequest<'de>: ::fidl_next::Decode<
3137 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3138 Constraint = (),
3139 >,
3140 for<'de> crate::wire::LauncherAddHandlesRequest<'de>: ::fidl_next::Decode<
3141 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3142 Constraint = (),
3143 >,
3144 for<'de> crate::wire::LauncherSetOptionsRequest: ::fidl_next::Decode<
3145 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3146 Constraint = (),
3147 >,
3148{
3149 async fn on_one_way(
3150 handler: &mut ___H,
3151 ordinal: u64,
3152 flexibility: ::fidl_next::protocol::Flexibility,
3153 body: ::fidl_next::Body<___T>,
3154 ) -> ::core::result::Result<
3155 (),
3156 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3157 > {
3158 match ordinal {
3159 4315651119310005522 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
3160 Ok(decoded) => {
3161 handler.add_args(::fidl_next::Request::from_decoded(decoded)).await;
3162 Ok(())
3163 }
3164 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3165 ordinal: 4315651119310005522,
3166 error,
3167 }),
3168 },
3169
3170 8332725285682026361 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
3171 Ok(decoded) => {
3172 handler.add_environs(::fidl_next::Request::from_decoded(decoded)).await;
3173 Ok(())
3174 }
3175 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3176 ordinal: 8332725285682026361,
3177 error,
3178 }),
3179 },
3180
3181 2700451326409737826 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
3182 Ok(decoded) => {
3183 handler.add_names(::fidl_next::Request::from_decoded(decoded)).await;
3184 Ok(())
3185 }
3186 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3187 ordinal: 2700451326409737826,
3188 error,
3189 }),
3190 },
3191
3192 5837318672132580885 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
3193 Ok(decoded) => {
3194 handler.add_handles(::fidl_next::Request::from_decoded(decoded)).await;
3195 Ok(())
3196 }
3197 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3198 ordinal: 5837318672132580885,
3199 error,
3200 }),
3201 },
3202
3203 6598432479381290375 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
3204 Ok(decoded) => {
3205 handler.set_options(::fidl_next::Request::from_decoded(decoded)).await;
3206 Ok(())
3207 }
3208 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3209 ordinal: 6598432479381290375,
3210 error,
3211 }),
3212 },
3213
3214 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3215 }
3216 }
3217
3218 async fn on_two_way(
3219 handler: &mut ___H,
3220 ordinal: u64,
3221 flexibility: ::fidl_next::protocol::Flexibility,
3222 body: ::fidl_next::Body<___T>,
3223 responder: ::fidl_next::protocol::Responder<___T>,
3224 ) -> ::core::result::Result<
3225 (),
3226 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3227 > {
3228 match ordinal {
3229 1239433936316120996 => {
3230 let responder = ::fidl_next::Responder::from_untyped(responder);
3231
3232 match ::fidl_next::AsDecoderExt::into_decoded(body) {
3233 Ok(decoded) => {
3234 handler
3235 .launch(::fidl_next::Request::from_decoded(decoded), responder)
3236 .await;
3237 Ok(())
3238 }
3239 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3240 ordinal: 1239433936316120996,
3241 error,
3242 }),
3243 }
3244 }
3245
3246 8457621991205227361 => {
3247 let responder = ::fidl_next::Responder::from_untyped(responder);
3248
3249 match ::fidl_next::AsDecoderExt::into_decoded(body) {
3250 Ok(decoded) => {
3251 handler
3252 .create_without_starting(
3253 ::fidl_next::Request::from_decoded(decoded),
3254 responder,
3255 )
3256 .await;
3257 Ok(())
3258 }
3259 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3260 ordinal: 8457621991205227361,
3261 error,
3262 }),
3263 }
3264 }
3265
3266 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3267 }
3268 }
3269}
3270
3271#[doc = " An interface for resolving names to executables and library loaders.\n\n An executable itself is often not sufficient to create a working process\n because many executables also load shared libraries. On Fuchsia, there is no\n global pool of shared libraries. Instead, every process has an associated\n `fuchsia.ldsvc.Loader`, which provides access to a private pool of shared\n libraries appropriate for that process.\n\n This interface provides a protocol for resolving a name into both the\n `zx.Handle:VMO` for the executable and the `fuchsia.ldsvc.Loader` for its\n associated shared libraries.\n\n This interface is rarely used directly. Instead, `fdio_spawn` and\n `fdio_spawn_etc` use this interface internally when they try to run a file\n with a `#!resolve` directive.\n"]
3273#[derive(PartialEq, Debug)]
3274pub struct Resolver;
3275
3276impl ::fidl_next::Discoverable for Resolver {
3277 const PROTOCOL_NAME: &'static str = "fuchsia.process.Resolver";
3278}
3279
3280#[cfg(target_os = "fuchsia")]
3281impl ::fidl_next::HasTransport for Resolver {
3282 type Transport = ::fidl_next::fuchsia::zx::Channel;
3283}
3284
3285pub mod resolver {
3286 pub mod prelude {
3287 pub use crate::{Resolver, ResolverClientHandler, ResolverServerHandler, resolver};
3288
3289 pub use crate::natural::ResolverResolveRequest;
3290
3291 pub use crate::natural::ResolverResolveResponse;
3292 }
3293
3294 pub struct Resolve;
3295
3296 impl ::fidl_next::Method for Resolve {
3297 const ORDINAL: u64 = 4329530577128037520;
3298 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3299 ::fidl_next::protocol::Flexibility::Strict;
3300
3301 type Protocol = crate::Resolver;
3302
3303 type Request = crate::wire::ResolverResolveRequest<'static>;
3304 }
3305
3306 impl ::fidl_next::TwoWayMethod for Resolve {
3307 type Response = crate::wire::ResolverResolveResponse;
3308 }
3309
3310 impl<___R> ::fidl_next::Respond<___R> for Resolve {
3311 type Output = ___R;
3312
3313 fn respond(response: ___R) -> Self::Output {
3314 response
3315 }
3316 }
3317
3318 mod ___detail {
3319 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Resolver
3320 where
3321 ___T: ::fidl_next::Transport,
3322 {
3323 type Client = ResolverClient<___T>;
3324 type Server = ResolverServer<___T>;
3325 }
3326
3327 #[repr(transparent)]
3329 pub struct ResolverClient<___T: ::fidl_next::Transport> {
3330 #[allow(dead_code)]
3331 client: ::fidl_next::protocol::Client<___T>,
3332 }
3333
3334 impl<___T> ResolverClient<___T>
3335 where
3336 ___T: ::fidl_next::Transport,
3337 {
3338 #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
3339 pub fn resolve(
3340 &self,
3341
3342 name: impl ::fidl_next::Encode<
3343 ::fidl_next::wire::String<'static>,
3344 <___T as ::fidl_next::Transport>::SendBuffer,
3345 >,
3346 ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
3347 where
3348 <___T as ::fidl_next::Transport>::SendBuffer:
3349 ::fidl_next::encoder::InternalHandleEncoder,
3350 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
3351 {
3352 self.resolve_with(crate::generic::ResolverResolveRequest { name })
3353 }
3354
3355 #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
3356 pub fn resolve_with<___R>(
3357 &self,
3358 request: ___R,
3359 ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
3360 where
3361 ___R: ::fidl_next::Encode<
3362 crate::wire::ResolverResolveRequest<'static>,
3363 <___T as ::fidl_next::Transport>::SendBuffer,
3364 >,
3365 {
3366 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
3367 4329530577128037520,
3368 <super::Resolve as ::fidl_next::Method>::FLEXIBILITY,
3369 request,
3370 ))
3371 }
3372 }
3373
3374 #[repr(transparent)]
3376 pub struct ResolverServer<___T: ::fidl_next::Transport> {
3377 server: ::fidl_next::protocol::Server<___T>,
3378 }
3379
3380 impl<___T> ResolverServer<___T> where ___T: ::fidl_next::Transport {}
3381 }
3382}
3383
3384pub trait ResolverClientHandler<
3388 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3389 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3390>
3391{
3392}
3393
3394impl<___T> ResolverClientHandler<___T> for ::fidl_next::IgnoreEvents where
3395 ___T: ::fidl_next::Transport
3396{
3397}
3398
3399impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Resolver
3400where
3401 ___H: ResolverClientHandler<___T> + ::core::marker::Send,
3402 ___T: ::fidl_next::Transport,
3403{
3404 async fn on_event(
3405 handler: &mut ___H,
3406 ordinal: u64,
3407 flexibility: ::fidl_next::protocol::Flexibility,
3408 body: ::fidl_next::Body<___T>,
3409 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3410 match ordinal {
3411 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3412 }
3413 }
3414}
3415
3416pub trait ResolverServerHandler<
3420 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3421 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3422>
3423{
3424 #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
3425 fn resolve(
3426 &mut self,
3427
3428 request: ::fidl_next::Request<resolver::Resolve, ___T>,
3429
3430 responder: ::fidl_next::Responder<resolver::Resolve, ___T>,
3431 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3432}
3433
3434impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Resolver
3435where
3436 ___H: ResolverServerHandler<___T> + ::core::marker::Send,
3437 ___T: ::fidl_next::Transport,
3438 for<'de> crate::wire::ResolverResolveRequest<'de>: ::fidl_next::Decode<
3439 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3440 Constraint = (),
3441 >,
3442{
3443 async fn on_one_way(
3444 handler: &mut ___H,
3445 ordinal: u64,
3446 flexibility: ::fidl_next::protocol::Flexibility,
3447 body: ::fidl_next::Body<___T>,
3448 ) -> ::core::result::Result<
3449 (),
3450 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3451 > {
3452 match ordinal {
3453 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3454 }
3455 }
3456
3457 async fn on_two_way(
3458 handler: &mut ___H,
3459 ordinal: u64,
3460 flexibility: ::fidl_next::protocol::Flexibility,
3461 body: ::fidl_next::Body<___T>,
3462 responder: ::fidl_next::protocol::Responder<___T>,
3463 ) -> ::core::result::Result<
3464 (),
3465 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3466 > {
3467 match ordinal {
3468 4329530577128037520 => {
3469 let responder = ::fidl_next::Responder::from_untyped(responder);
3470
3471 match ::fidl_next::AsDecoderExt::into_decoded(body) {
3472 Ok(decoded) => {
3473 handler
3474 .resolve(::fidl_next::Request::from_decoded(decoded), responder)
3475 .await;
3476 Ok(())
3477 }
3478 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3479 ordinal: 4329530577128037520,
3480 error,
3481 }),
3482 }
3483 }
3484
3485 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3486 }
3487 }
3488}
3489
3490pub use fidl_next_common_fuchsia_process::*;
3491
3492pub mod compat {
3494
3495 pub use fidl_next_common_fuchsia_process::compat::*;
3496
3497 impl ::fidl_next::CompatFrom<crate::HandleInfo> for ::fidl_fuchsia_process::HandleInfo {
3498 #[inline]
3499 fn compat_from(value: crate::HandleInfo) -> Self {
3500 Self {
3501 handle: ::fidl_next::CompatFrom::compat_from(value.handle),
3502
3503 id: ::fidl_next::CompatFrom::compat_from(value.id),
3504 }
3505 }
3506 }
3507
3508 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::HandleInfo> for crate::HandleInfo {
3509 #[inline]
3510 fn compat_from(value: ::fidl_fuchsia_process::HandleInfo) -> Self {
3511 Self {
3512 handle: ::fidl_next::CompatFrom::compat_from(value.handle),
3513
3514 id: ::fidl_next::CompatFrom::compat_from(value.id),
3515 }
3516 }
3517 }
3518
3519 impl ::fidl_next::CompatFrom<crate::LaunchInfo> for ::fidl_fuchsia_process::LaunchInfo {
3520 #[inline]
3521 fn compat_from(value: crate::LaunchInfo) -> Self {
3522 Self {
3523 executable: ::fidl_next::CompatFrom::compat_from(value.executable),
3524
3525 job: ::fidl_next::CompatFrom::compat_from(value.job),
3526
3527 name: ::fidl_next::CompatFrom::compat_from(value.name),
3528 }
3529 }
3530 }
3531
3532 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LaunchInfo> for crate::LaunchInfo {
3533 #[inline]
3534 fn compat_from(value: ::fidl_fuchsia_process::LaunchInfo) -> Self {
3535 Self {
3536 executable: ::fidl_next::CompatFrom::compat_from(value.executable),
3537
3538 job: ::fidl_next::CompatFrom::compat_from(value.job),
3539
3540 name: ::fidl_next::CompatFrom::compat_from(value.name),
3541 }
3542 }
3543 }
3544
3545 impl ::fidl_next::CompatFrom<crate::LauncherLaunchRequest>
3546 for ::fidl_fuchsia_process::LauncherLaunchRequest
3547 {
3548 #[inline]
3549 fn compat_from(value: crate::LauncherLaunchRequest) -> Self {
3550 Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
3551 }
3552 }
3553
3554 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherLaunchRequest>
3555 for crate::LauncherLaunchRequest
3556 {
3557 #[inline]
3558 fn compat_from(value: ::fidl_fuchsia_process::LauncherLaunchRequest) -> Self {
3559 Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
3560 }
3561 }
3562
3563 impl ::fidl_next::CompatFrom<crate::LauncherLaunchResponse>
3564 for ::fidl_fuchsia_process::LauncherLaunchResponse
3565 {
3566 #[inline]
3567 fn compat_from(value: crate::LauncherLaunchResponse) -> Self {
3568 Self {
3569 status: ::fidl_next::CompatFrom::compat_from(value.status),
3570
3571 process: ::fidl_next::CompatFrom::compat_from(value.process),
3572 }
3573 }
3574 }
3575
3576 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherLaunchResponse>
3577 for crate::LauncherLaunchResponse
3578 {
3579 #[inline]
3580 fn compat_from(value: ::fidl_fuchsia_process::LauncherLaunchResponse) -> Self {
3581 Self {
3582 status: ::fidl_next::CompatFrom::compat_from(value.status),
3583
3584 process: ::fidl_next::CompatFrom::compat_from(value.process),
3585 }
3586 }
3587 }
3588
3589 impl ::fidl_next::CompatFrom<crate::LauncherCreateWithoutStartingRequest>
3590 for ::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest
3591 {
3592 #[inline]
3593 fn compat_from(value: crate::LauncherCreateWithoutStartingRequest) -> Self {
3594 Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
3595 }
3596 }
3597
3598 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest>
3599 for crate::LauncherCreateWithoutStartingRequest
3600 {
3601 #[inline]
3602 fn compat_from(
3603 value: ::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest,
3604 ) -> Self {
3605 Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
3606 }
3607 }
3608
3609 impl ::fidl_next::CompatFrom<crate::LauncherCreateWithoutStartingResponse>
3610 for ::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse
3611 {
3612 #[inline]
3613 fn compat_from(value: crate::LauncherCreateWithoutStartingResponse) -> Self {
3614 Self {
3615 status: ::fidl_next::CompatFrom::compat_from(value.status),
3616
3617 data: ::fidl_next::CompatFrom::compat_from(value.data),
3618 }
3619 }
3620 }
3621
3622 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse>
3623 for crate::LauncherCreateWithoutStartingResponse
3624 {
3625 #[inline]
3626 fn compat_from(
3627 value: ::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse,
3628 ) -> Self {
3629 Self {
3630 status: ::fidl_next::CompatFrom::compat_from(value.status),
3631
3632 data: ::fidl_next::CompatFrom::compat_from(value.data),
3633 }
3634 }
3635 }
3636
3637 impl ::fidl_next::CompatFrom<crate::LauncherAddHandlesRequest>
3638 for ::fidl_fuchsia_process::LauncherAddHandlesRequest
3639 {
3640 #[inline]
3641 fn compat_from(value: crate::LauncherAddHandlesRequest) -> Self {
3642 Self { handles: ::fidl_next::CompatFrom::compat_from(value.handles) }
3643 }
3644 }
3645
3646 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddHandlesRequest>
3647 for crate::LauncherAddHandlesRequest
3648 {
3649 #[inline]
3650 fn compat_from(value: ::fidl_fuchsia_process::LauncherAddHandlesRequest) -> Self {
3651 Self { handles: ::fidl_next::CompatFrom::compat_from(value.handles) }
3652 }
3653 }
3654
3655 impl ::fidl_next::CompatFrom<crate::NameInfo> for ::fidl_fuchsia_process::NameInfo {
3656 #[inline]
3657 fn compat_from(value: crate::NameInfo) -> Self {
3658 Self {
3659 path: ::fidl_next::CompatFrom::compat_from(value.path),
3660
3661 directory: ::fidl_next::CompatFrom::compat_from(value.directory),
3662 }
3663 }
3664 }
3665
3666 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::NameInfo> for crate::NameInfo {
3667 #[inline]
3668 fn compat_from(value: ::fidl_fuchsia_process::NameInfo) -> Self {
3669 Self {
3670 path: ::fidl_next::CompatFrom::compat_from(value.path),
3671
3672 directory: ::fidl_next::CompatFrom::compat_from(value.directory),
3673 }
3674 }
3675 }
3676
3677 impl ::fidl_next::CompatFrom<crate::LauncherAddNamesRequest>
3678 for ::fidl_fuchsia_process::LauncherAddNamesRequest
3679 {
3680 #[inline]
3681 fn compat_from(value: crate::LauncherAddNamesRequest) -> Self {
3682 Self { names: ::fidl_next::CompatFrom::compat_from(value.names) }
3683 }
3684 }
3685
3686 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddNamesRequest>
3687 for crate::LauncherAddNamesRequest
3688 {
3689 #[inline]
3690 fn compat_from(value: ::fidl_fuchsia_process::LauncherAddNamesRequest) -> Self {
3691 Self { names: ::fidl_next::CompatFrom::compat_from(value.names) }
3692 }
3693 }
3694
3695 #[cfg(target_os = "fuchsia")]
3696 pub type LauncherProxy = ::fidl_next::Client<crate::Launcher>;
3699
3700 impl ::fidl_next::CompatFrom<crate::Launcher> for ::fidl_fuchsia_process::LauncherMarker {
3701 fn compat_from(_: crate::Launcher) -> Self {
3702 Self
3703 }
3704 }
3705
3706 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherMarker> for crate::Launcher {
3707 fn compat_from(_: ::fidl_fuchsia_process::LauncherMarker) -> Self {
3708 Self
3709 }
3710 }
3711
3712 #[cfg(target_os = "fuchsia")]
3713
3714 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_process::LauncherProxy> for crate::Launcher {
3715 fn client_compat_from(
3716 proxy: ::fidl_fuchsia_process::LauncherProxy,
3717 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
3718 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
3719 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
3720 ::fidl_next::ClientDispatcher::new(client_end)
3721 }
3722 }
3723
3724 impl ::fidl_next::CompatFrom<crate::ProcessStartData> for ::fidl_fuchsia_process::ProcessStartData {
3725 #[inline]
3726 fn compat_from(value: crate::ProcessStartData) -> Self {
3727 Self {
3728 process: ::fidl_next::CompatFrom::compat_from(value.process),
3729
3730 root_vmar: ::fidl_next::CompatFrom::compat_from(value.root_vmar),
3731
3732 thread: ::fidl_next::CompatFrom::compat_from(value.thread),
3733
3734 entry: ::fidl_next::CompatFrom::compat_from(value.entry),
3735
3736 stack: ::fidl_next::CompatFrom::compat_from(value.stack),
3737
3738 bootstrap: ::fidl_next::CompatFrom::compat_from(value.bootstrap),
3739
3740 vdso_base: ::fidl_next::CompatFrom::compat_from(value.vdso_base),
3741
3742 base: ::fidl_next::CompatFrom::compat_from(value.base),
3743 }
3744 }
3745 }
3746
3747 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ProcessStartData> for crate::ProcessStartData {
3748 #[inline]
3749 fn compat_from(value: ::fidl_fuchsia_process::ProcessStartData) -> Self {
3750 Self {
3751 process: ::fidl_next::CompatFrom::compat_from(value.process),
3752
3753 root_vmar: ::fidl_next::CompatFrom::compat_from(value.root_vmar),
3754
3755 thread: ::fidl_next::CompatFrom::compat_from(value.thread),
3756
3757 entry: ::fidl_next::CompatFrom::compat_from(value.entry),
3758
3759 stack: ::fidl_next::CompatFrom::compat_from(value.stack),
3760
3761 bootstrap: ::fidl_next::CompatFrom::compat_from(value.bootstrap),
3762
3763 vdso_base: ::fidl_next::CompatFrom::compat_from(value.vdso_base),
3764
3765 base: ::fidl_next::CompatFrom::compat_from(value.base),
3766 }
3767 }
3768 }
3769
3770 impl ::fidl_next::CompatFrom<crate::ResolverResolveResponse>
3771 for ::fidl_fuchsia_process::ResolverResolveResponse
3772 {
3773 #[inline]
3774 fn compat_from(value: crate::ResolverResolveResponse) -> Self {
3775 Self {
3776 status: ::fidl_next::CompatFrom::compat_from(value.status),
3777
3778 executable: ::fidl_next::CompatFrom::compat_from(value.executable),
3779
3780 ldsvc: ::fidl_next::CompatFrom::compat_from(value.ldsvc),
3781 }
3782 }
3783 }
3784
3785 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ResolverResolveResponse>
3786 for crate::ResolverResolveResponse
3787 {
3788 #[inline]
3789 fn compat_from(value: ::fidl_fuchsia_process::ResolverResolveResponse) -> Self {
3790 Self {
3791 status: ::fidl_next::CompatFrom::compat_from(value.status),
3792
3793 executable: ::fidl_next::CompatFrom::compat_from(value.executable),
3794
3795 ldsvc: ::fidl_next::CompatFrom::compat_from(value.ldsvc),
3796 }
3797 }
3798 }
3799
3800 #[cfg(target_os = "fuchsia")]
3801 pub type ResolverProxy = ::fidl_next::Client<crate::Resolver>;
3804
3805 impl ::fidl_next::CompatFrom<crate::Resolver> for ::fidl_fuchsia_process::ResolverMarker {
3806 fn compat_from(_: crate::Resolver) -> Self {
3807 Self
3808 }
3809 }
3810
3811 impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ResolverMarker> for crate::Resolver {
3812 fn compat_from(_: ::fidl_fuchsia_process::ResolverMarker) -> Self {
3813 Self
3814 }
3815 }
3816
3817 #[cfg(target_os = "fuchsia")]
3818
3819 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_process::ResolverProxy> for crate::Resolver {
3820 fn client_compat_from(
3821 proxy: ::fidl_fuchsia_process::ResolverProxy,
3822 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
3823 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
3824 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
3825 ::fidl_next::ClientDispatcher::new(client_end)
3826 }
3827 }
3828}