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