fidl_next_bind/
endpoint.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use core::marker::PhantomData;
6use core::mem::MaybeUninit;
7
8use fidl_next_codec::{
9    munge, Decode, DecodeError, Encodable, EncodableOption, Encode, EncodeError, EncodeOption,
10    Slot, TakeFrom, ZeroPadding,
11};
12
13macro_rules! endpoint {
14    (
15        #[doc = $doc:literal]
16        $name:ident
17    ) => {
18        #[doc = $doc]
19        #[derive(Debug)]
20        #[repr(transparent)]
21        pub struct $name<T, P> {
22            transport: T,
23            _protocol: PhantomData<P>,
24        }
25
26        unsafe impl<T: ZeroPadding, P> ZeroPadding for $name<T, P> {
27            #[inline]
28            fn zero_padding(out: &mut MaybeUninit<Self>) {
29                munge!(let Self { transport, _protocol: _ } = out);
30                T::zero_padding(transport);
31            }
32        }
33
34        impl<T, P> $name<T, P> {
35            /// Returns a new endpoint over the given transport.
36            pub fn from_untyped(transport: T) -> Self {
37                Self { transport, _protocol: PhantomData }
38            }
39
40            /// Returns the underlying transport.
41            pub fn into_untyped(self) -> T {
42                self.transport
43            }
44        }
45
46        unsafe impl<D, T, P> Decode<D> for $name<T, P>
47        where
48            D: ?Sized,
49            T: Decode<D>,
50        {
51            fn decode(slot: Slot<'_, Self>, decoder: &mut D) -> Result<(), DecodeError> {
52                munge!(let Self { transport, _protocol: _ } = slot);
53                T::decode(transport, decoder)
54            }
55        }
56
57        impl<T, P> Encodable for $name<T, P>
58        where
59            T: Encodable,
60        {
61            type Encoded = $name<T::Encoded, P>;
62        }
63
64        impl<T, P> EncodableOption for $name<T, P>
65        where
66            T: EncodableOption,
67        {
68            type EncodedOption = $name<T::EncodedOption, P>;
69        }
70
71        unsafe impl<E, T, P> Encode<E> for $name<T, P>
72        where
73            E: ?Sized,
74            T: Encode<E>,
75        {
76            fn encode(
77                &mut self,
78                encoder: &mut E,
79                out: &mut MaybeUninit<Self::Encoded>,
80            ) -> Result<(), EncodeError> {
81                munge!(let Self::Encoded { transport, _protocol: _ } = out);
82                self.transport.encode(encoder, transport)
83            }
84        }
85
86        unsafe impl<E, T, P> EncodeOption<E> for $name<T, P>
87        where
88            E: ?Sized,
89            T: EncodeOption<E>,
90        {
91            fn encode_option(
92                this: Option<&mut Self>,
93                encoder: &mut E,
94                out: &mut MaybeUninit<Self::EncodedOption>,
95            ) -> Result<(), EncodeError> {
96                munge!(let Self::EncodedOption { transport, _protocol: _ } = out);
97                T::encode_option(this.map(|this| &mut this.transport), encoder, transport)
98            }
99        }
100
101        impl<T, P, U> TakeFrom<$name<U, P>> for $name<T, P>
102        where
103            T: TakeFrom<U>,
104        {
105            fn take_from(from: &$name<U, P>) -> Self {
106                Self { transport: T::take_from(&from.transport), _protocol: PhantomData }
107            }
108        }
109
110        impl<T, P, U> TakeFrom<$name<U, P>> for Option<$name<T, P>>
111        where
112            Option<T>: TakeFrom<U>,
113        {
114            fn take_from(from: &$name<U, P>) -> Self {
115                Option::<T>::take_from(&from.transport)
116                    .map(|transport| $name { transport, _protocol: PhantomData })
117            }
118        }
119
120        #[cfg(feature = "compat")]
121        impl<T, P1, P2> TakeFrom<$name<T, P1>> for ::fidl::endpoints::$name<P2>
122        where
123            ::fidl::Channel: TakeFrom<T>,
124            P2: TakeFrom<P1>,
125        {
126            fn take_from(from: &$name<T, P1>) -> Self {
127                Self::new(::fidl::Channel::take_from(&from.transport))
128            }
129        }
130
131        #[cfg(feature = "compat")]
132        impl<T, P1, P2> TakeFrom<$name<T, P1>> for Option<::fidl::endpoints::$name<P2>>
133        where
134            Option<::fidl::Channel>: TakeFrom<T>,
135            P2: TakeFrom<P1>,
136        {
137            fn take_from(from: &$name<T, P1>) -> Self {
138                Option::<::fidl::Channel>::take_from(&from.transport)
139                    .map(::fidl::endpoints::$name::new)
140            }
141        }
142    };
143}
144
145endpoint! {
146    /// The client end of a protocol.
147    ClientEnd
148}
149
150endpoint! {
151    /// The server end of a protocol.
152    ServerEnd
153}
fidl_next_bind/endpoint.rs

fidl_next_bind/
endpoint.rs
