1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5#[derive(Clone, Debug)]
6pub struct LoaderLoadObjectRequest {
7 pub object_name: String,
8}
9
10impl ::fidl_next::Encodable for LoaderLoadObjectRequest {
11 type Encoded = WireLoaderLoadObjectRequest<'static>;
12}
13
14unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderLoadObjectRequest
15where
16 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17
18 ___E: ::fidl_next::Encoder,
19{
20 #[inline]
21 fn encode(
22 self,
23 encoder: &mut ___E,
24 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
25 ) -> Result<(), ::fidl_next::EncodeError> {
26 ::fidl_next::munge! {
27 let Self::Encoded {
28 object_name,
29
30 } = out;
31 }
32
33 ::fidl_next::Encode::encode(self.object_name, encoder, object_name)?;
34
35 Ok(())
36 }
37}
38
39unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LoaderLoadObjectRequest
40where
41 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
42
43 ___E: ::fidl_next::Encoder,
44{
45 #[inline]
46 fn encode_ref(
47 &self,
48 encoder: &mut ___E,
49 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
50 ) -> Result<(), ::fidl_next::EncodeError> {
51 ::fidl_next::munge! {
52 let Self::Encoded {
53 object_name,
54
55 } = out;
56 }
57
58 ::fidl_next::EncodeRef::encode_ref(&self.object_name, encoder, object_name)?;
59
60 Ok(())
61 }
62}
63
64impl ::fidl_next::EncodableOption for LoaderLoadObjectRequest {
65 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderLoadObjectRequest<'static>>;
66}
67
68unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderLoadObjectRequest
69where
70 ___E: ::fidl_next::Encoder + ?Sized,
71 LoaderLoadObjectRequest: ::fidl_next::Encode<___E>,
72{
73 #[inline]
74 fn encode_option(
75 this: Option<Self>,
76 encoder: &mut ___E,
77 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
78 ) -> Result<(), ::fidl_next::EncodeError> {
79 if let Some(inner) = this {
80 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
81 ::fidl_next::WireBox::encode_present(out);
82 } else {
83 ::fidl_next::WireBox::encode_absent(out);
84 }
85
86 Ok(())
87 }
88}
89
90unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LoaderLoadObjectRequest
91where
92 ___E: ::fidl_next::Encoder + ?Sized,
93 LoaderLoadObjectRequest: ::fidl_next::EncodeRef<___E>,
94{
95 #[inline]
96 fn encode_option_ref(
97 this: Option<&Self>,
98 encoder: &mut ___E,
99 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
100 ) -> Result<(), ::fidl_next::EncodeError> {
101 if let Some(inner) = this {
102 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
103 ::fidl_next::WireBox::encode_present(out);
104 } else {
105 ::fidl_next::WireBox::encode_absent(out);
106 }
107
108 Ok(())
109 }
110}
111
112impl<'de> ::fidl_next::FromWire<WireLoaderLoadObjectRequest<'de>> for LoaderLoadObjectRequest {
113 #[inline]
114 fn from_wire(wire: WireLoaderLoadObjectRequest<'de>) -> Self {
115 Self { object_name: ::fidl_next::FromWire::from_wire(wire.object_name) }
116 }
117}
118
119impl<'de> ::fidl_next::FromWireRef<WireLoaderLoadObjectRequest<'de>> for LoaderLoadObjectRequest {
120 #[inline]
121 fn from_wire_ref(wire: &WireLoaderLoadObjectRequest<'de>) -> Self {
122 Self { object_name: ::fidl_next::FromWireRef::from_wire_ref(&wire.object_name) }
123 }
124}
125
126#[derive(Debug)]
128#[repr(C)]
129pub struct WireLoaderLoadObjectRequest<'de> {
130 pub object_name: ::fidl_next::WireString<'de>,
131}
132
133unsafe impl ::fidl_next::Wire for WireLoaderLoadObjectRequest<'static> {
134 type Decoded<'de> = WireLoaderLoadObjectRequest<'de>;
135
136 #[inline]
137 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
138}
139
140unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderLoadObjectRequest<'static>
141where
142 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
143
144 ___D: ::fidl_next::Decoder,
145{
146 fn decode(
147 slot: ::fidl_next::Slot<'_, Self>,
148 decoder: &mut ___D,
149 ) -> Result<(), ::fidl_next::DecodeError> {
150 ::fidl_next::munge! {
151 let Self {
152 mut object_name,
153
154 } = slot;
155 }
156
157 ::fidl_next::Decode::decode(object_name.as_mut(), decoder)?;
158
159 let object_name = unsafe { object_name.deref_unchecked() };
160
161 if object_name.len() > 1024 {
162 return Err(::fidl_next::DecodeError::VectorTooLong {
163 size: object_name.len() as u64,
164 limit: 1024,
165 });
166 }
167
168 Ok(())
169 }
170}
171
172#[derive(Debug)]
173#[repr(C)]
174pub struct LoaderLoadObjectResponse {
175 pub rv: i32,
176
177 pub object: Option<::fidl_next::fuchsia::zx::Handle>,
178}
179
180impl ::fidl_next::Encodable for LoaderLoadObjectResponse {
181 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireLoaderLoadObjectResponse> = unsafe {
182 ::fidl_next::CopyOptimization::enable_if(
183 true
184
185 && <
186 i32 as ::fidl_next::Encodable
187 >::COPY_OPTIMIZATION.is_enabled()
188
189 && <
190 Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
191 >::COPY_OPTIMIZATION.is_enabled()
192
193 )
194 };
195
196 type Encoded = WireLoaderLoadObjectResponse;
197}
198
199unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderLoadObjectResponse
200where
201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
202
203 ___E: ::fidl_next::fuchsia::HandleEncoder,
204{
205 #[inline]
206 fn encode(
207 self,
208 encoder: &mut ___E,
209 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
210 ) -> Result<(), ::fidl_next::EncodeError> {
211 ::fidl_next::munge! {
212 let Self::Encoded {
213 rv,
214 object,
215
216 } = out;
217 }
218
219 ::fidl_next::Encode::encode(self.rv, encoder, rv)?;
220
221 ::fidl_next::Encode::encode(self.object, encoder, object)?;
222
223 Ok(())
224 }
225}
226
227impl ::fidl_next::EncodableOption for LoaderLoadObjectResponse {
228 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderLoadObjectResponse>;
229}
230
231unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderLoadObjectResponse
232where
233 ___E: ::fidl_next::Encoder + ?Sized,
234 LoaderLoadObjectResponse: ::fidl_next::Encode<___E>,
235{
236 #[inline]
237 fn encode_option(
238 this: Option<Self>,
239 encoder: &mut ___E,
240 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
241 ) -> Result<(), ::fidl_next::EncodeError> {
242 if let Some(inner) = this {
243 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
244 ::fidl_next::WireBox::encode_present(out);
245 } else {
246 ::fidl_next::WireBox::encode_absent(out);
247 }
248
249 Ok(())
250 }
251}
252
253impl ::fidl_next::FromWire<WireLoaderLoadObjectResponse> for LoaderLoadObjectResponse {
254 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLoaderLoadObjectResponse, Self> = unsafe {
255 ::fidl_next::CopyOptimization::enable_if(
256 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
257 .is_enabled()
258 && <Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::FromWire<
259 ::fidl_next::fuchsia::WireOptionalHandle,
260 >>::COPY_OPTIMIZATION
261 .is_enabled(),
262 )
263 };
264
265 #[inline]
266 fn from_wire(wire: WireLoaderLoadObjectResponse) -> Self {
267 Self {
268 rv: ::fidl_next::FromWire::from_wire(wire.rv),
269
270 object: ::fidl_next::FromWire::from_wire(wire.object),
271 }
272 }
273}
274
275#[derive(Debug)]
277#[repr(C)]
278pub struct WireLoaderLoadObjectResponse {
279 pub rv: ::fidl_next::WireI32,
280
281 pub object: ::fidl_next::fuchsia::WireOptionalHandle,
282}
283
284unsafe impl ::fidl_next::Wire for WireLoaderLoadObjectResponse {
285 type Decoded<'de> = WireLoaderLoadObjectResponse;
286
287 #[inline]
288 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
289}
290
291unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderLoadObjectResponse
292where
293 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
294
295 ___D: ::fidl_next::fuchsia::HandleDecoder,
296{
297 fn decode(
298 slot: ::fidl_next::Slot<'_, Self>,
299 decoder: &mut ___D,
300 ) -> Result<(), ::fidl_next::DecodeError> {
301 ::fidl_next::munge! {
302 let Self {
303 mut rv,
304 mut object,
305
306 } = slot;
307 }
308
309 ::fidl_next::Decode::decode(rv.as_mut(), decoder)?;
310
311 ::fidl_next::Decode::decode(object.as_mut(), decoder)?;
312
313 Ok(())
314 }
315}
316
317#[derive(Clone, Debug)]
318pub struct LoaderConfigRequest {
319 pub config: String,
320}
321
322impl ::fidl_next::Encodable for LoaderConfigRequest {
323 type Encoded = WireLoaderConfigRequest<'static>;
324}
325
326unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderConfigRequest
327where
328 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
329
330 ___E: ::fidl_next::Encoder,
331{
332 #[inline]
333 fn encode(
334 self,
335 encoder: &mut ___E,
336 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
337 ) -> Result<(), ::fidl_next::EncodeError> {
338 ::fidl_next::munge! {
339 let Self::Encoded {
340 config,
341
342 } = out;
343 }
344
345 ::fidl_next::Encode::encode(self.config, encoder, config)?;
346
347 Ok(())
348 }
349}
350
351unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LoaderConfigRequest
352where
353 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
354
355 ___E: ::fidl_next::Encoder,
356{
357 #[inline]
358 fn encode_ref(
359 &self,
360 encoder: &mut ___E,
361 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
362 ) -> Result<(), ::fidl_next::EncodeError> {
363 ::fidl_next::munge! {
364 let Self::Encoded {
365 config,
366
367 } = out;
368 }
369
370 ::fidl_next::EncodeRef::encode_ref(&self.config, encoder, config)?;
371
372 Ok(())
373 }
374}
375
376impl ::fidl_next::EncodableOption for LoaderConfigRequest {
377 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderConfigRequest<'static>>;
378}
379
380unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderConfigRequest
381where
382 ___E: ::fidl_next::Encoder + ?Sized,
383 LoaderConfigRequest: ::fidl_next::Encode<___E>,
384{
385 #[inline]
386 fn encode_option(
387 this: Option<Self>,
388 encoder: &mut ___E,
389 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
390 ) -> Result<(), ::fidl_next::EncodeError> {
391 if let Some(inner) = this {
392 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
393 ::fidl_next::WireBox::encode_present(out);
394 } else {
395 ::fidl_next::WireBox::encode_absent(out);
396 }
397
398 Ok(())
399 }
400}
401
402unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LoaderConfigRequest
403where
404 ___E: ::fidl_next::Encoder + ?Sized,
405 LoaderConfigRequest: ::fidl_next::EncodeRef<___E>,
406{
407 #[inline]
408 fn encode_option_ref(
409 this: Option<&Self>,
410 encoder: &mut ___E,
411 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
412 ) -> Result<(), ::fidl_next::EncodeError> {
413 if let Some(inner) = this {
414 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
415 ::fidl_next::WireBox::encode_present(out);
416 } else {
417 ::fidl_next::WireBox::encode_absent(out);
418 }
419
420 Ok(())
421 }
422}
423
424impl<'de> ::fidl_next::FromWire<WireLoaderConfigRequest<'de>> for LoaderConfigRequest {
425 #[inline]
426 fn from_wire(wire: WireLoaderConfigRequest<'de>) -> Self {
427 Self { config: ::fidl_next::FromWire::from_wire(wire.config) }
428 }
429}
430
431impl<'de> ::fidl_next::FromWireRef<WireLoaderConfigRequest<'de>> for LoaderConfigRequest {
432 #[inline]
433 fn from_wire_ref(wire: &WireLoaderConfigRequest<'de>) -> Self {
434 Self { config: ::fidl_next::FromWireRef::from_wire_ref(&wire.config) }
435 }
436}
437
438#[derive(Debug)]
440#[repr(C)]
441pub struct WireLoaderConfigRequest<'de> {
442 pub config: ::fidl_next::WireString<'de>,
443}
444
445unsafe impl ::fidl_next::Wire for WireLoaderConfigRequest<'static> {
446 type Decoded<'de> = WireLoaderConfigRequest<'de>;
447
448 #[inline]
449 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
450}
451
452unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderConfigRequest<'static>
453where
454 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
455
456 ___D: ::fidl_next::Decoder,
457{
458 fn decode(
459 slot: ::fidl_next::Slot<'_, Self>,
460 decoder: &mut ___D,
461 ) -> Result<(), ::fidl_next::DecodeError> {
462 ::fidl_next::munge! {
463 let Self {
464 mut config,
465
466 } = slot;
467 }
468
469 ::fidl_next::Decode::decode(config.as_mut(), decoder)?;
470
471 let config = unsafe { config.deref_unchecked() };
472
473 if config.len() > 1024 {
474 return Err(::fidl_next::DecodeError::VectorTooLong {
475 size: config.len() as u64,
476 limit: 1024,
477 });
478 }
479
480 Ok(())
481 }
482}
483
484#[derive(Clone, Debug)]
485#[repr(C)]
486pub struct LoaderConfigResponse {
487 pub rv: i32,
488}
489
490impl ::fidl_next::Encodable for LoaderConfigResponse {
491 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireLoaderConfigResponse> = unsafe {
492 ::fidl_next::CopyOptimization::enable_if(
493 true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
494 )
495 };
496
497 type Encoded = WireLoaderConfigResponse;
498}
499
500unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderConfigResponse
501where
502 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
503{
504 #[inline]
505 fn encode(
506 self,
507 encoder: &mut ___E,
508 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
509 ) -> Result<(), ::fidl_next::EncodeError> {
510 ::fidl_next::munge! {
511 let Self::Encoded {
512 rv,
513
514 } = out;
515 }
516
517 ::fidl_next::Encode::encode(self.rv, encoder, rv)?;
518
519 Ok(())
520 }
521}
522
523unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LoaderConfigResponse
524where
525 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
526{
527 #[inline]
528 fn encode_ref(
529 &self,
530 encoder: &mut ___E,
531 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
532 ) -> Result<(), ::fidl_next::EncodeError> {
533 ::fidl_next::munge! {
534 let Self::Encoded {
535 rv,
536
537 } = out;
538 }
539
540 ::fidl_next::EncodeRef::encode_ref(&self.rv, encoder, rv)?;
541
542 Ok(())
543 }
544}
545
546impl ::fidl_next::EncodableOption for LoaderConfigResponse {
547 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderConfigResponse>;
548}
549
550unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderConfigResponse
551where
552 ___E: ::fidl_next::Encoder + ?Sized,
553 LoaderConfigResponse: ::fidl_next::Encode<___E>,
554{
555 #[inline]
556 fn encode_option(
557 this: Option<Self>,
558 encoder: &mut ___E,
559 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
560 ) -> Result<(), ::fidl_next::EncodeError> {
561 if let Some(inner) = this {
562 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
563 ::fidl_next::WireBox::encode_present(out);
564 } else {
565 ::fidl_next::WireBox::encode_absent(out);
566 }
567
568 Ok(())
569 }
570}
571
572unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LoaderConfigResponse
573where
574 ___E: ::fidl_next::Encoder + ?Sized,
575 LoaderConfigResponse: ::fidl_next::EncodeRef<___E>,
576{
577 #[inline]
578 fn encode_option_ref(
579 this: Option<&Self>,
580 encoder: &mut ___E,
581 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
582 ) -> Result<(), ::fidl_next::EncodeError> {
583 if let Some(inner) = this {
584 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
585 ::fidl_next::WireBox::encode_present(out);
586 } else {
587 ::fidl_next::WireBox::encode_absent(out);
588 }
589
590 Ok(())
591 }
592}
593
594impl ::fidl_next::FromWire<WireLoaderConfigResponse> for LoaderConfigResponse {
595 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLoaderConfigResponse, Self> = unsafe {
596 ::fidl_next::CopyOptimization::enable_if(
597 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
598 .is_enabled(),
599 )
600 };
601
602 #[inline]
603 fn from_wire(wire: WireLoaderConfigResponse) -> Self {
604 Self { rv: ::fidl_next::FromWire::from_wire(wire.rv) }
605 }
606}
607
608impl ::fidl_next::FromWireRef<WireLoaderConfigResponse> for LoaderConfigResponse {
609 #[inline]
610 fn from_wire_ref(wire: &WireLoaderConfigResponse) -> Self {
611 Self { rv: ::fidl_next::FromWireRef::from_wire_ref(&wire.rv) }
612 }
613}
614
615#[derive(Clone, Debug)]
617#[repr(C)]
618pub struct WireLoaderConfigResponse {
619 pub rv: ::fidl_next::WireI32,
620}
621
622unsafe impl ::fidl_next::Wire for WireLoaderConfigResponse {
623 type Decoded<'de> = WireLoaderConfigResponse;
624
625 #[inline]
626 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
627}
628
629unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderConfigResponse
630where
631 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
632{
633 fn decode(
634 slot: ::fidl_next::Slot<'_, Self>,
635 decoder: &mut ___D,
636 ) -> Result<(), ::fidl_next::DecodeError> {
637 ::fidl_next::munge! {
638 let Self {
639 mut rv,
640
641 } = slot;
642 }
643
644 ::fidl_next::Decode::decode(rv.as_mut(), decoder)?;
645
646 Ok(())
647 }
648}
649
650#[derive(Debug)]
651#[repr(C)]
652pub struct LoaderCloneRequest {
653 pub loader: ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::zx::Channel>,
654}
655
656impl ::fidl_next::Encodable for LoaderCloneRequest {
657 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireLoaderCloneRequest> = unsafe {
658 ::fidl_next::CopyOptimization::enable_if(
659 true
660
661 && <
662 ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encodable
663 >::COPY_OPTIMIZATION.is_enabled()
664
665 )
666 };
667
668 type Encoded = WireLoaderCloneRequest;
669}
670
671unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderCloneRequest
672where
673 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
674
675 ___E: ::fidl_next::fuchsia::HandleEncoder,
676{
677 #[inline]
678 fn encode(
679 self,
680 encoder: &mut ___E,
681 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
682 ) -> Result<(), ::fidl_next::EncodeError> {
683 ::fidl_next::munge! {
684 let Self::Encoded {
685 loader,
686
687 } = out;
688 }
689
690 ::fidl_next::Encode::encode(self.loader, encoder, loader)?;
691
692 Ok(())
693 }
694}
695
696impl ::fidl_next::EncodableOption for LoaderCloneRequest {
697 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderCloneRequest>;
698}
699
700unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderCloneRequest
701where
702 ___E: ::fidl_next::Encoder + ?Sized,
703 LoaderCloneRequest: ::fidl_next::Encode<___E>,
704{
705 #[inline]
706 fn encode_option(
707 this: Option<Self>,
708 encoder: &mut ___E,
709 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
710 ) -> Result<(), ::fidl_next::EncodeError> {
711 if let Some(inner) = this {
712 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
713 ::fidl_next::WireBox::encode_present(out);
714 } else {
715 ::fidl_next::WireBox::encode_absent(out);
716 }
717
718 Ok(())
719 }
720}
721
722impl ::fidl_next::FromWire<WireLoaderCloneRequest> for LoaderCloneRequest {
723 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLoaderCloneRequest, Self> = unsafe {
724 ::fidl_next::CopyOptimization::enable_if(
725 true
726
727 && <
728 ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::WireChannel>>
729 >::COPY_OPTIMIZATION.is_enabled()
730
731 )
732 };
733
734 #[inline]
735 fn from_wire(wire: WireLoaderCloneRequest) -> Self {
736 Self { loader: ::fidl_next::FromWire::from_wire(wire.loader) }
737 }
738}
739
740#[derive(Debug)]
742#[repr(C)]
743pub struct WireLoaderCloneRequest {
744 pub loader: ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::WireChannel>,
745}
746
747unsafe impl ::fidl_next::Wire for WireLoaderCloneRequest {
748 type Decoded<'de> = WireLoaderCloneRequest;
749
750 #[inline]
751 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
752}
753
754unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderCloneRequest
755where
756 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
757
758 ___D: ::fidl_next::fuchsia::HandleDecoder,
759{
760 fn decode(
761 slot: ::fidl_next::Slot<'_, Self>,
762 decoder: &mut ___D,
763 ) -> Result<(), ::fidl_next::DecodeError> {
764 ::fidl_next::munge! {
765 let Self {
766 mut loader,
767
768 } = slot;
769 }
770
771 ::fidl_next::Decode::decode(loader.as_mut(), decoder)?;
772
773 Ok(())
774 }
775}
776
777#[derive(Clone, Debug)]
778#[repr(C)]
779pub struct LoaderCloneResponse {
780 pub rv: i32,
781}
782
783impl ::fidl_next::Encodable for LoaderCloneResponse {
784 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireLoaderCloneResponse> = unsafe {
785 ::fidl_next::CopyOptimization::enable_if(
786 true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
787 )
788 };
789
790 type Encoded = WireLoaderCloneResponse;
791}
792
793unsafe impl<___E> ::fidl_next::Encode<___E> for LoaderCloneResponse
794where
795 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
796{
797 #[inline]
798 fn encode(
799 self,
800 encoder: &mut ___E,
801 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
802 ) -> Result<(), ::fidl_next::EncodeError> {
803 ::fidl_next::munge! {
804 let Self::Encoded {
805 rv,
806
807 } = out;
808 }
809
810 ::fidl_next::Encode::encode(self.rv, encoder, rv)?;
811
812 Ok(())
813 }
814}
815
816unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LoaderCloneResponse
817where
818 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
819{
820 #[inline]
821 fn encode_ref(
822 &self,
823 encoder: &mut ___E,
824 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
825 ) -> Result<(), ::fidl_next::EncodeError> {
826 ::fidl_next::munge! {
827 let Self::Encoded {
828 rv,
829
830 } = out;
831 }
832
833 ::fidl_next::EncodeRef::encode_ref(&self.rv, encoder, rv)?;
834
835 Ok(())
836 }
837}
838
839impl ::fidl_next::EncodableOption for LoaderCloneResponse {
840 type EncodedOption = ::fidl_next::WireBox<'static, WireLoaderCloneResponse>;
841}
842
843unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LoaderCloneResponse
844where
845 ___E: ::fidl_next::Encoder + ?Sized,
846 LoaderCloneResponse: ::fidl_next::Encode<___E>,
847{
848 #[inline]
849 fn encode_option(
850 this: Option<Self>,
851 encoder: &mut ___E,
852 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
853 ) -> Result<(), ::fidl_next::EncodeError> {
854 if let Some(inner) = this {
855 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
856 ::fidl_next::WireBox::encode_present(out);
857 } else {
858 ::fidl_next::WireBox::encode_absent(out);
859 }
860
861 Ok(())
862 }
863}
864
865unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LoaderCloneResponse
866where
867 ___E: ::fidl_next::Encoder + ?Sized,
868 LoaderCloneResponse: ::fidl_next::EncodeRef<___E>,
869{
870 #[inline]
871 fn encode_option_ref(
872 this: Option<&Self>,
873 encoder: &mut ___E,
874 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
875 ) -> Result<(), ::fidl_next::EncodeError> {
876 if let Some(inner) = this {
877 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
878 ::fidl_next::WireBox::encode_present(out);
879 } else {
880 ::fidl_next::WireBox::encode_absent(out);
881 }
882
883 Ok(())
884 }
885}
886
887impl ::fidl_next::FromWire<WireLoaderCloneResponse> for LoaderCloneResponse {
888 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLoaderCloneResponse, Self> = unsafe {
889 ::fidl_next::CopyOptimization::enable_if(
890 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
891 .is_enabled(),
892 )
893 };
894
895 #[inline]
896 fn from_wire(wire: WireLoaderCloneResponse) -> Self {
897 Self { rv: ::fidl_next::FromWire::from_wire(wire.rv) }
898 }
899}
900
901impl ::fidl_next::FromWireRef<WireLoaderCloneResponse> for LoaderCloneResponse {
902 #[inline]
903 fn from_wire_ref(wire: &WireLoaderCloneResponse) -> Self {
904 Self { rv: ::fidl_next::FromWireRef::from_wire_ref(&wire.rv) }
905 }
906}
907
908#[derive(Clone, Debug)]
910#[repr(C)]
911pub struct WireLoaderCloneResponse {
912 pub rv: ::fidl_next::WireI32,
913}
914
915unsafe impl ::fidl_next::Wire for WireLoaderCloneResponse {
916 type Decoded<'de> = WireLoaderCloneResponse;
917
918 #[inline]
919 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
920}
921
922unsafe impl<___D> ::fidl_next::Decode<___D> for WireLoaderCloneResponse
923where
924 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
925{
926 fn decode(
927 slot: ::fidl_next::Slot<'_, Self>,
928 decoder: &mut ___D,
929 ) -> Result<(), ::fidl_next::DecodeError> {
930 ::fidl_next::munge! {
931 let Self {
932 mut rv,
933
934 } = slot;
935 }
936
937 ::fidl_next::Decode::decode(rv.as_mut(), decoder)?;
938
939 Ok(())
940 }
941}
942
943#[doc = " See //docs/concepts/process/program_loading.md for a more complete\n description of this and related process bootstrapping protocols, and\n for specifics about the default global loader service\'s\n interpretation of names, paths, and configurations.\n"]
945#[derive(Debug)]
946pub struct Loader;
947
948pub mod loader {
949 pub mod prelude {
950 pub use crate::{loader, Loader, LoaderClientHandler, LoaderServerHandler};
951
952 pub use crate::LoaderCloneRequest;
953
954 pub use crate::LoaderCloneResponse;
955
956 pub use crate::LoaderConfigRequest;
957
958 pub use crate::LoaderConfigResponse;
959
960 pub use crate::LoaderLoadObjectRequest;
961
962 pub use crate::LoaderLoadObjectResponse;
963 }
964
965 pub struct Done;
966
967 impl ::fidl_next::Method for Done {
968 const ORDINAL: u64 = 7186174313520107521;
969
970 type Protocol = crate::Loader;
971
972 type Request = ();
973
974 type Response = ::fidl_next::Never;
975 }
976
977 pub struct LoadObject;
978
979 impl ::fidl_next::Method for LoadObject {
980 const ORDINAL: u64 = 5243774714012182611;
981
982 type Protocol = crate::Loader;
983
984 type Request = crate::WireLoaderLoadObjectRequest<'static>;
985
986 type Response = crate::WireLoaderLoadObjectResponse;
987 }
988
989 pub struct Config;
990
991 impl ::fidl_next::Method for Config {
992 const ORDINAL: u64 = 7676977189692319809;
993
994 type Protocol = crate::Loader;
995
996 type Request = crate::WireLoaderConfigRequest<'static>;
997
998 type Response = crate::WireLoaderConfigResponse;
999 }
1000
1001 pub struct Clone;
1002
1003 impl ::fidl_next::Method for Clone {
1004 const ORDINAL: u64 = 6333824321947847721;
1005
1006 type Protocol = crate::Loader;
1007
1008 type Request = crate::WireLoaderCloneRequest;
1009
1010 type Response = crate::WireLoaderCloneResponse;
1011 }
1012
1013 mod ___detail {
1014
1015 pub struct LoadObject<T0> {
1016 object_name: T0,
1017 }
1018
1019 impl<T0> ::fidl_next::Encodable for LoadObject<T0>
1020 where
1021 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
1022 {
1023 type Encoded = crate::WireLoaderLoadObjectRequest<'static>;
1024 }
1025
1026 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for LoadObject<T0>
1027 where
1028 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1029
1030 ___E: ::fidl_next::Encoder,
1031
1032 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
1033 {
1034 #[inline]
1035 fn encode(
1036 self,
1037 encoder: &mut ___E,
1038 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1039 ) -> Result<(), ::fidl_next::EncodeError> {
1040 ::fidl_next::munge! {
1041 let Self::Encoded {
1042 object_name,
1043
1044 } = out;
1045 }
1046
1047 ::fidl_next::Encode::encode(self.object_name, encoder, object_name)?;
1048
1049 Ok(())
1050 }
1051 }
1052
1053 pub struct Config<T0> {
1054 config: T0,
1055 }
1056
1057 impl<T0> ::fidl_next::Encodable for Config<T0>
1058 where
1059 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
1060 {
1061 type Encoded = crate::WireLoaderConfigRequest<'static>;
1062 }
1063
1064 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Config<T0>
1065 where
1066 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1067
1068 ___E: ::fidl_next::Encoder,
1069
1070 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
1071 {
1072 #[inline]
1073 fn encode(
1074 self,
1075 encoder: &mut ___E,
1076 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1077 ) -> Result<(), ::fidl_next::EncodeError> {
1078 ::fidl_next::munge! {
1079 let Self::Encoded {
1080 config,
1081
1082 } = out;
1083 }
1084
1085 ::fidl_next::Encode::encode(self.config, encoder, config)?;
1086
1087 Ok(())
1088 }
1089 }
1090
1091 pub struct Clone<T0> {
1092 loader: T0,
1093 }
1094
1095 impl<T0> ::fidl_next::Encodable for Clone<T0>
1096 where
1097 T0: ::fidl_next::Encodable<
1098 Encoded = ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::WireChannel>,
1099 >,
1100 {
1101 type Encoded = crate::WireLoaderCloneRequest;
1102 }
1103
1104 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Clone<T0>
1105 where
1106 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1107
1108 ___E: ::fidl_next::fuchsia::HandleEncoder,
1109
1110 T0: ::fidl_next::Encode<
1111 ___E,
1112 Encoded = ::fidl_next::ServerEnd<crate::Loader, ::fidl_next::fuchsia::WireChannel>,
1113 >,
1114 {
1115 #[inline]
1116 fn encode(
1117 self,
1118 encoder: &mut ___E,
1119 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1120 ) -> Result<(), ::fidl_next::EncodeError> {
1121 ::fidl_next::munge! {
1122 let Self::Encoded {
1123 loader,
1124
1125 } = out;
1126 }
1127
1128 ::fidl_next::Encode::encode(self.loader, encoder, loader)?;
1129
1130 Ok(())
1131 }
1132 }
1133
1134 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Loader
1135 where
1136 ___T: ::fidl_next::Transport,
1137 {
1138 type ClientSender = LoaderClientSender<___T>;
1139 type ServerSender = LoaderServerSender<___T>;
1140 }
1141
1142 pub struct LoaderClientSender<___T: ::fidl_next::Transport> {
1144 #[allow(dead_code)]
1145 sender: ::fidl_next::protocol::ClientSender<___T>,
1146 }
1147
1148 impl<___T> LoaderClientSender<___T>
1149 where
1150 ___T: ::fidl_next::Transport,
1151 {
1152 #[doc = " Cleanly shutdown the connection to the Loader service.\n"]
1153 pub fn done(
1154 &self,
1155 ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError> {
1156 self.sender.send_one_way(7186174313520107521, ())
1157 }
1158
1159 #[doc = " The dynamic linker sends `object_name` and gets back a VMO\n handle containing the file.\n"]
1160 pub fn load_object(
1161 &self,
1162
1163 object_name: impl ::fidl_next::Encode<
1164 <___T as ::fidl_next::Transport>::SendBuffer,
1165 Encoded = ::fidl_next::WireString<'static>,
1166 >,
1167 ) -> Result<
1168 ::fidl_next::ResponseFuture<'_, super::LoadObject, ___T>,
1169 ::fidl_next::EncodeError,
1170 >
1171 where
1172 <___T as ::fidl_next::Transport>::SendBuffer:
1173 ::fidl_next::encoder::InternalHandleEncoder,
1174
1175 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
1176 {
1177 self.load_object_with(LoadObject { object_name })
1178 }
1179
1180 #[doc = " The dynamic linker sends `object_name` and gets back a VMO\n handle containing the file.\n"]
1181 pub fn load_object_with<___R>(
1182 &self,
1183 request: ___R,
1184 ) -> Result<
1185 ::fidl_next::ResponseFuture<'_, super::LoadObject, ___T>,
1186 ::fidl_next::EncodeError,
1187 >
1188 where
1189 ___R: ::fidl_next::Encode<
1190 <___T as ::fidl_next::Transport>::SendBuffer,
1191 Encoded = crate::WireLoaderLoadObjectRequest<'static>,
1192 >,
1193 {
1194 self.sender
1195 .send_two_way(5243774714012182611, request)
1196 .map(::fidl_next::ResponseFuture::from_untyped)
1197 }
1198
1199 #[doc = " The dynamic linker sends a `config` identifying its load\n configuration. This is intended to affect how later\n `LoadObject` requests decide what particular implementation\n file to supply for a given name.\n"]
1200 pub fn config(
1201 &self,
1202
1203 config: impl ::fidl_next::Encode<
1204 <___T as ::fidl_next::Transport>::SendBuffer,
1205 Encoded = ::fidl_next::WireString<'static>,
1206 >,
1207 ) -> Result<
1208 ::fidl_next::ResponseFuture<'_, super::Config, ___T>,
1209 ::fidl_next::EncodeError,
1210 >
1211 where
1212 <___T as ::fidl_next::Transport>::SendBuffer:
1213 ::fidl_next::encoder::InternalHandleEncoder,
1214
1215 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
1216 {
1217 self.config_with(Config { config })
1218 }
1219
1220 #[doc = " The dynamic linker sends a `config` identifying its load\n configuration. This is intended to affect how later\n `LoadObject` requests decide what particular implementation\n file to supply for a given name.\n"]
1221 pub fn config_with<___R>(
1222 &self,
1223 request: ___R,
1224 ) -> Result<
1225 ::fidl_next::ResponseFuture<'_, super::Config, ___T>,
1226 ::fidl_next::EncodeError,
1227 >
1228 where
1229 ___R: ::fidl_next::Encode<
1230 <___T as ::fidl_next::Transport>::SendBuffer,
1231 Encoded = crate::WireLoaderConfigRequest<'static>,
1232 >,
1233 {
1234 self.sender
1235 .send_two_way(7676977189692319809, request)
1236 .map(::fidl_next::ResponseFuture::from_untyped)
1237 }
1238
1239 #[doc = " Obtain a new loader service connection.\n"]
1240 pub fn clone(
1241 &self,
1242
1243 loader: impl ::fidl_next::Encode<
1244 <___T as ::fidl_next::Transport>::SendBuffer,
1245 Encoded = ::fidl_next::ServerEnd<
1246 crate::Loader,
1247 ::fidl_next::fuchsia::WireChannel,
1248 >,
1249 >,
1250 ) -> Result<::fidl_next::ResponseFuture<'_, super::Clone, ___T>, ::fidl_next::EncodeError>
1251 where
1252 <___T as ::fidl_next::Transport>::SendBuffer:
1253 ::fidl_next::encoder::InternalHandleEncoder,
1254
1255 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
1256 {
1257 self.clone_with(Clone { loader })
1258 }
1259
1260 #[doc = " Obtain a new loader service connection.\n"]
1261 pub fn clone_with<___R>(
1262 &self,
1263 request: ___R,
1264 ) -> Result<::fidl_next::ResponseFuture<'_, super::Clone, ___T>, ::fidl_next::EncodeError>
1265 where
1266 ___R: ::fidl_next::Encode<
1267 <___T as ::fidl_next::Transport>::SendBuffer,
1268 Encoded = crate::WireLoaderCloneRequest,
1269 >,
1270 {
1271 self.sender
1272 .send_two_way(6333824321947847721, request)
1273 .map(::fidl_next::ResponseFuture::from_untyped)
1274 }
1275 }
1276
1277 #[repr(transparent)]
1279 pub struct LoaderServerSender<___T: ::fidl_next::Transport> {
1280 sender: ::fidl_next::protocol::ServerSender<___T>,
1281 }
1282
1283 impl<___T> LoaderServerSender<___T> where ___T: ::fidl_next::Transport {}
1284 }
1285}
1286
1287pub trait LoaderClientHandler<___T: ::fidl_next::Transport> {}
1291
1292impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Loader
1293where
1294 ___H: LoaderClientHandler<___T> + Send,
1295 ___T: ::fidl_next::Transport,
1296
1297 <loader::LoadObject as ::fidl_next::Method>::Response:
1298 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1299
1300 <loader::Config as ::fidl_next::Method>::Response:
1301 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1302
1303 <loader::Clone as ::fidl_next::Method>::Response:
1304 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1305{
1306 async fn on_event(
1307 handler: &mut ___H,
1308 sender: &::fidl_next::ClientSender<Self, ___T>,
1309 ordinal: u64,
1310 buffer: ___T::RecvBuffer,
1311 ) {
1312 match ordinal {
1313 ordinal => {
1314 sender.close();
1315 }
1316 }
1317 }
1318}
1319
1320pub trait LoaderServerHandler<___T: ::fidl_next::Transport> {
1324 #[doc = " Cleanly shutdown the connection to the Loader service.\n"]
1325 fn done(
1326 &mut self,
1327 sender: &::fidl_next::ServerSender<Loader, ___T>,
1328 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1329
1330 #[doc = " The dynamic linker sends `object_name` and gets back a VMO\n handle containing the file.\n"]
1331 fn load_object(
1332 &mut self,
1333 sender: &::fidl_next::ServerSender<Loader, ___T>,
1334
1335 request: ::fidl_next::Request<loader::LoadObject, ___T>,
1336
1337 responder: ::fidl_next::Responder<loader::LoadObject>,
1338 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1339
1340 #[doc = " The dynamic linker sends a `config` identifying its load\n configuration. This is intended to affect how later\n `LoadObject` requests decide what particular implementation\n file to supply for a given name.\n"]
1341 fn config(
1342 &mut self,
1343 sender: &::fidl_next::ServerSender<Loader, ___T>,
1344
1345 request: ::fidl_next::Request<loader::Config, ___T>,
1346
1347 responder: ::fidl_next::Responder<loader::Config>,
1348 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1349
1350 #[doc = " Obtain a new loader service connection.\n"]
1351 fn clone(
1352 &mut self,
1353 sender: &::fidl_next::ServerSender<Loader, ___T>,
1354
1355 request: ::fidl_next::Request<loader::Clone, ___T>,
1356
1357 responder: ::fidl_next::Responder<loader::Clone>,
1358 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1359}
1360
1361impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Loader
1362where
1363 ___H: LoaderServerHandler<___T> + Send,
1364 ___T: ::fidl_next::Transport,
1365
1366 <loader::LoadObject as ::fidl_next::Method>::Request:
1367 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1368
1369 <loader::Config as ::fidl_next::Method>::Request:
1370 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1371
1372 <loader::Clone as ::fidl_next::Method>::Request:
1373 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1374{
1375 async fn on_one_way(
1376 handler: &mut ___H,
1377 sender: &::fidl_next::ServerSender<Self, ___T>,
1378 ordinal: u64,
1379 buffer: ___T::RecvBuffer,
1380 ) {
1381 match ordinal {
1382 7186174313520107521 => {
1383 handler.done(sender).await;
1384 }
1385
1386 ordinal => {
1387 sender.close();
1388 }
1389 }
1390 }
1391
1392 async fn on_two_way(
1393 handler: &mut ___H,
1394 sender: &::fidl_next::ServerSender<Self, ___T>,
1395 ordinal: u64,
1396 buffer: ___T::RecvBuffer,
1397 responder: ::fidl_next::protocol::Responder,
1398 ) {
1399 match ordinal {
1400 5243774714012182611 => {
1401 let responder = ::fidl_next::Responder::from_untyped(responder);
1402
1403 match ::fidl_next::DecoderExt::decode(buffer) {
1404 Ok(decoded) => handler.load_object(sender, decoded, responder).await,
1405 Err(e) => {
1406 sender.close();
1407 }
1408 }
1409 }
1410
1411 7676977189692319809 => {
1412 let responder = ::fidl_next::Responder::from_untyped(responder);
1413
1414 match ::fidl_next::DecoderExt::decode(buffer) {
1415 Ok(decoded) => handler.config(sender, decoded, responder).await,
1416 Err(e) => {
1417 sender.close();
1418 }
1419 }
1420 }
1421
1422 6333824321947847721 => {
1423 let responder = ::fidl_next::Responder::from_untyped(responder);
1424
1425 match ::fidl_next::DecoderExt::decode(buffer) {
1426 Ok(decoded) => handler.clone(sender, decoded, responder).await,
1427 Err(e) => {
1428 sender.close();
1429 }
1430 }
1431 }
1432
1433 ordinal => {
1434 sender.close();
1435 }
1436 }
1437 }
1438}
1439
1440pub mod compat {
1442
1443 #[cfg(target_os = "fuchsia")]
1444 pub type LoaderProxy =
1447 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Loader>;
1448
1449 impl ::core::convert::From<crate::Loader> for ::fidl_fuchsia_ldsvc::LoaderMarker {
1450 #[inline]
1451 fn from(_: crate::Loader) -> Self {
1452 Self
1453 }
1454 }
1455}