pass message to analysers by ref

Cargo.toml

@@ -28,4 +28,7 @@ parse-display = "0.1"
 jemallocator = "0.3"
 
 [dev-dependencies]
-pretty_assertions = "0.6"
+pretty_assertions = "0.6"
+
+[profile.release]
+lto = true

benches/allmessages.rs

@@ -26,7 +26,7 @@ impl MessageHandler for AllMessages {
         true
     }
 
-    fn handle_message(&mut self, message: Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, tick: u32) {
         test::black_box(message);
     }
 

benches/sendprop.rs

@@ -26,10 +26,6 @@ impl MessageHandler for SendPropAnalyser {
         false
     }
 
-    fn handle_message(&mut self, message: Message, tick: u32) {}
-
-    fn handle_string_entry(&mut self, table: &String, _index: usize, entry: &StringTableEntry) {}
-
     fn get_output(self, state: ParserState) -> Self::Output {
         state
             .send_tables

src/demo/message/packetentities.rs

@@ -44,7 +44,7 @@ pub enum PVS {
     Delete = 3,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct PacketEntity {
     pub server_class: ClassId,
     pub entity_index: EntityId,

src/demo/message/usermessage.rs

@@ -107,7 +107,7 @@ impl ParseBitSkip for UserMessage {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
 pub enum ChatMessageKind {
     #[serde(rename = "TF_Chat_All")]
     ChatAll,

src/demo/parser/analyser.rs

@@ -23,11 +23,11 @@ pub struct ChatMassage {
 }
 
 impl ChatMassage {
-    pub fn from_message(message: SayText2Message, tick: u32) -> Self {
+    pub fn from_message(message: &SayText2Message, tick: u32) -> Self {
         ChatMassage {
             kind: message.kind,
-            from: message.from.unwrap_or_default(),
+            from: message.from.clone().unwrap_or_default(),
-            text: message.text,
+            text: message.text.clone(),
             tick,
         }
     }
@@ -104,7 +104,7 @@ pub struct Spawn {
 }
 
 impl Spawn {
-    pub fn from_event(event: PlayerSpawnEvent, tick: u32) -> Self {
+    pub fn from_event(event: &PlayerSpawnEvent, tick: u32) -> Self {
         Spawn {
             user: UserId((event.user_id & 255) as u8),
             class: Class::new(event.class),
@@ -132,7 +132,7 @@ pub struct Death {
 }
 
 impl Death {
-    pub fn from_event(event: PlayerDeathEvent, tick: u32) -> Self {
+    pub fn from_event(event: &PlayerDeathEvent, tick: u32) -> Self {
         let assister = if event.assister < (16 * 1024) {
             Some(UserId((event.assister & 255) as u8))
         } else {
@@ -142,7 +142,7 @@ impl Death {
             assister,
             tick,
             killer: UserId((event.attacker & 255) as u8),
-            weapon: event.weapon,
+            weapon: event.weapon.clone(),
             victim: UserId((event.user_id & 255) as u8),
         }
     }
@@ -156,7 +156,7 @@ pub struct Round {
 }
 
 impl Round {
-    pub fn from_event(event: TeamPlayRoundWinEvent, tick: u32) -> Self {
+    pub fn from_event(event: &TeamPlayRoundWinEvent, tick: u32) -> Self {
         Round {
             winner: Team::new(event.team as u16),
             length: event.round_time,
@@ -191,13 +191,13 @@ impl MessageHandler for Analyser {
         }
     }
 
-    fn handle_message(&mut self, message: Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, tick: u32) {
         if self.start_tick == 0 {
             self.start_tick = tick;
         }
         match message {
-            Message::GameEvent(message) => self.handle_event(message.event, tick),
+            Message::GameEvent(message) => self.handle_event(&message.event, tick),
-            Message::UserMessage(message) => self.handle_user_message(message, tick),
+            Message::UserMessage(message) => self.handle_user_message(&message, tick),
             _ => {}
         }
     }
@@ -233,11 +233,11 @@ impl Analyser {
         Self::default()
     }
 
-    fn handle_user_message(&mut self, message: UserMessage, tick: u32) {
+    fn handle_user_message(&mut self, message: &UserMessage, tick: u32) {
         if let UserMessage::SayText2(text_message) = message {
             if text_message.kind == ChatMessageKind::NameChange {
-                if let Some(from) = text_message.from {
+                if let Some(from) = text_message.from.clone() {
-                    self.change_name(from, text_message.text);
+                    self.change_name(from, text_message.text.clone());
                 }
             } else {
                 self.chat
@@ -252,7 +252,7 @@ impl Analyser {
         }
     }
 
-    fn handle_event(&mut self, event: GameEvent, tick: u32) {
+    fn handle_event(&mut self, event: &GameEvent, tick: u32) {
         const WIN_REASON_TIME_LIMIT: u8 = 6;
 
         match event {

src/demo/parser/handler.rs

@@ -11,7 +11,7 @@ pub trait MessageHandler {
 
     fn does_handle(message_type: MessageType) -> bool;
 
-    fn handle_message(&mut self, message: Message, tick: u32) {}
+    fn handle_message(&mut self, message: &Message, tick: u32) {}
 
     fn handle_string_entry(&mut self, table: &String, index: usize, entries: &StringTableEntry) {}
 
@@ -107,15 +107,10 @@ impl<T: MessageHandler> DemoHandler<T> {
 
     fn handle_message(&mut self, message: Message) {
         let message_type = message.get_message_type();
-        if ParserState::does_handle(message_type) {
+        if T::does_handle(message_type) {
-            if let Some(message) = self.state_handler.handle_message(message, self.tick) {
+            self.analyser.handle_message(&message, self.tick);
-                if T::does_handle(message_type) {
-                    self.analyser.handle_message(message, self.tick);
-                }
-            }
-        } else if T::does_handle(message_type) {
-            self.analyser.handle_message(message, self.tick);
         }
+        self.state_handler.handle_message(message, self.tick);
     }
 
     pub fn get_output(self) -> T::Output {

src/demo/parser/messagetypeanalyser.rs

@@ -26,7 +26,7 @@ impl MessageHandler for MessageTypeAnalyser {
         true
     }
 
-    fn handle_message(&mut self, message: Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, tick: u32) {
         self.packet_types.push(message.get_message_type())
     }
 

src/demo/parser/state.rs

@@ -141,30 +141,17 @@ impl ParserState {
         }
     }
 
-    pub fn handle_message(&mut self, message: Message, _tick: u32) -> Option<Message> {
+    pub fn handle_message(&mut self, message: Message, _tick: u32) {
         match message {
             Message::ServerInfo(message) => {
                 self.demo_meta.version = message.version;
                 self.demo_meta.game = message.game;
                 self.demo_meta.interval_per_tick = message.interval_per_tick;
-                None
             }
             Message::GameEventList(message) => {
                 self.event_definitions = message.event_list;
-                None
             }
             Message::PacketEntities(ent_message) => {
-                if ent_message.updated_base_line {
-                    let old_index = ent_message.base_line as usize;
-                    let new_index = 1 - old_index;
-                    self.instance_baselines.swap(0, 1);
-
-                    for entity in ent_message.entities.iter() {
-                        self.instance_baselines[new_index]
-                            .insert(entity.entity_index, entity.props.clone());
-                    }
-                }
-
                 for removed in ent_message.removed_entities.iter() {
                     self.entity_classes.remove(removed);
                 }
@@ -176,9 +163,19 @@ impl ParserState {
                     self.entity_classes
                         .insert(entity.entity_index, entity.server_class);
                 }
-                Some(Message::PacketEntities(ent_message))
+
+                if ent_message.updated_base_line {
+                    let old_index = ent_message.base_line as usize;
+                    let new_index = 1 - old_index;
+                    self.instance_baselines.swap(0, 1);
+
+                    for entity in ent_message.entities {
+                        self.instance_baselines[new_index]
+                            .insert(entity.entity_index, entity.props);
+                    }
+                }
             }
-            _ => Some(message),
+            _ => {}
         }
     }
 

tests/entity.rs

@@ -95,13 +95,13 @@ impl MessageHandler for EntityDumper {
         }
     }
 
-    fn handle_message(&mut self, message: Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, tick: u32) {
         match message {
             Message::PacketEntities(entity_message) => self.entities.extend(
                 entity_message
                     .entities
-                    .into_iter()
+                    .iter()
-                    .map(|entity| (tick, entity)),
+                    .map(|entity| (tick, entity.clone())),
             ),
             _ => {}
         }