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