More network types.

src/network/client.rs

@@ -1,21 +1,20 @@
 use futures::Future;
-use serde::de::DeserializeOwned;
-use serde::Serialize;
+use tokio::stream::Stream;
 
-use std::time::Duration;
+use super::packet_connection::IncomingPacket;
 
-trait Connection {
-    type Request: Serialize;
-    type Response: DeserializeOwned; // TODO: Better lifetime for zero-copy deserialization of large amounts of data?
-    type Call: RemoteCall<Output = Self::Response>;
+use std::time::Duration;
 
-    fn call(call: Self::Request) -> Self::Call;
+pub trait RPCInterface {
+    type PacketType;
+    type NetworkError;
+    type Call: RPC<Output = Result<IncomingPacket<Self::PacketType>, Self::NetworkError>>;
 
-    // TODO: Server-client events.
+    fn call(call: &Self::PacketType) -> Self::Call;
 }
 
-trait RemoteCall: Future {
-    // TODO
-
+pub trait RPC: Future {
     fn with_timeout(self, timeout: Duration) -> Self;
 }
+
+pub trait ServerEventStream<PacketType>: Stream<Item = PacketType> {}

src/network/mod.rs

@@ -1,3 +1,3 @@
-mod client;
-mod packet_connection;
-mod server;
+pub mod client;
+pub mod packet_connection;
+pub mod server;

src/network/packet_connection.rs

@@ -30,16 +30,27 @@
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
-trait PacketConnection {
+pub const SERVER_EVENT_ID: u32 = u32::max_value();
+
+pub trait PacketConnection {
     type Payload: Serialize + DeserializeOwned;
 
     // TODO
 }
 
+/// Type which holds a byte vector received via the network and which allows access to the
+/// deserialized packet.
+///
+/// The type can be used for efficient zero-copy deserialization of large packets.
+pub struct IncomingPacket<Payload> {
+    // TODO
+    _packet: Payload,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
 pub struct Packet<Payload> {
     pub id: u32,
-    pub response: bool,
+    pub response: bool, // TODO: Not really required.
     pub payload: Payload,
 }
 

src/network/server.rs

@@ -1 +1,23 @@
+use super::packet_connection::IncomingPacket;
 
+// Trait that is implemented by any RPC server to process incoming calls.
+trait RPCServer {
+    type PacketType;
+    type NetworkError;
+
+    fn incoming_call<Response>(
+        &mut self,
+        call: IncomingPacket<Self::PacketType>,
+        response: Response,
+    ) where
+        Response: RPCResponse<PacketType = Self::PacketType, NetworkError = Self::NetworkError>;
+}
+
+// TODO: Document that types implementing this trait should also implement Drop and should return
+// an error if the type is dropped without send() being called.
+trait RPCResponse {
+    type PacketType;
+    type NetworkError;
+
+    fn send(self, packet: &Self::PacketType) -> Result<(), Self::NetworkError>;
+}