fidl_next_fuchsia_ldsvc/
fidl_next_fuchsia_ldsvc.rs

1// DO NOT EDIT: This file is machine-generated by fidlgen
2#![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/// The wire type corresponding to [`LoaderLoadObjectRequest`].
127#[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/// The wire type corresponding to [`LoaderLoadObjectResponse`].
276#[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/// The wire type corresponding to [`LoaderConfigRequest`].
439#[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/// The wire type corresponding to [`LoaderConfigResponse`].
616#[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/// The wire type corresponding to [`LoaderCloneRequest`].
741#[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/// The wire type corresponding to [`LoaderCloneResponse`].
909#[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/// The type corresponding to the Loader protocol.
944#[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        /// The client sender for the `Loader` protocol.
1143        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        /// The server sender for the `Loader` protocol.
1278        #[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
1287/// A client handler for the Loader protocol.
1288///
1289/// See [`Loader`] for more details.
1290pub 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
1320/// A server handler for the Loader protocol.
1321///
1322/// See [`Loader`] for more details.
1323pub 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
1440/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
1441pub mod compat {
1442
1443    #[cfg(target_os = "fuchsia")]
1444    /// An alias for a client sender over `zx::Channel` for the `Loader`
1445    /// protocol.
1446    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}