minor cleanup

src/demo/message/gameevent.rs

@@ -9,7 +9,7 @@ use crate::demo::gamevent::{
     RawGameEvent,
 };
 use crate::demo::parser::ParseBitSkip;
-use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
+use crate::{GameEventError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
 
 fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<GameEventValue> {
     Ok(match definition.kind {
@@ -20,7 +20,9 @@ fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<
         GameEventValueType::Byte => GameEventValue::Byte(stream.read()?),
         GameEventValueType::Boolean => GameEventValue::Boolean(stream.read()?),
         GameEventValueType::Local => GameEventValue::Local,
-        GameEventValueType::None => unreachable!(),
+        GameEventValueType::None => {
+            return Err(ParseError::MalformedGameEvent(GameEventError::NoneValue))
+        }
     })
 }
 
@@ -46,7 +48,7 @@ impl Parse for GameEventMessage {
                     values,
                 }
             }
-            None => unreachable!(),
+            None => return Err(ParseError::MalformedGameEvent(GameEventError::UnknownType)),
         };
         let event = GameEvent::from_raw_event(raw_event)?;
         Ok(GameEventMessage { event })

src/demo/parser/analyser.rs

@@ -198,16 +198,14 @@ impl MessageHandler for Analyser {
 
     fn handle_string_entry(&mut self, table: &String, _index: usize, entry: &StringTableEntry) {
         match table.as_str() {
-            "userinfo" => {
+            "userinfo" => match (&entry.text, &entry.extra_data) {
-                match (&entry.text, &entry.extra_data) {
                 (Some(text), Some(data)) => {
                     if data.byte_len > 32 {
                         let _ = self.parse_user_info(text, data.data.clone());
                     }
                 }
-                    _ => {} //unreachable!("no userdata {}, {}", table, &entry.text)
+                _ => {}
-                }
+            },
-            }
             _ => {}
         }
     }

src/demo/parser/handler.rs

@@ -76,21 +76,22 @@ impl<T: MessageHandler> DemoHandler<T> {
         self.state_handler
             .handle_string_table_meta(table.get_table_meta());
         for (entry_index, entry) in table.entries.into_iter().enumerate() {
-            self.handle_string_entry(&table.name, entry_index, entry);
+            self.state_handler
+                .handle_string_entry(&table.name, entry_index, &entry);
+            self.analyser
+                .handle_string_entry(&table.name, entry_index, &entry);
         }
     }
 
     fn handle_table_update(&mut self, table_id: u8, entries: Vec<(u16, StringTableEntry)>) {
-        let table_name = self.string_table_names.get(table_id as usize);
+        if let Some(table_name) = self.string_table_names.get(table_id as usize) {
-        match table_name {
-            Some(table_name) => {
-                let table_name = table_name.clone();
             for (index, entry) in entries {
-                    self.handle_string_entry(&table_name, index as usize, entry);
+                let index = index as usize;
+                self.state_handler
+                    .handle_string_entry(table_name, index, &entry);
+                self.analyser.handle_string_entry(table_name, index, &entry);
             }
         }
-            _ => unreachable!("trying to update non existing table"),
-        }
     }
 
     fn handle_data_table(&mut self, send_tables: Vec<SendTable>, server_classes: Vec<ServerClass>) {
@@ -98,12 +99,6 @@ impl<T: MessageHandler> DemoHandler<T> {
             .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.analyser.handle_string_entry(table, index, &entries);
-    }
-
     fn handle_message(&mut self, message: Message) {
         let message_type = message.get_message_type();
         if ParserState::does_handle(message_type) {

src/demo/parser/mod.rs

@@ -60,6 +60,8 @@ pub enum ParseError {
 #[derive(Debug)]
 pub enum GameEventError {
     IncorrectValueCount,
+    NoneValue,
+    UnknownType,
 }
 
 impl From<ReadError> for ParseError {

src/demo/parser/state.rs

@@ -119,7 +119,7 @@ impl MessageHandler for ParserState {
                     }
                     Err(_) => {}
                 },
-                _ => unreachable!("missing baseline"),
+                _ => {}
             },
             _ => {}
         }