Move packet types from packet_connection to packet.

src/network/client.rs

 use futures::Future;
-use futures::task::{Context, Poll};
-use core::pin::Pin;
+//use futures::task::{Context, Poll};
+//use core::pin::Pin;
 use tokio::stream::Stream;
-use async_tungstenite::{tokio::connect_async, tungstenite::Message, WebSocketStream};
-use url::Url;
+//use async_tungstenite::{tokio::connect_async, tungstenite::Message, WebSocketStream};
+//use url::Url;
 
-use super::packet_connection::IncomingPacket;
+use super::packet::IncomingPacket;
 
 use std::time::Duration;
 
 
 pub trait ServerEventStream<PacketType>: Stream<Item = PacketType> {}
 
-pub struct WSRPCInterface<PacketType, Stream> {
+/*pub struct WSRPCInterface<PacketType, Stream> {
     // TODO
     _unused: PacketType,
     stream: WebSocketStream<Stream>,
 }
 
 impl<P, S> WSRPCInterface<P, S> {
-    fn create<P2, S2>(ws_stream: WebSocketStream<S2>) -> (Self, WSServerEventStream<P2>) {
+    fn create<P2, S2>(_ws_stream: WebSocketStream<S2>) -> (Self, WSServerEventStream<P2>) {
         // TODO
         panic!("Not yet implemented.");
     }
         // TODO
         panic!("Not yet implemented.");
     }
-}
-
+}*/
 
-pub async fn low_level_integration_test_client(address: String) {
-    let url = Url::parse(&address).unwrap();
-    let (mut ws_stream, _) = connect_async(url).await.unwrap();
+pub async fn low_level_integration_test_client(_address: String) {
+    //let url = Url::parse(&address).unwrap();
+    //let (mut ws_stream, _) = connect_async(url).await.unwrap();
     // TODO
+    panic!("Not yet implemented.");
 }

src/network/mod.rs

 pub mod client;
-pub mod packet_connection;
+pub mod packet;
 pub mod server;

src/network/packet_connection.rs → src/network/packet.rs

 //! a way that no such temporal information is necessary to process the events.
 //! TODO: Example to demonstrate the problem.
 
-use serde::de::DeserializeOwned;
+//use futures::sink::Sink;
+//use futures::stream::Stream;
+//use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
 pub const SERVER_EVENT_ID: u32 = u32::max_value();
 
-pub trait PacketConnection {
-    type Payload: Serialize + DeserializeOwned;
-
-    // TODO
-}
+//pub trait PacketConnection: Sink<&Self::Payload> + Stream<IncomingPacket<Payload>> {
+//    type Payload: Serialize + DeserializeOwned;
+//}
 
 /// Type which holds a byte vector received via the network and which allows access to the
 /// deserialized packet.

src/network/server.rs

-use super::packet_connection::IncomingPacket;
+use super::packet::IncomingPacket;
 
 // Trait that is implemented by any RPC server to process incoming calls.
 trait RPCServer {
 }
 
 impl LowLevelIntegrationTestServer {
-    pub async fn start(bind_address: &str) -> LowLevelIntegrationTestServer {
+    pub async fn start(_bind_address: &str) -> LowLevelIntegrationTestServer {
         // TODO
         LowLevelIntegrationTestServer{}
     }
         // TODO
     }
 }
+