fidl_next_bind/
server.rs

Help
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;
6
7use fidl_next_codec::{Encode, EncodeError};
8use fidl_next_protocol::{self as protocol, ProtocolError, SendFuture, Transport};
9
10use super::{Method, ServerEnd};
11
12/// A storngly typed server sender.
13pub struct ServerSender<T: Transport, P> {
14    sender: protocol::ServerSender<T>,
15    _protocol: PhantomData<P>,
16}
17
18unsafe impl<T, P> Send for ServerSender<T, P>
19where
20    T: Transport,
21    protocol::ServerSender<T>: Send,
22{
23}
24
25impl<T: Transport, P> ServerSender<T, P> {
26    /// Wraps an untyped sender reference, returning a typed sender reference.
27    pub fn wrap_untyped(client: &protocol::ServerSender<T>) -> &Self {
28        unsafe { &*(client as *const protocol::ServerSender<T>).cast() }
29    }
30
31    /// Returns the underlying untyped sender.
32    pub fn as_untyped(&self) -> &protocol::ServerSender<T> {
33        &self.sender
34    }
35
36    /// Closes the channel from the server end.
37    pub fn close(&self) {
38        self.as_untyped().close();
39    }
40}
41
42impl<T: Transport, P> Clone for ServerSender<T, P> {
43    fn clone(&self) -> Self {
44        Self { sender: self.sender.clone(), _protocol: PhantomData }
45    }
46}
47
48/// A protocol which supports servers.
49pub trait ServerProtocol<T: Transport, H>: Sized {
50    /// Handles a received server one-way message with the given handler.
51    fn on_one_way(
52        handler: &mut H,
53        server: &ServerSender<T, Self>,
54        ordinal: u64,
55        buffer: T::RecvBuffer,
56    );
57
58    /// Handles a received server two-way message with the given handler.
59    fn on_two_way(
60        handler: &mut H,
61        server: &ServerSender<T, Self>,
62        ordinal: u64,
63        buffer: T::RecvBuffer,
64        responder: protocol::Responder,
65    );
66}
67
68/// An adapter for a server protocol handler.
69pub struct ServerAdapter<P, H> {
70    handler: H,
71    _protocol: PhantomData<P>,
72}
73
74unsafe impl<P, H> Send for ServerAdapter<P, H> where H: Send {}
75
76impl<P, H> ServerAdapter<P, H> {
77    /// Creates a new protocol server handler from a supported handler.
78    pub fn from_untyped(handler: H) -> Self {
79        Self { handler, _protocol: PhantomData }
80    }
81}
82
83impl<T, P, H> protocol::ServerHandler<T> for ServerAdapter<P, H>
84where
85    T: Transport,
86    P: ServerProtocol<T, H>,
87{
88    fn on_one_way(
89        &mut self,
90        server: &protocol::ServerSender<T>,
91        ordinal: u64,
92        buffer: T::RecvBuffer,
93    ) {
94        P::on_one_way(&mut self.handler, ServerSender::wrap_untyped(server), ordinal, buffer)
95    }
96
97    fn on_two_way(
98        &mut self,
99        server: &protocol::ServerSender<T>,
100        ordinal: u64,
101        buffer: <T as Transport>::RecvBuffer,
102        responder: protocol::Responder,
103    ) {
104        P::on_two_way(
105            &mut self.handler,
106            ServerSender::wrap_untyped(server),
107            ordinal,
108            buffer,
109            responder,
110        )
111    }
112}
113
114/// A strongly typed server.
115pub struct Server<T: Transport, P> {
116    server: protocol::Server<T>,
117    _protocol: PhantomData<P>,
118}
119
120unsafe impl<T, P> Send for Server<T, P>
121where
122    T: Transport,
123    protocol::Server<T>: Send,
124{
125}
126
127impl<T: Transport, P> Server<T, P> {
128    /// Creates a new server from a server end.
129    pub fn new(server_end: ServerEnd<T, P>) -> Self {
130        Self { server: protocol::Server::new(server_end.into_untyped()), _protocol: PhantomData }
131    }
132
133    /// Returns the sender for the server.
134    pub fn sender(&self) -> &ServerSender<T, P> {
135        ServerSender::wrap_untyped(self.server.sender())
136    }
137
138    /// Creates a new server from an untyped server.
139    pub fn from_untyped(server: protocol::Server<T>) -> Self {
140        Self { server, _protocol: PhantomData }
141    }
142
143    /// Runs the server with the provided handler.
144    pub async fn run<H>(&mut self, handler: H) -> Result<(), ProtocolError<T::Error>>
145    where
146        P: ServerProtocol<T, H>,
147    {
148        self.server.run(ServerAdapter { handler, _protocol: PhantomData::<P> }).await
149    }
150}
151
152/// A strongly typed `Responder`.
153#[must_use]
154pub struct Responder<M> {
155    responder: protocol::Responder,
156    _method: PhantomData<M>,
157}
158
159impl<M> Responder<M> {
160    /// Creates a new responder.
161    pub fn from_untyped(responder: protocol::Responder) -> Self {
162        Self { responder, _method: PhantomData }
163    }
164
165    /// Responds to the client.
166    pub fn respond<'s, T, P, R>(
167        self,
168        server: &'s ServerSender<T, P>,
169        response: &mut R,
170    ) -> Result<SendFuture<'s, T>, EncodeError>
171    where
172        T: Transport,
173        M: Method<Protocol = P>,
174        R: Encode<T::SendBuffer, Encoded = M::Response>,
175    {
176        server.as_untyped().send_response(self.responder, M::ORDINAL, response)
177    }
178}
fidl_next_bind/server.rs

fidl_next_bind/
server.rs
