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    /// The generic type corresponding to [`SharedVmoRegisterUnregisterVmoResponse`].
465    pub struct SharedVmoRegisterUnregisterVmoResponse<T0> {
466        pub vmo: T0,
467    }
468
469    unsafe impl<___E, T0>
470        ::fidl_next::Encode<crate::wire::SharedVmoRegisterUnregisterVmoResponse, ___E>
471        for SharedVmoRegisterUnregisterVmoResponse<T0>
472    where
473        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
474        ___E: ::fidl_next::fuchsia::HandleEncoder,
475        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
476    {
477        #[inline]
478        fn encode(
479            self,
480            encoder_: &mut ___E,
481            out_: &mut ::core::mem::MaybeUninit<
482                crate::wire::SharedVmoRegisterUnregisterVmoResponse,
483            >,
484            _: (),
485        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
486            ::fidl_next::munge! {
487                let crate::wire::SharedVmoRegisterUnregisterVmoResponse {
488                    vmo,
489
490                } = out_;
491            }
492
493            ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
494
495            Ok(())
496        }
497    }
498}
499
500pub use self::natural::*;
501
502/// The type corresponding to the SharedVmoRegister protocol.
503#[doc = " This is a generic protocol for sharing VMOs that drivers may compose.\n"]
504#[derive(PartialEq, Debug)]
505pub struct SharedVmoRegister;
506
507#[cfg(target_os = "fuchsia")]
508impl ::fidl_next::HasTransport for SharedVmoRegister {
509    type Transport = ::fidl_next::fuchsia::zx::Channel;
510}
511
512pub mod shared_vmo_register {
513    pub mod prelude {
514        pub use crate::{
515            SharedVmoRegister, SharedVmoRegisterClientHandler, SharedVmoRegisterLocalClientHandler,
516            SharedVmoRegisterLocalServerHandler, SharedVmoRegisterServerHandler,
517            shared_vmo_register,
518        };
519
520        pub use crate::natural::SharedVmoRegisterRegisterVmoRequest;
521
522        pub use crate::natural::SharedVmoRegisterUnregisterVmoRequest;
523
524        pub use crate::natural::SharedVmoRegisterRegisterVmoResponse;
525
526        pub use crate::natural::SharedVmoRegisterUnregisterVmoResponse;
527    }
528
529    pub struct RegisterVmo;
530
531    impl ::fidl_next::Method for RegisterVmo {
532        const ORDINAL: u64 = 3593681058348550677;
533        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
534            ::fidl_next::protocol::Flexibility::Strict;
535
536        type Protocol = crate::SharedVmoRegister;
537
538        type Request = crate::wire::SharedVmoRegisterRegisterVmoRequest;
539    }
540
541    impl ::fidl_next::TwoWayMethod for RegisterVmo {
542        type Response = ::fidl_next::wire::Result<
543            'static,
544            crate::wire::SharedVmoRegisterRegisterVmoResponse,
545            ::fidl_next::wire::fuchsia::Status,
546        >;
547    }
548
549    impl<___R> ::fidl_next::Respond<___R> for RegisterVmo {
550        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
551
552        fn respond(response: ___R) -> Self::Output {
553            ::core::result::Result::Ok(response)
554        }
555    }
556
557    impl<___R> ::fidl_next::RespondErr<___R> for RegisterVmo {
558        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
559
560        fn respond_err(response: ___R) -> Self::Output {
561            ::core::result::Result::Err(response)
562        }
563    }
564
565    pub struct UnregisterVmo;
566
567    impl ::fidl_next::Method for UnregisterVmo {
568        const ORDINAL: u64 = 1266894365566071049;
569        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
570            ::fidl_next::protocol::Flexibility::Strict;
571
572        type Protocol = crate::SharedVmoRegister;
573
574        type Request = crate::wire::SharedVmoRegisterUnregisterVmoRequest;
575    }
576
577    impl ::fidl_next::TwoWayMethod for UnregisterVmo {
578        type Response = ::fidl_next::wire::Result<
579            'static,
580            crate::wire::SharedVmoRegisterUnregisterVmoResponse,
581            ::fidl_next::wire::fuchsia::Status,
582        >;
583    }
584
585    impl<___R> ::fidl_next::Respond<___R> for UnregisterVmo {
586        type Output = ::core::result::Result<
587            crate::generic::SharedVmoRegisterUnregisterVmoResponse<___R>,
588            ::fidl_next::never::Never,
589        >;
590
591        fn respond(response: ___R) -> Self::Output {
592            ::core::result::Result::Ok(crate::generic::SharedVmoRegisterUnregisterVmoResponse {
593                vmo: response,
594            })
595        }
596    }
597
598    impl<___R> ::fidl_next::RespondErr<___R> for UnregisterVmo {
599        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
600
601        fn respond_err(response: ___R) -> Self::Output {
602            ::core::result::Result::Err(response)
603        }
604    }
605
606    mod ___detail {
607        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SharedVmoRegister
608        where
609            ___T: ::fidl_next::Transport,
610        {
611            type Client = SharedVmoRegisterClient<___T>;
612            type Server = SharedVmoRegisterServer<___T>;
613        }
614
615        /// The client for the `SharedVmoRegister` protocol.
616        #[repr(transparent)]
617        pub struct SharedVmoRegisterClient<___T: ::fidl_next::Transport> {
618            #[allow(dead_code)]
619            client: ::fidl_next::protocol::Client<___T>,
620        }
621
622        impl<___T> SharedVmoRegisterClient<___T>
623        where
624            ___T: ::fidl_next::Transport,
625        {
626            #[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"]
627            pub fn register_vmo(
628                &self,
629
630                vmo_id: impl ::fidl_next::Encode<
631                    ::fidl_next::wire::Uint32,
632                    <___T as ::fidl_next::Transport>::SendBuffer,
633                >,
634
635                vmo: impl ::fidl_next::Encode<
636                    ::fidl_next_fuchsia_mem::wire::Range,
637                    <___T as ::fidl_next::Transport>::SendBuffer,
638                >,
639
640                rights: impl ::fidl_next::Encode<
641                    crate::wire::SharedVmoRight,
642                    <___T as ::fidl_next::Transport>::SendBuffer,
643                >,
644            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
645            where
646                <___T as ::fidl_next::Transport>::SendBuffer:
647                    ::fidl_next::encoder::InternalHandleEncoder,
648                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
649            {
650                self.register_vmo_with(crate::generic::SharedVmoRegisterRegisterVmoRequest {
651                    vmo_id,
652
653                    vmo,
654
655                    rights,
656                })
657            }
658
659            #[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"]
660            pub fn register_vmo_with<___R>(
661                &self,
662                request: ___R,
663            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterVmo, ___T>
664            where
665                ___R: ::fidl_next::Encode<
666                        crate::wire::SharedVmoRegisterRegisterVmoRequest,
667                        <___T as ::fidl_next::Transport>::SendBuffer,
668                    >,
669            {
670                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
671                    3593681058348550677,
672                    <super::RegisterVmo as ::fidl_next::Method>::FLEXIBILITY,
673                    request,
674                ))
675            }
676
677            #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
678            pub fn unregister_vmo(
679                &self,
680
681                vmo_id: impl ::fidl_next::Encode<
682                    ::fidl_next::wire::Uint32,
683                    <___T as ::fidl_next::Transport>::SendBuffer,
684                >,
685            ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
686            where
687                <___T as ::fidl_next::Transport>::SendBuffer:
688                    ::fidl_next::encoder::InternalHandleEncoder,
689            {
690                self.unregister_vmo_with(crate::generic::SharedVmoRegisterUnregisterVmoRequest {
691                    vmo_id,
692                })
693            }
694
695            #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
696            pub fn unregister_vmo_with<___R>(
697                &self,
698                request: ___R,
699            ) -> ::fidl_next::TwoWayFuture<'_, super::UnregisterVmo, ___T>
700            where
701                ___R: ::fidl_next::Encode<
702                        crate::wire::SharedVmoRegisterUnregisterVmoRequest,
703                        <___T as ::fidl_next::Transport>::SendBuffer,
704                    >,
705            {
706                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
707                    1266894365566071049,
708                    <super::UnregisterVmo as ::fidl_next::Method>::FLEXIBILITY,
709                    request,
710                ))
711            }
712        }
713
714        /// The server for the `SharedVmoRegister` protocol.
715        #[repr(transparent)]
716        pub struct SharedVmoRegisterServer<___T: ::fidl_next::Transport> {
717            server: ::fidl_next::protocol::Server<___T>,
718        }
719
720        impl<___T> SharedVmoRegisterServer<___T> where ___T: ::fidl_next::Transport {}
721    }
722}
723
724#[diagnostic::on_unimplemented(
725    note = "If {Self} implements the non-local SharedVmoRegisterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
726)]
727
728/// A client handler for the SharedVmoRegister protocol.
729///
730/// See [`SharedVmoRegister`] for more details.
731pub trait SharedVmoRegisterLocalClientHandler<
732    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
733    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
734>
735{
736}
737
738impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for SharedVmoRegister
739where
740    ___H: SharedVmoRegisterLocalClientHandler<___T>,
741    ___T: ::fidl_next::Transport,
742{
743    async fn on_event(
744        handler: &mut ___H,
745        mut message: ::fidl_next::Message<___T>,
746    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
747        match *message.header().ordinal {
748            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
749        }
750    }
751}
752
753#[diagnostic::on_unimplemented(
754    note = "If {Self} implements the non-local SharedVmoRegisterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
755)]
756
757/// A server handler for the SharedVmoRegister protocol.
758///
759/// See [`SharedVmoRegister`] for more details.
760pub trait SharedVmoRegisterLocalServerHandler<
761    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
762    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
763>
764{
765    #[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"]
766    fn register_vmo(
767        &mut self,
768
769        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
770
771        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
772    ) -> impl ::core::future::Future<Output = ()>;
773
774    #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
775    fn unregister_vmo(
776        &mut self,
777
778        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
779
780        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
781    ) -> impl ::core::future::Future<Output = ()>;
782}
783
784impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for SharedVmoRegister
785where
786    ___H: SharedVmoRegisterLocalServerHandler<___T>,
787    ___T: ::fidl_next::Transport,
788    for<'de> crate::wire::SharedVmoRegisterRegisterVmoRequest: ::fidl_next::Decode<
789            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
790            Constraint = (),
791        >,
792    for<'de> crate::wire::SharedVmoRegisterUnregisterVmoRequest: ::fidl_next::Decode<
793            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
794            Constraint = (),
795        >,
796{
797    async fn on_one_way(
798        handler: &mut ___H,
799        mut message: ::fidl_next::Message<___T>,
800    ) -> ::core::result::Result<
801        (),
802        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
803    > {
804        match *message.header().ordinal {
805            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
806        }
807    }
808
809    async fn on_two_way(
810        handler: &mut ___H,
811        mut message: ::fidl_next::Message<___T>,
812        responder: ::fidl_next::protocol::Responder<___T>,
813    ) -> ::core::result::Result<
814        (),
815        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
816    > {
817        match *message.header().ordinal {
818            3593681058348550677 => {
819                let responder = ::fidl_next::Responder::from_untyped(responder);
820
821                match ::fidl_next::AsDecoderExt::into_decoded(message) {
822                    Ok(decoded) => {
823                        handler
824                            .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
825                            .await;
826                        Ok(())
827                    }
828                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
829                        ordinal: 3593681058348550677,
830                        error,
831                    }),
832                }
833            }
834
835            1266894365566071049 => {
836                let responder = ::fidl_next::Responder::from_untyped(responder);
837
838                match ::fidl_next::AsDecoderExt::into_decoded(message) {
839                    Ok(decoded) => {
840                        handler
841                            .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
842                            .await;
843                        Ok(())
844                    }
845                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
846                        ordinal: 1266894365566071049,
847                        error,
848                    }),
849                }
850            }
851
852            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
853        }
854    }
855}
856
857/// A client handler for the SharedVmoRegister protocol.
858///
859/// See [`SharedVmoRegister`] for more details.
860pub trait SharedVmoRegisterClientHandler<
861    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
862    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
863>
864{
865}
866
867impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for SharedVmoRegister
868where
869    ___H: SharedVmoRegisterClientHandler<___T> + ::core::marker::Send,
870    ___T: ::fidl_next::Transport,
871{
872    async fn on_event(
873        handler: &mut ___H,
874        mut message: ::fidl_next::Message<___T>,
875    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
876        match *message.header().ordinal {
877            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
878        }
879    }
880}
881
882/// A server handler for the SharedVmoRegister protocol.
883///
884/// See [`SharedVmoRegister`] for more details.
885pub trait SharedVmoRegisterServerHandler<
886    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
887    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
888>
889{
890    #[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"]
891    fn register_vmo(
892        &mut self,
893
894        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
895
896        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
897    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
898
899    #[doc = " Unmaps and/or unpins the VMO and returns the handle to the caller.\n"]
900    fn unregister_vmo(
901        &mut self,
902
903        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
904
905        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
906    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
907}
908
909impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for SharedVmoRegister
910where
911    ___H: SharedVmoRegisterServerHandler<___T> + ::core::marker::Send,
912    ___T: ::fidl_next::Transport,
913    for<'de> crate::wire::SharedVmoRegisterRegisterVmoRequest: ::fidl_next::Decode<
914            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
915            Constraint = (),
916        >,
917    for<'de> crate::wire::SharedVmoRegisterUnregisterVmoRequest: ::fidl_next::Decode<
918            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
919            Constraint = (),
920        >,
921{
922    async fn on_one_way(
923        handler: &mut ___H,
924        mut message: ::fidl_next::Message<___T>,
925    ) -> ::core::result::Result<
926        (),
927        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
928    > {
929        match *message.header().ordinal {
930            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
931        }
932    }
933
934    async fn on_two_way(
935        handler: &mut ___H,
936        mut message: ::fidl_next::Message<___T>,
937        responder: ::fidl_next::protocol::Responder<___T>,
938    ) -> ::core::result::Result<
939        (),
940        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
941    > {
942        match *message.header().ordinal {
943            3593681058348550677 => {
944                let responder = ::fidl_next::Responder::from_untyped(responder);
945
946                match ::fidl_next::AsDecoderExt::into_decoded(message) {
947                    Ok(decoded) => {
948                        handler
949                            .register_vmo(::fidl_next::Request::from_decoded(decoded), responder)
950                            .await;
951                        Ok(())
952                    }
953                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
954                        ordinal: 3593681058348550677,
955                        error,
956                    }),
957                }
958            }
959
960            1266894365566071049 => {
961                let responder = ::fidl_next::Responder::from_untyped(responder);
962
963                match ::fidl_next::AsDecoderExt::into_decoded(message) {
964                    Ok(decoded) => {
965                        handler
966                            .unregister_vmo(::fidl_next::Request::from_decoded(decoded), responder)
967                            .await;
968                        Ok(())
969                    }
970                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
971                        ordinal: 1266894365566071049,
972                        error,
973                    }),
974                }
975            }
976
977            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
978        }
979    }
980}
981
982impl<___T> SharedVmoRegisterClientHandler<___T> for ::fidl_next::IgnoreEvents where
983    ___T: ::fidl_next::Transport
984{
985}
986
987impl<___H, ___T> SharedVmoRegisterLocalClientHandler<___T> for ::fidl_next::Local<___H>
988where
989    ___H: SharedVmoRegisterClientHandler<___T>,
990    ___T: ::fidl_next::Transport,
991{
992}
993
994impl<___H, ___T> SharedVmoRegisterLocalServerHandler<___T> for ::fidl_next::Local<___H>
995where
996    ___H: SharedVmoRegisterServerHandler<___T>,
997    ___T: ::fidl_next::Transport,
998{
999    async fn register_vmo(
1000        &mut self,
1001
1002        request: ::fidl_next::Request<shared_vmo_register::RegisterVmo, ___T>,
1003
1004        responder: ::fidl_next::Responder<shared_vmo_register::RegisterVmo, ___T>,
1005    ) {
1006        ___H::register_vmo(&mut self.0, request, responder).await
1007    }
1008
1009    async fn unregister_vmo(
1010        &mut self,
1011
1012        request: ::fidl_next::Request<shared_vmo_register::UnregisterVmo, ___T>,
1013
1014        responder: ::fidl_next::Responder<shared_vmo_register::UnregisterVmo, ___T>,
1015    ) {
1016        ___H::unregister_vmo(&mut self.0, request, responder).await
1017    }
1018}
1019
1020pub 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
