fmt

src/demo/message/gameevent.rs

@@ -3,12 +3,12 @@ use std::iter::FromIterator;
 
 use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
 
-use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use crate::demo::gameevent_gen::GameEventType;
 use crate::demo::gamevent::{
     GameEvent, GameEventDefinition, GameEventEntry, GameEventValue, GameEventValueType,
     RawGameEvent,
 };
+use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 
 fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<GameEventValue> {
     Ok(match definition.kind {
@@ -40,7 +40,10 @@ impl Parse for GameEventMessage {
                     values.push(read_event_value(&mut data, &entry)?);
                 }
 
-                RawGameEvent { event_type: definition.event_type, values }
+                RawGameEvent {
+                    event_type: definition.event_type,
+                    values,
+                }
             }
             None => unreachable!(),
         };
@@ -65,7 +68,7 @@ pub struct GameEventListMessage {
 
 impl BitRead<LittleEndian> for GameEventDefinition {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
-        let event_type:GameEventTypeId = stream.read()?;
+        let event_type: GameEventTypeId = stream.read()?;
         let name: String = stream.read()?;
         let mut entries = Vec::new();
 

src/demo/message/usermessage.rs

@@ -121,9 +121,7 @@ impl BitRead<LittleEndian> for ChatMessageKind {
             "TF_Chat_Team_Dead" => ChatMessageKind::ChatTeamDead,
             "#TF_Name_Change" => ChatMessageKind::NameChange,
             "TF_Chat_All" => ChatMessageKind::ChatAll,
-            _ => {
+            _ => unreachable!("unknown chat kind"),
-                unreachable!("unknown chat kind")
-            },
         })
     }
 }

src/demo/parser/analyser.rs

@@ -4,16 +4,16 @@ use std::thread::spawn;
 use serde::Serialize;
 use serde_repr::Serialize_repr;
 
-use crate::{ParserState, ReadResult, Stream};
 use crate::demo::gameevent_gen::{
     GameEvent, PlayerDeathEvent, PlayerSpawnEvent, TeamPlayRoundWinEvent,
 };
-use crate::demo::message::{Message, MessageType};
 use crate::demo::message::packetentities::EntityId;
 use crate::demo::message::usermessage::{ChatMessageKind, SayText2Message, UserMessage};
+use crate::demo::message::{Message, MessageType};
 use crate::demo::packet::stringtable::StringTableEntry;
 use crate::demo::parser::handler::{MessageHandler, StringTableEntryHandler};
 use crate::demo::vector::Vector;
+use crate::{ParserState, ReadResult, Stream};
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ChatMassage {
@@ -295,7 +295,10 @@ pub struct UserState {
 }
 
 impl UserState {
-    pub fn from_users_and_spawn(users: HashMap<UserId, UserInfo>, spawns: Vec<Spawn>) -> HashMap<UserId, Self> {
+    pub fn from_users_and_spawn(
+        users: HashMap<UserId, UserInfo>,
+        spawns: Vec<Spawn>,
+    ) -> HashMap<UserId, Self> {
         let mut teams: HashMap<UserId, Team> = HashMap::with_capacity(users.len());
         let mut classes: HashMap<UserId, HashMap<Class, u8>> = HashMap::with_capacity(9);
         for spawn in spawns {
@@ -305,15 +308,21 @@ impl UserState {
             *class_spawns += 1;
         }
 
-        users.into_iter().map(|(user_id, user)| {
+        users
-            (user_id, UserState {
+            .into_iter()
+            .map(|(user_id, user)| {
+                (
+                    user_id,
+                    UserState {
                         classes: classes.remove(&user.user_id).unwrap_or(HashMap::new()),
                         team: teams.remove(&user.user_id).unwrap_or(Team::Other),
                         name: user.name,
                         user_id: user.user_id,
                         steam_id: user.steam_id,
+                    },
+                )
             })
-        }).collect()
+            .collect()
     }
 }
 

src/demo/parser/handler.rs

@@ -4,8 +4,8 @@ use std::rc::Rc;
 
 use crate::demo::message::{Message, MessageType};
 use crate::demo::packet::datatable::{SendTable, ServerClass};
-use crate::demo::packet::Packet;
 use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
+use crate::demo::packet::Packet;
 use crate::demo::parser::analyser::{Analyser, MatchState};
 use crate::ParserState;
 
@@ -89,11 +89,13 @@ impl DemoHandler {
     }
 
     fn handle_data_table(&mut self, send_tables: Vec<SendTable>, server_classes: Vec<ServerClass>) {
-        self.state_handler.handle_data_table(send_tables, server_classes);
+        self.state_handler
+            .handle_data_table(send_tables, server_classes);
     }
 
     fn handle_string_entry(&mut self, table: &String, index: usize, entries: &StringTableEntry) {
-        self.state_handler.handle_string_entry(table, index, entries);
+        self.state_handler
+            .handle_string_entry(table, index, entries);
         self.analyser.handle_string_entry(table, index, entries);
     }
 

src/demo/parser/mod.rs

@@ -3,6 +3,7 @@ use std::rc::Rc;
 
 use bitstream_reader::{BitRead, LittleEndian, ReadError};
 
+use crate::demo::gameevent_gen::GameEventType;
 use crate::demo::gamevent::{GameEventValue, GameEventValueType};
 use crate::demo::header::Header;
 use crate::demo::message::{Message, MessageType};
@@ -14,7 +15,6 @@ pub use crate::demo::parser::state::ParserState;
 use crate::Stream;
 use std::cell::RefCell;
 use std::ops::Deref;
-use crate::demo::gameevent_gen::GameEventType;
 
 mod analyser;
 mod handler;
@@ -40,7 +40,11 @@ pub enum ParseError {
     /// A unknown game event type was read
     UnknownGameEvent(String),
     /// A read game event doesn't contain the expected values
-    InvalidGameEvent { expected_type: GameEventValueType, name: String, value: GameEventValue },
+    InvalidGameEvent {
+        expected_type: GameEventValueType,
+        name: String,
+        value: GameEventValue,
+    },
     /// Unexpected type of compressed data
     UnexpectedCompressionType(String),
     /// Error while decompressing SNAP compressed string table
@@ -85,10 +89,9 @@ pub struct DemoParser {
 
 impl DemoParser {
     pub fn new(stream: Stream) -> Self {
-
         DemoParser {
             stream,
-            handler: DemoHandler::new()
+            handler: DemoHandler::new(),
         }
     }
 

src/demo/parser/state.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use crate::demo::gameevent_gen::GameEventType;
 use crate::demo::gamevent::GameEventDefinition;
+use crate::demo::message::gameevent::GameEventTypeId;
 use crate::demo::message::packetentities::EntityId;
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::demo::message::{Message, MessageType};
@@ -12,7 +13,6 @@ use crate::demo::parser::handler::{MessageHandler, StringTableEntryHandler};
 use crate::demo::sendprop::SendProp;
 use crate::Stream;
 use std::mem::replace;
-use crate::demo::message::gameevent::GameEventTypeId;
 
 pub type StringEntryHandler = Box<FnMut(&String, &StringTableEntry) -> ()>;
 
@@ -127,7 +127,7 @@ impl StringTableEntryHandler for ParserState {
                 },
                 _ => unreachable!("missing baseline"),
             },
-            _ => {},
+            _ => {}
         }
     }
 }