use more optimized way to store things in state

benches/sendprop.rs

@@ -34,7 +34,7 @@ impl MessageHandler for SendPropAnalyser {
         state
             .send_tables
             .into_iter()
-            .map(|(_, v)| ParseSendTable {
+            .map(|v| ParseSendTable {
                 name: v.name,
                 props: v.props,
                 needs_decoder: v.needs_decoder,

src/demo/message/packetentities.rs

@@ -108,7 +108,7 @@ pub struct PacketEntitiesMessage {
 fn get_send_table(state: &ParserState, class: ClassId) -> Result<&SendTable> {
     state
         .send_tables
-        .get(&class)
+        .get(usize::from(class))
         .ok_or_else(|| MalformedDemoError::UnknownServerClass(class).into())
 }
 
@@ -206,7 +206,7 @@ impl PacketEntitiesMessage {
         let serial = stream.read_sized(10)?;
         let send_table = state
             .send_tables
-            .get(&class_index)
+            .get(usize::from(class_index))
             .ok_or_else(|| MalformedDemoError::UnknownServerClass(class_index))?;
 
         let props = match state.instance_baselines[baseline_index].get(&entity_index) {

src/demo/parser/state.rs

@@ -10,6 +10,7 @@ use crate::demo::packet::stringtable::StringTableEntry;
 use crate::demo::parser::analyser::Analyser;
 use crate::demo::parser::handler::MessageHandler;
 use crate::demo::sendprop::SendProp;
+use crate::nullhasher::NullHasherBuilder;
 use crate::{Result, Stream};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -26,8 +27,8 @@ pub struct ParserState {
     pub parsed_static_baselines: RefCell<HashMap<ClassId, Vec<SendProp>>>,
     pub event_definitions: Vec<GameEventDefinition>,
     pub string_tables: Vec<StringTableMeta>,
-    pub entity_classes: HashMap<EntityId, ClassId>,
+    pub entity_classes: HashMap<EntityId, ClassId, NullHasherBuilder>,
-    pub send_tables: HashMap<ClassId, SendTable>,
+    pub send_tables: Vec<SendTable>, // indexed by ClassId
     pub server_classes: Vec<ServerClass>,
     pub instance_baselines: [HashMap<EntityId, Vec<SendProp>>; 2],
     pub demo_meta: DemoMeta,
@@ -57,8 +58,8 @@ impl ParserState {
             parsed_static_baselines: RefCell::new(HashMap::new()),
             event_definitions: Vec::new(),
             string_tables: Vec::new(),
-            entity_classes: HashMap::new(),
+            entity_classes: HashMap::with_hasher(NullHasherBuilder),
-            send_tables: HashMap::new(),
+            send_tables: Vec::new(),
             server_classes: Vec::new(),
             instance_baselines: [HashMap::new(), HashMap::new()],
             demo_meta: DemoMeta::default(),
@@ -99,9 +100,14 @@ impl ParserState {
 
         self.send_tables.reserve(self.server_classes.len());
 
+        let mut last: usize = 0;
+
         for class in self.server_classes.iter() {
+            assert_eq!(usize::from(class.id), last);
+            last += 1;
+
             if let Some(table) = send_tables.remove(&class.data_table) {
-                self.send_tables.insert(class.id, table);
+                self.send_tables.push(table);
             }
         }
     }

src/lib.rs

@@ -14,3 +14,4 @@ pub use crate::demo::{
 };
 
 pub mod demo;
+mod nullhasher;

src/nullhasher.rs

@@ -0,0 +1,40 @@
+use std::hash::{BuildHasher, Hasher};
+
+/// A dummy hasher that maps simply returns the hashed u64
+///
+/// trying to hash anything but a u64 will result in a panic
+pub struct NullHasher {
+    data: u64,
+}
+
+impl Hasher for NullHasher {
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.data
+    }
+
+    #[inline]
+    fn write(&mut self, _msg: &[u8]) {
+        panic!("can only hash u64 as u32");
+    }
+
+    #[inline]
+    fn write_u32(&mut self, data: u32) {
+        self.data = data as u64
+    }
+
+    #[inline]
+    fn write_u64(&mut self, data: u64) {
+        self.data = data;
+    }
+}
+
+pub struct NullHasherBuilder;
+
+impl BuildHasher for NullHasherBuilder {
+    type Hasher = NullHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        NullHasher { data: 0 }
+    }
+}