fidl_next_fuchsia_hardware_sharedmemory/
fidl_next_fuchsia_hardware_sharedmemory.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
5pub mod natural {
6
7    pub use fidl_next_common_fuchsia_hardware_sharedmemory::natural::*;
8
9    #[derive(Debug, PartialEq)]
10    pub struct SharedVmoRegisterRegisterVmoRequest {
11        pub vmo_id: u32,
12
13        pub vmo: ::fidl_next_fuchsia_mem::natural::Range,
14
15        pub rights: crate::natural::SharedVmoRight,
16    }
17
18    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SharedVmoRegisterRegisterVmoRequest, ___E>
19        for SharedVmoRegisterRegisterVmoRequest
20    where
21        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
22        ___E: ::fidl_next::fuchsia::HandleEncoder,
23    {
24        #[inline]
25        fn encode(
26            self,
27            encoder_: &mut ___E,
28            out_: &mut ::core::mem::MaybeUninit<crate::wire::SharedVmoRegisterRegisterVmoRequest>,
29            _: (),
30        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
31            ::fidl_next::munge! {
32                let crate::wire::SharedVmoRegisterRegisterVmoRequest {
33                    vmo_id,
34                    vmo,
35                    rights,
36
37                } = out_;
38            }
39
40            ::fidl_next::Encode::encode(self.vmo_id, encoder_, vmo_id, ())?;
41
42            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo_id.as_mut_ptr()) };
43
44            ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
45
46            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
47
48            ::fidl_next::Encode::encode(self.rights, encoder_, rights, ())?;
49
50            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rights.as_mut_ptr()) };
51
52            Ok(())
53        }
54    }
55
56    unsafe impl<___E>
57        ::fidl_next::EncodeOption<
58            ::fidl_next::wire::Box<'static, crate::wire::SharedVmoRegisterRegisterVmoRequest>,
59            ___E,
60        > for SharedVmoRegisterRegisterVmoRequest
61    where
62        ___E: ::fidl_next::Encoder + ?Sized,
63        SharedVmoRegisterRegisterVmoRequest:
64            ::fidl_next::Encode<crate::wire::SharedVmoRegisterRegisterVmoRequest, ___E>,
65    {
66        #[inline]
67        fn encode_option(
68            this: ::core::option::Option<Self>,
69            encoder: &mut ___E,
70            out: &mut ::core::mem::MaybeUninit<
71                ::fidl_next::wire::Box<'static, crate::wire::SharedVmoRegisterRegisterVmoRequest>,
72            >,
73            _: (),
74        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
75            if let Some(inner) = this {
76                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
77                ::fidl_next::wire::Box::encode_present(out);
78            } else {
79                ::fidl_next::wire::Box::encode_absent(out);
80            }
81
82            Ok(())
83        }
84    }
85
86    impl ::fidl_next::FromWire<crate::wire::SharedVmoRegisterRegisterVmoRequest>
87        for SharedVmoRegisterRegisterVmoRequest
88    {
89        #[inline]
90        fn from_wire(wire: crate::wire::SharedVmoRegisterRegisterVmoRequest) -> Self {
91            Self {
92                vmo_id: ::fidl_next::FromWire::from_wire(wire.vmo_id),
93
94                vmo: ::fidl_next::FromWire::from_wire(wire.vmo),
95
96                rights: ::fidl_next::FromWire::from_wire(wire.rights),
97            }
98        }
99    }
100
101    #[derive(Debug, PartialEq)]
102    #[repr(C)]
103    pub struct SharedVmoRegisterUnregisterVmoResponse {
104        pub vmo: ::fidl_next::fuchsia::zx::Vmo,
105    }
106
107    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SharedVmoRegisterUnregisterVmoResponse, ___E>
108        for SharedVmoRegisterUnregisterVmoResponse
109    where
110        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
111        ___E: ::fidl_next::fuchsia::HandleEncoder,
112    {
113        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
114            Self,
115            crate::wire::SharedVmoRegisterUnregisterVmoResponse,
116        > = unsafe {
117            ::fidl_next::CopyOptimization::enable_if(
118                true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<
119                    ::fidl_next::wire::fuchsia::Vmo,
120                    ___E,
121                >>::COPY_OPTIMIZATION
122                    .is_enabled(),
123            )
124        };
125
126        #[inline]
127        fn encode(
128            self,
129            encoder_: &mut ___E,
130            out_: &mut ::core::mem::MaybeUninit<
131                crate::wire::SharedVmoRegisterUnregisterVmoResponse,
132            >,
133            _: (),
134        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
135            ::fidl_next::munge! {
136                let crate::wire::SharedVmoRegisterUnregisterVmoResponse {
137                    vmo,
138
139                } = out_;
140            }
141
142            ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
143
144            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
145
146            Ok(())
147        }
148    }
149
150    unsafe impl<___E>
151        ::fidl_next::EncodeOption<
152            ::fidl_next::wire::Box<'static, crate::wire::SharedVmoRegisterUnregisterVmoResponse>,
153            ___E,
154        > for SharedVmoRegisterUnregisterVmoResponse
155    where
156        ___E: ::fidl_next::Encoder + ?Sized,
157        SharedVmoRegisterUnregisterVmoResponse:
158            ::fidl_next::Encode<crate::wire::SharedVmoRegisterUnregisterVmoResponse, ___E>,
159    {
160        #[inline]
161        fn encode_option(
162            this: ::core::option::Option<Self>,
163            encoder: &mut ___E,
164            out: &mut ::core::mem::MaybeUninit<
165                ::fidl_next::wire::Box<
166                    'static,
167                    crate::wire::SharedVmoRegisterUnregisterVmoResponse,
168                >,
169            >,
170            _: (),
171        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
172            if let Some(inner) = this {
173                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
174                ::fidl_next::wire::Box::encode_present(out);
175            } else {
176                ::fidl_next::wire::Box::encode_absent(out);
177            }
178
179            Ok(())
180        }
181    }
182
183    impl ::fidl_next::FromWire<crate::wire::SharedVmoRegisterUnregisterVmoResponse>
184        for SharedVmoRegisterUnregisterVmoResponse
185    {
186        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
187            crate::wire::SharedVmoRegisterUnregisterVmoResponse,
188            Self,
189        > = unsafe {
190            ::fidl_next::CopyOptimization::enable_if(
191                true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
192                    ::fidl_next::wire::fuchsia::Vmo,
193                >>::COPY_OPTIMIZATION
194                    .is_enabled(),
195            )
196        };
197
198        #[inline]
199        fn from_wire(wire: crate::wire::SharedVmoRegisterUnregisterVmoResponse) -> Self {
200            Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
201        }
202    }
203}
204
205pub mod wire {
206
207    pub use fidl_next_common_fuchsia_hardware_sharedmemory::wire::*;
208
209    /// The wire type corresponding to [`SharedVmoRegisterRegisterVmoRequest`].
210    #[derive(Debug)]
211    #[repr(C)]
212    pub struct SharedVmoRegisterRegisterVmoRequest {
213        pub vmo_id: ::fidl_next::wire::Uint32,
214
215        pub vmo: ::fidl_next_fuchsia_mem::wire::Range,
216
217        pub rights: crate::wire::SharedVmoRight,
218    }
219
220    static_assertions::const_assert_eq!(
221        std::mem::size_of::<SharedVmoRegisterRegisterVmoRequest>(),
222        40
223    );
224    static_assertions::const_assert_eq!(
225        std::mem::align_of::<SharedVmoRegisterRegisterVmoRequest>(),
226        8
227    );
228
229    static_assertions::const_assert_eq!(
230        std::mem::offset_of!(SharedVmoRegisterRegisterVmoRequest, vmo_id),
231        0
232    );
233
234    static_assertions::const_assert_eq!(
235        std::mem::offset_of!(SharedVmoRegisterRegisterVmoRequest, vmo),
236        8
237    );
238
239    static_assertions::const_assert_eq!(
240        std::mem::offset_of!(SharedVmoRegisterRegisterVmoRequest, rights),
241        32
242    );
243
244    impl ::fidl_next::Constrained for SharedVmoRegisterRegisterVmoRequest {
245        type Constraint = ();
246
247        fn validate(
248            _: ::fidl_next::Slot<'_, Self>,
249            _: Self::Constraint,
250        ) -> Result<(), ::fidl_next::ValidationError> {
251            Ok(())
252        }
253    }
254
255    unsafe impl ::fidl_next::Wire for SharedVmoRegisterRegisterVmoRequest {
256        type Narrowed<'de> = SharedVmoRegisterRegisterVmoRequest;
257
258        #[inline]
259        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
260            ::fidl_next::munge! {
261                let Self {
262                    vmo_id,
263                    vmo,
264                    rights,
265
266                } = &mut *out_;
267            }
268
269            ::fidl_next::Wire::zero_padding(vmo_id);
270
271            ::fidl_next::Wire::zero_padding(vmo);
272
273            ::fidl_next::Wire::zero_padding(rights);
274
275            unsafe {
276                out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
277            }
278
279            unsafe {
280                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
281            }
282        }
283    }
284
285    unsafe impl<___D> ::fidl_next::Decode<___D> for SharedVmoRegisterRegisterVmoRequest
286    where
287        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
288        ___D: ::fidl_next::fuchsia::HandleDecoder,
289    {
290        fn decode(
291            slot_: ::fidl_next::Slot<'_, Self>,
292            decoder_: &mut ___D,
293            _: (),
294        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
295            if slot_.as_bytes()[36..40] != [0u8; 4] {
296                return Err(::fidl_next::DecodeError::InvalidPadding);
297            }
298
299            if slot_.as_bytes()[4..8] != [0u8; 4] {
300                return Err(::fidl_next::DecodeError::InvalidPadding);
301            }
302
303            ::fidl_next::munge! {
304                let Self {
305                    mut vmo_id,
306                    mut vmo,
307                    mut rights,
308
309                } = slot_;
310            }
311
312            let _field = vmo_id.as_mut();
313
314            ::fidl_next::Decode::decode(vmo_id.as_mut(), decoder_, ())?;
315
316            let _field = vmo.as_mut();
317
318            ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
319
320            let _field = rights.as_mut();
321
322            ::fidl_next::Decode::decode(rights.as_mut(), decoder_, ())?;
323
324            Ok(())
325        }
326    }
327
328    impl ::fidl_next::IntoNatural for SharedVmoRegisterRegisterVmoRequest {
329        type Natural = crate::natural::SharedVmoRegisterRegisterVmoRequest;
330    }
331
332    /// The wire type corresponding to [`SharedVmoRegisterUnregisterVmoResponse`].
333    #[derive(Debug)]
334    #[repr(C)]
335    pub struct SharedVmoRegisterUnregisterVmoResponse {
336        pub vmo: ::fidl_next::wire::fuchsia::Vmo,
337    }
338
339    static_assertions::const_assert_eq!(
340        std::mem::size_of::<SharedVmoRegisterUnregisterVmoResponse>(),
341        4
342    );
343    static_assertions::const_assert_eq!(
344        std::mem::align_of::<SharedVmoRegisterUnregisterVmoResponse>(),
345        4
346    );
347
348    static_assertions::const_assert_eq!(
349        std::mem::offset_of!(SharedVmoRegisterUnregisterVmoResponse, vmo),
350        0
351    );
352
353    impl ::fidl_next::Constrained for SharedVmoRegisterUnregisterVmoResponse {
354        type Constraint = ();
355
356        fn validate(
357            _: ::fidl_next::Slot<'_, Self>,
358            _: Self::Constraint,
359        ) -> Result<(), ::fidl_next::ValidationError> {
360            Ok(())
361        }
362    }
363
364    unsafe impl ::fidl_next::Wire for SharedVmoRegisterUnregisterVmoResponse {
365        type Narrowed<'de> = SharedVmoRegisterUnregisterVmoResponse;
366
367        #[inline]
368        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
369            ::fidl_next::munge! {
370                let Self {
371                    vmo,
372
373                } = &mut *out_;
374            }
375
376            ::fidl_next::Wire::zero_padding(vmo);
377        }
378    }
379
380    unsafe impl<___D> ::fidl_next::Decode<___D> for SharedVmoRegisterUnregisterVmoResponse
381    where
382        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
383        ___D: ::fidl_next::fuchsia::HandleDecoder,
384    {
385        fn decode(
386            slot_: ::fidl_next::Slot<'_, Self>,
387            decoder_: &mut ___D,
388            _: (),
389        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
390            ::fidl_next::munge! {
391                let Self {
392                    mut vmo,
393
394                } = slot_;
395            }
396
397            let _field = vmo.as_mut();
398
399            ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
400
401            Ok(())
402        }
403    }
404
405    impl ::fidl_next::IntoNatural for SharedVmoRegisterUnregisterVmoResponse {
406        type Natural = crate::natural::SharedVmoRegisterUnregisterVmoResponse;
407    }
408}
409
410pub mod wire_optional {
411
412    pub use fidl_next_common_fuchsia_hardware_sharedmemory::wire_optional::*;
413}
414
415pub mod generic {
416
417    pub use fidl_next_common_fuchsia_hardware_sharedmemory::generic::*;
418
419    /// The generic type corresponding to [`SharedVmoRegisterRegisterVmoRequest`].
420    pub struct SharedVmoRegisterRegisterVmoRequest<T0, T1, T2> {
421        pub vmo_id: T0,
422
423        pub vmo: T1,
424
425        pub rights: T2,
426    }
427
428    unsafe impl<___E, T0, T1, T2>
429        ::fidl_next::Encode<crate::wire::SharedVmoRegisterRegisterVmoRequest, ___E>
430        for SharedVmoRegisterRegisterVmoRequest<T0, T1, T2>
431    where
432        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
433        ___E: ::fidl_next::fuchsia::HandleEncoder,
434        T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
435        T1: ::fidl_next::Encode<::fidl_next_fuchsia_mem::wire::Range, ___E>,
436        T2: ::fidl_next::Encode<crate::wire::SharedVmoRight, ___E>,
437    {
438        #[inline]
439        fn encode(
440            self,
441            encoder_: &mut ___E,
442            out_: &mut ::core::mem::MaybeUninit<crate::wire::SharedVmoRegisterRegisterVmoRequest>,
443            _: (),
444        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
445            ::fidl_next::munge! {
446                let crate::wire::SharedVmoRegisterRegisterVmoRequest {
447                    vmo_id,
448                    vmo,
449                    rights,
450
451                } = out_;
452            }
453
454            ::fidl_next::Encode::encode(self.vmo_id, encoder_, vmo_id, ())?;
455
456            ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
457
458            ::fidl_next::Encode::encode(self.rights, encoder_, rights, ())?;
459
460            Ok(())
461        }
462    }
463
464    unsafe impl<'a, ___E, T0, T1, T2>
465        ::fidl_next::Encode<crate::wire::SharedVmoRegisterRegisterVmoRequest, ___E>
466        for &'a SharedVmoRegisterRegisterVmoRequest<T0, T1, T2>
467    where
468        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
469        ___E: ::fidl_next::fuchsia::HandleEncoder,
470        &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
471        &'a T1: ::fidl_next::Encode<::fidl_next_fuchsia_mem::wire::Range, ___E>,
472        &'a T2: ::fidl_next::Encode<crate::wire::SharedVmoRight, ___E>,
473    {
474        #[inline]
475        fn encode(
476            self,
477            encoder_: &mut ___E,
478            out_: &mut ::core::mem::MaybeUninit<crate::wire::SharedVmoRegisterRegisterVmoRequest>,
479            _: (),
480        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
481            ::fidl_next::munge! {
482                let crate::wire::SharedVmoRegisterRegisterVmoRequest {
483                    vmo_id,
484                    vmo,
485                    rights,
486
487                } = out_;
488            }
489
490            ::fidl_next::Encode::encode(&self.vmo_id, encoder_, vmo_id, ())?;
491
492            ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
493
494            ::fidl_next::Encode::encode(&self.rights, encoder_, rights, ())?;
495
496            Ok(())
497        }
498    }
499
500    /// The generic type corresponding to [`SharedVmoRegisterUnregisterVmoResponse`].
501    pub struct SharedVmoRegisterUnregisterVmoResponse<T0> {
502        pub vmo: T0,
503    }
504
505    unsafe impl<___E, T0>
506        ::fidl_next::Encode<crate::wire::SharedVmoRegisterUnregisterVmoResponse, ___E>
507        for SharedVmoRegisterUnregisterVmoResponse<T0>
508    where
509        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
510        ___E: ::fidl_next::fuchsia::HandleEncoder,
511        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
512    {
513        #[inline]
514        fn encode(
515            self,
516            encoder_: &mut ___E,
517            out_: &mut ::core::mem::MaybeUninit<
518                crate::wire::SharedVmoRegisterUnregisterVmoResponse,
519            >,
520            _: (),
521        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
522            ::fidl_next::munge! {
523                let crate::wire::SharedVmoRegisterUnregisterVmoResponse {
524                    vmo,
525
526                } = out_;
527            }
528
529            ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
530
531            Ok(())
532        }
533    }
534
535    unsafe impl<'a, ___E, T0>
536        ::fidl_next::Encode<crate::wire::SharedVmoRegisterUnregisterVmoResponse, ___E>
537        for &'a SharedVmoRegisterUnregisterVmoResponse<T0>
538    where
539        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
540        ___E: ::fidl_next::fuchsia::HandleEncoder,
541        &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
542    {
543        #[inline]
544        fn encode(
545            self,
546            encoder_: &mut ___E,
547            out_: &mut ::core::mem::MaybeUninit<
548                crate::wire::SharedVmoRegisterUnregisterVmoResponse,
549            >,
550            _: (),
551        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
552            ::fidl_next::munge! {
553                let crate::wire::SharedVmoRegisterUnregisterVmoResponse {
554                    vmo,
555
556                } = out_;
557            }
558
559            ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
560
561            Ok(())
562        }
563    }
564}
565
566pub use self::natural::*;
567
568/// The type corresponding to the SharedVmoRegister protocol.
569#[doc = " This is a generic protocol for sharing VMOs that drivers may compose.\n"]
570#[derive(PartialEq, Debug)]
571pub struct SharedVmoRegister;
572
573#[cfg(target_os = "fuchsia")]
574impl ::fidl_next::HasTransport for SharedVmoRegister {
575    type Transport = ::fidl_next::fuchsia::zx::Channel;
576}
577
578pub mod shared_vmo_register {
579    pub mod prelude {
580        pub use crate::{
581            SharedVmoRegister, SharedVmoRegisterClientHandler, SharedVmoRegisterLocalClientHandler,
582            SharedVmoRegisterLocalServerHandler, SharedVmoRegisterServerHandler,
583            shared_vmo_register,
584        };
585
586        pub use crate::natural::SharedVmoRegisterRegisterVmoRequest;
587
588        pub use crate::natural::SharedVmoRegisterUnregisterVmoRequest;
589
590        pub use crate::natural::SharedVmoRegisterRegisterVmoResponse;
591
592        pub use crate::natural::SharedVmoRegisterUnregisterVmoResponse;
593    }
594
595    pub struct RegisterVmo;
596
597    impl ::fidl_next::Method for RegisterVmo {
598        const ORDINAL: u64 = 3593681058348550677;
599        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
600            ::fidl_next::protocol::Flexibility::Strict;
601
602        type Protocol = crate::SharedVmoRegister;
603
604        type Request = crate::wire::SharedVmoRegisterRegisterVmoRequest;
605    }
606
607    impl ::fidl_next::TwoWayMethod for RegisterVmo {
608        type Response = ::fidl_next::wire::Result<
609            'static,
610            crate::wire::SharedVmoRegisterRegisterVmoResponse,
611            ::fidl_next::wire::fuchsia::Status,
612        >;
613    }
614
615    impl<___R> ::fidl_next::Respond<___R> for RegisterVmo {
616        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
617
618        fn respond(response: ___R) -> Self::Output {
619            ::core::result::Result::Ok(response)
620        }
621    }
622
623    impl<___R> ::fidl_next::RespondErr<___R> for RegisterVmo {
624        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
625
626        fn respond_err(response: ___R) -> Self::Output {
627            ::core::result::Result::Err(response)
628        }
629    }
630
631    pub struct UnregisterVmo;
632
633    impl ::fidl_next::Method for UnregisterVmo {
634        const ORDINAL: u64 = 1266894365566071049;
635        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
636            ::fidl_next::protocol::Flexibility::Strict;
637
638        type Protocol = crate::SharedVmoRegister;
639
640        type Request = crate::wire::SharedVmoRegisterUnregisterVmoRequest;
641    }
642
643    impl ::fidl_next::TwoWayMethod for UnregisterVmo {
644        type Response = ::fidl_next::wire::Result<
645            'static,
646            crate::wire::SharedVmoRegisterUnregisterVmoResponse,
647            ::fidl_next::wire::fuchsia::Status,
648        >;
649    }
650
651    impl<___R> ::fidl_next::Respond<___R> for UnregisterVmo {
652        type Output = ::core::result::Result<
653            crate::generic::SharedVmoRegisterUnregisterVmoResponse<___R>,
654            ::fidl_next::never::Never,
655        >;
656
657        fn respond(response: ___R) -> Self::Output {
658            ::core::result::Result::Ok(crate::generic::SharedVmoRegisterUnregisterVmoResponse {
659                vmo: response,
660            })
661        }
662    }
663
664    impl<___R> ::fidl_next::RespondErr<___R> for UnregisterVmo {
665        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
666
667        fn respond_err(response: ___R) -> Self::Output {
668            ::core::result::Result::Err(response)
669        }
670    }
671
672    mod ___detail {
673        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SharedVmoRegister
674        where
675            ___T: ::fidl_next::Transport,
676        {
677            type Client = SharedVmoRegisterClient<___T>;
678            type Server = SharedVmoRegisterServer<___T>;
679        }
680
681        /// The client for the `SharedVmoRegister` protocol.
682        #[repr(transparent)]
683        pub struct SharedVmoRegisterClient<___T: ::fidl_next::Transport> {
684            #[allow(dead_code)]
685            client: ::fidl_next::protocol::Client<___T>,
686        }
687
688        impl<___T> SharedVmoRegisterClient<___T>
689        where
690            ___T: ::fidl_next::Transport,
691        {
692            #[doc = " Registers a VMO and transfers ownership to the driver.\n vmo_id: The ID chosen by the client that will be used in operations on this VMO.\n vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to\n the offset and size specified here.\n rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers\n should assume that the driver will map and/or pin the VMO using these rights.\n"]
693            pub fn register_vmo(
694                &self,
695
696                vmo_id: impl ::fidl_next::Encode<
697                    ::fidl_next::wire::Uint32,
698                    <___T as ::fidl_next::Transport>::SendBuffer,
699                >,
700
701                vmo: impl ::fidl_next::Encode<
702                    ::fidl_next_fuchsia_mem::wire::Range,
703                    <___T as ::fidl_next::Transport>::SendBuffer,
704                >,
705
706                rights: impl ::fidl_next::Encode<
707                    crate::wire::SharedVmoRight,
708                    <___T as ::fidl_next::Transport>::SendBuffer,
709                >,
710            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
711            where
712                <___T as ::fidl_next::Transport>::SendBuffer:
713                    ::fidl_next::encoder::InternalHandleEncoder,
714                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
715            {
716                self.register_vmo_with(crate::generic::SharedVmoRegisterRegisterVmoRequest {
717                    vmo_id,
718
719                    vmo,
720
721                    rights,
722                })
723            }
724
725            #[doc = " Registers a VMO and transfers ownership to the driver.\n vmo_id: The ID chosen by the client that will be used in operations on this VMO.\n vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to\n the offset and size specified here.\n rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers\n should assume that the driver will map and/or pin the VMO using these rights.\n"]
726            pub fn register_vmo_with<___R>(
727                &self,
728                request: ___R,
729            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
730            where
731                ___R: ::fidl_next::Encode<
732                        crate::wire::SharedVmoRegisterRegisterVmoRequest,
733                        <___T as ::fidl_next::Transport>::SendBuffer,
734                    >,
735            {
736                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
737                    3593681058348550677,
738                    <super::RegisterVmo as ::fidl_next::Method>::FLEXIBILITY,
739                    request,
740                ))
741            }
742
743            #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
744            pub fn unregister_vmo(
745                &self,
746
747                vmo_id: impl ::fidl_next::Encode<
748                    ::fidl_next::wire::Uint32,
749                    <___T as ::fidl_next::Transport>::SendBuffer,
750                >,
751            ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
752            where
753                <___T as ::fidl_next::Transport>::SendBuffer:
754                    ::fidl_next::encoder::InternalHandleEncoder,
755            {
756                self.unregister_vmo_with(crate::generic::SharedVmoRegisterUnregisterVmoRequest {
757                    vmo_id,
758                })
759            }
760
761            #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
762            pub fn unregister_vmo_with<___R>(
763                &self,
764                request: ___R,
765            ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
766            where
767                ___R: ::fidl_next::Encode<
768                        crate::wire::SharedVmoRegisterUnregisterVmoRequest,
769                        <___T as ::fidl_next::Transport>::SendBuffer,
770                    >,
771            {
772                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
773                    1266894365566071049,
774                    <super::UnregisterVmo as ::fidl_next::Method>::FLEXIBILITY,
775                    request,
776                ))
777            }
778        }
779
780        /// The server for the `SharedVmoRegister` protocol.
781        #[repr(transparent)]
782        pub struct SharedVmoRegisterServer<___T: ::fidl_next::Transport> {
783            server: ::fidl_next::protocol::Server<___T>,
784        }
785
786        impl<___T> SharedVmoRegisterServer<___T> where ___T: ::fidl_next::Transport {}
787    }
788}
789
790#[diagnostic::on_unimplemented(
791    note = "If {Self} implements the non-local SharedVmoRegisterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
792)]
793
794/// A client handler for the SharedVmoRegister protocol.
795///
796/// See [`SharedVmoRegister`] for more details.
797pub trait SharedVmoRegisterLocalClientHandler<
798    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
799    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
800>
801{
802}
803
804impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for SharedVmoRegister
805where
806    ___H: SharedVmoRegisterLocalClientHandler<___T>,
807    ___T: ::fidl_next::Transport,
808{
809    async fn on_event(
810        handler: &mut ___H,
811        mut message: ::fidl_next::Message<___T>,
812    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
813        match *message.header().ordinal {
814            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
815        }
816    }
817}
818
819#[diagnostic::on_unimplemented(
820    note = "If {Self} implements the non-local SharedVmoRegisterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
821)]
822
823/// A server handler for the SharedVmoRegister protocol.
824///
825/// See [`SharedVmoRegister`] for more details.
826pub trait SharedVmoRegisterLocalServerHandler<
827    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
828    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
829>
830{
831    #[doc = " Registers a VMO and transfers ownership to the driver.\n vmo_id: The ID chosen by the client that will be used in operations on this VMO.\n vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to\n the offset and size specified here.\n rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers\n should assume that the driver will map and/or pin the VMO using these rights.\n"]
832    fn register_vmo(
833        &mut self,
834
835        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
836
837        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
838    ) -> impl ::core::future::Future<Output = ()>;
839
840    #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
841    fn unregister_vmo(
842        &mut self,
843
844        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
845
846        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
847    ) -> impl ::core::future::Future<Output = ()>;
848}
849
850impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for SharedVmoRegister
851where
852    ___H: SharedVmoRegisterLocalServerHandler<___T>,
853    ___T: ::fidl_next::Transport,
854    for<'de> crate::wire::SharedVmoRegisterRegisterVmoRequest: ::fidl_next::Decode<
855            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
856            Constraint = (),
857        >,
858    for<'de> crate::wire::SharedVmoRegisterUnregisterVmoRequest: ::fidl_next::Decode<
859            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
860            Constraint = (),
861        >,
862{
863    async fn on_one_way(
864        handler: &mut ___H,
865        mut message: ::fidl_next::Message<___T>,
866    ) -> ::core::result::Result<
867        (),
868        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
869    > {
870        match *message.header().ordinal {
871            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
872        }
873    }
874
875    async fn on_two_way(
876        handler: &mut ___H,
877        mut message: ::fidl_next::Message<___T>,
878        responder: ::fidl_next::protocol::Responder<___T>,
879    ) -> ::core::result::Result<
880        (),
881        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
882    > {
883        match *message.header().ordinal {
884            3593681058348550677 => {
885                let responder = ::fidl_next::Responder::from_untyped(responder);
886
887                match ::fidl_next::AsDecoderExt::into_decoded(message) {
888                    Ok(decoded) => {
889                        handler
890                            .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
891                            .await;
892                        Ok(())
893                    }
894                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
895                        ordinal: 3593681058348550677,
896                        error,
897                    }),
898                }
899            }
900
901            1266894365566071049 => {
902                let responder = ::fidl_next::Responder::from_untyped(responder);
903
904                match ::fidl_next::AsDecoderExt::into_decoded(message) {
905                    Ok(decoded) => {
906                        handler
907                            .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
908                            .await;
909                        Ok(())
910                    }
911                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
912                        ordinal: 1266894365566071049,
913                        error,
914                    }),
915                }
916            }
917
918            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
919        }
920    }
921}
922
923/// A client handler for the SharedVmoRegister protocol.
924///
925/// See [`SharedVmoRegister`] for more details.
926pub trait SharedVmoRegisterClientHandler<
927    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
928    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
929>
930{
931}
932
933impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for SharedVmoRegister
934where
935    ___H: SharedVmoRegisterClientHandler<___T> + ::core::marker::Send,
936    ___T: ::fidl_next::Transport,
937{
938    async fn on_event(
939        handler: &mut ___H,
940        mut message: ::fidl_next::Message<___T>,
941    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
942        match *message.header().ordinal {
943            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
944        }
945    }
946}
947
948/// A server handler for the SharedVmoRegister protocol.
949///
950/// See [`SharedVmoRegister`] for more details.
951pub trait SharedVmoRegisterServerHandler<
952    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
953    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
954>
955{
956    #[doc = " Registers a VMO and transfers ownership to the driver.\n vmo_id: The ID chosen by the client that will be used in operations on this VMO.\n vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to\n the offset and size specified here.\n rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers\n should assume that the driver will map and/or pin the VMO using these rights.\n"]
957    fn register_vmo(
958        &mut self,
959
960        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
961
962        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
963    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
964
965    #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
966    fn unregister_vmo(
967        &mut self,
968
969        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
970
971        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
972    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
973}
974
975impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for SharedVmoRegister
976where
977    ___H: SharedVmoRegisterServerHandler<___T> + ::core::marker::Send,
978    ___T: ::fidl_next::Transport,
979    for<'de> crate::wire::SharedVmoRegisterRegisterVmoRequest: ::fidl_next::Decode<
980            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
981            Constraint = (),
982        >,
983    for<'de> crate::wire::SharedVmoRegisterUnregisterVmoRequest: ::fidl_next::Decode<
984            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
985            Constraint = (),
986        >,
987{
988    async fn on_one_way(
989        handler: &mut ___H,
990        mut message: ::fidl_next::Message<___T>,
991    ) -> ::core::result::Result<
992        (),
993        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
994    > {
995        match *message.header().ordinal {
996            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
997        }
998    }
999
1000    async fn on_two_way(
1001        handler: &mut ___H,
1002        mut message: ::fidl_next::Message<___T>,
1003        responder: ::fidl_next::protocol::Responder<___T>,
1004    ) -> ::core::result::Result<
1005        (),
1006        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1007    > {
1008        match *message.header().ordinal {
1009            3593681058348550677 => {
1010                let responder = ::fidl_next::Responder::from_untyped(responder);
1011
1012                match ::fidl_next::AsDecoderExt::into_decoded(message) {
1013                    Ok(decoded) => {
1014                        handler
1015                            .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
1016                            .await;
1017                        Ok(())
1018                    }
1019                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1020                        ordinal: 3593681058348550677,
1021                        error,
1022                    }),
1023                }
1024            }
1025
1026            1266894365566071049 => {
1027                let responder = ::fidl_next::Responder::from_untyped(responder);
1028
1029                match ::fidl_next::AsDecoderExt::into_decoded(message) {
1030                    Ok(decoded) => {
1031                        handler
1032                            .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
1033                            .await;
1034                        Ok(())
1035                    }
1036                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1037                        ordinal: 1266894365566071049,
1038                        error,
1039                    }),
1040                }
1041            }
1042
1043            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
1044        }
1045    }
1046}
1047
1048impl<___T> SharedVmoRegisterClientHandler<___T> for ::fidl_next::IgnoreEvents where
1049    ___T: ::fidl_next::Transport
1050{
1051}
1052
1053impl<___H, ___T> SharedVmoRegisterLocalClientHandler<___T> for ::fidl_next::Local<___H>
1054where
1055    ___H: SharedVmoRegisterClientHandler<___T>,
1056    ___T: ::fidl_next::Transport,
1057{
1058}
1059
1060impl<___H, ___T> SharedVmoRegisterLocalServerHandler<___T> for ::fidl_next::Local<___H>
1061where
1062    ___H: SharedVmoRegisterServerHandler<___T>,
1063    ___T: ::fidl_next::Transport,
1064{
1065    async fn register_vmo(
1066        &mut self,
1067
1068        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
1069
1070        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
1071    ) {
1072        ___H::register_vmo(&mut self.0, request, responder).await
1073    }
1074
1075    async fn unregister_vmo(
1076        &mut self,
1077
1078        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
1079
1080        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
1081    ) {
1082        ___H::unregister_vmo(&mut self.0, request, responder).await
1083    }
1084}
1085
1086pub use fidl_next_common_fuchsia_hardware_sharedmemory::*;
fidl_next_fuchsia_hardware_sharedmemory/fidl_next_fuchsia_hardware_sharedmemory.rs

fidl_next_fuchsia_hardware_sharedmemory/
fidl_next_fuchsia_hardware_sharedmemory.rs
