clear code

examples/ping_pong_client.rs

@@ -11,8 +11,7 @@ fn main() {
         if timer.elapsed() > period {
             timer = Instant::now();
             id += 1;
-            let _ = client
-                .send(format!("Ping {}", id).into_bytes());
+            let _ = client.send(format!("Ping {}", id).into_bytes());
         }
         let _ = client
             .recv()

examples/ping_pong_server.rs

@@ -32,9 +32,6 @@ impl victorem::Game for PingPongGame {
 }
 
 fn main() {
-    let mut server = victorem::GameServer::new(
-        PingPongGame { id: 0 },
-        "2222",
-    ).unwrap();
+    let mut server = victorem::GameServer::new(PingPongGame { id: 0 }, "2222").unwrap();
     server.run();
 }

src/business_logic_layer/id.rs

@@ -31,7 +31,9 @@ pub struct Generator {
 }
 
 impl Generator {
-    pub fn new(start: u32) -> Generator { Generator { id: start } }
+    pub fn new(start: u32) -> Generator {
+        Generator { id: start }
+    }
     pub fn generate(&mut self) -> u32 {
         let result = self.id;
         self.id += 1;
@@ -44,11 +46,12 @@ pub struct Filter {
 }
 
 impl Filter {
-    pub fn new(start: u32) -> Filter { Filter { id: start } }
+    pub fn new(start: u32) -> Filter {
+        Filter { id: start }
+    }
 
-    pub fn is_valid_last_recv_id(&mut self, data: &impl IWithId) -> Result<(), Exception> {
-        if data.get() > self.id
-            || self.id - data.get() > MAX_ID_BREAK {
+    pub fn filter(&mut self, data: &impl IWithId) -> Result<(), Exception> {
+        if data.get() > self.id || self.id - data.get() > MAX_ID_BREAK {
             self.id = data.get();
             Ok(())
         } else {
@@ -63,7 +66,6 @@ pub struct Arranger<T: IWithId> {
     received: Vec<u32>,
 }
 
-
 const MAX_ID_BREAK: u32 = 64;
 const MAX_SAVED: usize = (MAX_ID_BREAK * 2) as usize;
 const MAX_RECEIVED: usize = MAX_SAVED;

src/business_logic_layer/key.rs

@@ -1,5 +1,5 @@
-use crate::entities::{CommandPacket, Exception, StatePacket};
-use std::time::{Duration, SystemTimeError, SystemTime, UNIX_EPOCH};
+use crate::entities::{CommandPacket, StatePacket};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 pub trait IWithKey {
     fn get(&self) -> Duration;
@@ -27,27 +27,28 @@ impl IWithKey for CommandPacket {
 }
 
 pub fn new_key() -> Duration {
-    match SystemTime::now()
-        .duration_since(UNIX_EPOCH) {
+    match SystemTime::now().duration_since(UNIX_EPOCH) {
         Ok(d) => d,
         Err(e) => e.duration(),
     }
 }
 
 pub struct Generator {
-    key: Duration
+    key: Duration,
 }
 
 impl Generator {
     pub fn new() -> Generator {
         Generator { key: new_key() }
     }
 
-    pub fn generate(&self) -> Duration { self.key }
+    pub fn generate(&self) -> Duration {
+        self.key
+    }
 }
 
 pub struct Filter {
-    key: Duration
+    key: Duration,
 }
 
 impl Filter {

src/business_logic_layer/mod.rs

@@ -1,7 +1,3 @@
-use std::collections::HashMap;
-use std::thread;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH, SystemTimeError};
-
 mod version;
 
 mod protocol;
@@ -12,13 +8,13 @@ pub mod timer;
 
 mod key;
 
-use crate::data_access_layer::Cache;
-use crate::entities::{CommandPacket, Exception, StatePacket};
-use self::id::{Filter, Generator, Arranger};
-use self::version::VersionChecker;
+use self::id::{Arranger, Filter, Generator};
+use self::key as k;
 use self::protocol::ProtocolChecker;
 use self::timer::SleepTimer;
-use self::key as k;
+use self::version::VersionChecker;
+use crate::data_access_layer::Cache;
+use crate::entities::{CommandPacket, Exception, StatePacket};
 
 pub struct Client {
     protocol_version: VersionChecker,
@@ -48,8 +44,8 @@ impl Client {
 
     fn create_command(&mut self, command: Vec<u8>) -> CommandPacket {
         CommandPacket {
-            protocol_id:  self.protocol_id.get(),
-            protocol_version:self.protocol_version.get(),
+            protocol_id: self.protocol_id.get(),
+            protocol_version: self.protocol_version.get(),
             id: self.id.generate(),
             command,
             session_key: self.key_generator.generate(),
@@ -70,7 +66,7 @@ impl Client {
             self.key_filter = k::Filter::new(state.session_key);
             self.id_filter = Filter::new(0);
         }
-        self.id_filter.is_valid_last_recv_id(&state)?;
+        self.id_filter.filter(&state)?;
         let vec = self.cache.get_range(&state.lost_ids);
         Ok((state.state, vec))
     }
@@ -98,7 +94,6 @@ impl Server {
         }
     }
 
-
     pub fn send(&mut self, state: Vec<u8>) -> StatePacket {
         StatePacket {
             protocol_id: self.protocol_id.get(),

src/business_logic_layer/timer.rs

@@ -1,6 +1,5 @@
-use crate::entities::{CommandPacket, Exception, StatePacket};
-use std::time::{Duration, Instant};
 use std::thread;
+use std::time::{Duration, Instant};
 
 pub struct SleepTimer {
     time: Duration,

src/business_logic_layer/version.rs

@@ -2,7 +2,7 @@ use crate::entities::{CommandPacket, Exception, StatePacket};
 
 const PROTOCOL_VERSION: u8 = 1;
 
-trait IWithVersion {
+pub trait IWithVersion {
     fn get(&self) -> u8;
     fn set(&mut self, version: u8);
 }

src/entities.rs

@@ -3,7 +3,7 @@ use std::error::Error;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::io;
-use std::time::{Duration, SystemTimeError};
+use std::time::Duration;
 
 #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct CommandPacket {

src/lib.rs

@@ -8,7 +8,7 @@ use crate::data_access_layer::{TypedClientSocket, TypedServerSocket};
 pub use crate::entities::Exception;
 use std::collections::HashMap;
 use std::net::SocketAddr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::Duration;
 
 //TODO: Add Session ID for Client And Server!
 
@@ -131,19 +131,16 @@ impl ServerSocket {
     }
 
     pub fn add(&mut self, client: &SocketAddr) {
-        use std::net::*;
         if !self.servers.contains_key(client) {
-            self.servers.insert(
-                client.clone(),
-                bll::Server::new(),
-            );
+            self.servers.insert(client.clone(), bll::Server::new());
         }
     }
 
     pub fn send_to_all(&mut self, state: Vec<u8>) -> Vec<(SocketAddr, Exception)> {
         let mut exceptions = Vec::new();
         for (a, s) in &mut self.servers {
-            let _ = self.socket
+            let _ = self
+                .socket
                 .write(a, &s.send(state.clone()))
                 .map_err(|e| exceptions.push((*a, e)));
         }
@@ -189,8 +186,7 @@ impl<T: Game> GameServer<T> {
             let state = self.game.draw(self.draw_elapsed.elapsed());
             self.game.add_client().map(|a| self.socket.add(&a));
             self.game.remove_client().map(|a| self.socket.remove(&a));
-            self.is_running = self.is_running
-                & &self
+            self.is_running &= self
                 .socket
                 .send_to_all(state)
                 .into_iter()
@@ -203,21 +199,20 @@ impl<T: Game> GameServer<T> {
     }
 
     fn update(&mut self) {
-        let _ = self.socket
+        let _ = self
+            .socket
             .recv()
             .map(|(commands, from)| {
                 if self.game.allow_connect(&from) {
-                    self.is_running = self.is_running
-                        & &self
-                        .game
-                        .handle_command(self.update.elapsed(), commands, from);
+                    self.is_running &=
+                        self.game
+                            .handle_command(self.update.elapsed(), commands, from);
                 } else {
                     self.socket.remove(&from);
                 }
             })
             .map_err(|e| {
-                self.is_running = self.is_running
-                    & &self
+                self.is_running &= self
                     .game
                     .handle_server_event(ServerEvent::ExceptionOnRecv(e))
             });

tests/test.rs

@@ -78,6 +78,9 @@ impl<'a> Game for GameMock<'a> {
     fn add_client(&mut self) -> Option<SocketAddr> {
         self.data.new_client.clone()
     }
+    fn remove_client(&mut self) -> Option<SocketAddr> {
+        self.data.disconnect_this_client.clone()
+    }
 }
 
 fn create_server(game: GameMock, port: String) -> Result<GameServer<GameMock>, Exception> {
@@ -114,7 +117,7 @@ fn server_should_stop_if_handle_command_returns_false() -> Result<(), Exception>
         let res = ClientSocket::new("1112", "127.0.0.1:3333")
             .map(|mut c| {
                 for _i in 0..1000 {
-                    c.send(vec![1u8, 3u8]);
+                    let _ = c.send(vec![1u8, 3u8]);
                 }
                 1
             })
@@ -153,7 +156,7 @@ fn server_should_recv_commands_from_client() -> Result<(), Exception> {
         let res = ClientSocket::new("1111", "127.0.0.1:3335")
             .map(|mut c| {
                 for _i in 0..1000 {
-                    c.send(vec![1u8, 3u8]);
+                    let _ = c.send(vec![1u8, 3u8]);
                 }
                 1
             })
@@ -237,9 +240,9 @@ struct Calculator<T> {
     pub result: Option<T>,
 }
 
-impl<'a, 'b: 'a, T: 'b + Add<Output=T> + Mul<Output=T> + Borrow<T>> Calculator<T>
-    where
-        &'a T: Add<Output=T> + Mul<Output=T>,
+impl<'a, 'b: 'a, T: 'b + Add<Output = T> + Mul<Output = T> + Borrow<T>> Calculator<T>
+where
+    &'a T: Add<Output = T> + Mul<Output = T>,
 {
     pub fn calculate_procedurally(&'b mut self) {
         let res: T = match self.op {
@@ -250,7 +253,7 @@ impl<'a, 'b: 'a, T: 'b + Add<Output=T> + Mul<Output=T> + Borrow<T>> Calculator<T
     }
 }
 
-impl<T: Add<Output=T> + Mul<Output=T> + Clone> Calculator<T> {
+impl<T: Add<Output = T> + Mul<Output = T> + Clone> Calculator<T> {
     pub fn calculate_functionally(mut self) -> Self {
         self.result = Some(match self.op {
             Operation::Add => self.lhs.clone() + self.rhs.clone(),