ahash

Cargo.toml

@@ -19,6 +19,7 @@ main_error = "0.1"
 paste = "1"
 logos = "0.12"
 memchr = "2.5.0"
+ahash = "0.8.3"
 
 [dev-dependencies]
 criterion = "0.4"

benches/bench.rs

@@ -1,7 +1,7 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use std::fs::read_to_string;
 use std::time::Duration;
-use tf_log_parser::{parse, GameEvent, RawEvent, LineSplit};
+use tf_log_parser::{parse, GameEvent, LineSplit, RawEvent};
 
 pub fn parse_benchmark(c: &mut Criterion) {
     let input = read_to_string("test_data/log_2892242.log").unwrap();

benches/iai.rs

@@ -1,5 +1,5 @@
 use iai::black_box;
-use tf_log_parser::{LineSplit, parse, RawEvent};
+use tf_log_parser::{parse, LineSplit, RawEvent};
 
 static LOG: &str = include_str!("../test_data/log_2892242.log");
 

src/common.rs

@@ -1,5 +1,5 @@
 use crate::raw_event::{split_player_subject, RawSubject};
-use enum_iterator::{Sequence, all};
+use enum_iterator::{all, Sequence};
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};
 use std::cmp::Ordering;

src/lib.rs

@@ -9,12 +9,12 @@ use crate::module::{
 pub use crate::subjectmap::SubjectMap;
 use chrono::NaiveDateTime;
 pub use event::{EventMeta, GameEvent};
+use memchr::memmem::{find_iter, FindIter};
 use nom::Err;
 pub use raw_event::{RawEvent, RawEventType};
 use std::collections::BTreeMap;
 use std::convert::TryInto;
 use std::fmt::Debug;
-use memchr::memmem::{find_iter, FindIter};
 use thiserror::Error;
 
 mod common;
@@ -81,7 +81,7 @@ pub fn parse_with_handler<Handler: EventHandler>(
     let mut handler = Handler::default();
 
     let mut start_time: Option<NaiveDateTime> = None;
-    let mut subjects = SubjectMap::<Handler::PerSubjectData>::default();
+    let mut subjects = SubjectMap::<Handler::PerSubjectData>::with_capacity(32);
 
     for event_res in events {
         let raw_event = event_res?;
@@ -141,7 +141,7 @@ impl<'a> LineSplit<'a> {
         LineSplit {
             input,
             start: 0,
-            iter: find_iter(input.as_bytes(), b"L ")
+            iter: find_iter(input.as_bytes(), b"L "),
         }
     }
 }
@@ -155,15 +155,13 @@ impl<'a> Iterator for LineSplit<'a> {
                 let line = &self.input[self.start..next];
                 self.start = next + 2;
                 Some(line)
-            },
+            }
             None if self.start < self.input.len() => {
                 let line = &self.input[self.start..];
                 self.start = self.input.len();
                 Some(line)
             }
-            _ => {
-                None
-            }
+            _ => None,
         }
     }
 }

src/module/classstats.rs

@@ -95,9 +95,7 @@ impl EventHandler for ClassStatsHandler {
         }
     }
 
-    fn finish_global(self, _subjects: &SubjectMap) -> Self::GlobalOutput {
-        
-    }
+    fn finish_global(self, _subjects: &SubjectMap) -> Self::GlobalOutput {}
 
     fn finish_per_subject(
         &mut self,

src/module/mod.rs

@@ -235,7 +235,6 @@ impl<T: GlobalData> EventHandler for T {
         _subject: &SubjectData,
         _data: Self::PerSubjectData,
     ) -> Self::PerSubjectOutput {
-        
     }
 }
 
@@ -269,9 +268,7 @@ impl<T: PlayerSpecificData + Default> EventHandler for PlayerHandler<T> {
         subject_data.handle_event(meta, subject, event)
     }
 
-    fn finish_global(self, _subjects: &SubjectMap) -> Self::GlobalOutput {
-        
-    }
+    fn finish_global(self, _subjects: &SubjectMap) -> Self::GlobalOutput {}
 
     fn finish_per_subject(
         &mut self,

src/raw_event.rs

@@ -3,10 +3,10 @@ use crate::{Error, Result};
 use crate::{SubjectError, SubjectId};
 use chrono::{NaiveDate, NaiveDateTime};
 use logos::{Lexer, Logos};
+use memchr::memchr;
 use nom::{IResult, Needed};
 use std::convert::{TryFrom, TryInto};
 use std::num::ParseIntError;
-use memchr::memchr;
 
 /// Event that has only been minimally parsed.
 /// that way we can decide if we're interested in handling the event before parsing further

src/subjectmap.rs

@@ -1,11 +1,20 @@
 use crate::raw_event::RawSubject;
 use crate::{SubjectData, SubjectError, SubjectId};
-use std::collections::BTreeMap;
+use ahash::{AHashMap, RandomState};
 use std::convert::TryInto;
 use std::ops::{Index, IndexMut};
 
 #[derive(Default)]
-pub struct SubjectMap<T = ()>(BTreeMap<SubjectId, (SubjectData, T)>);
+pub struct SubjectMap<T = ()>(AHashMap<SubjectId, (SubjectData, T)>);
+
+impl<T> SubjectMap<T> {
+    pub fn with_capacity(cap: usize) -> Self {
+        SubjectMap(AHashMap::with_capacity_and_hasher(
+            cap,
+            RandomState::default(),
+        ))
+    }
+}
 
 impl<T> Index<SubjectId> for SubjectMap<T> {
     type Output = (SubjectData, T);
@@ -63,7 +72,7 @@ impl<T> IntoIterator for SubjectMap<T> {
 }
 
 pub struct SubjectMapIter<T> {
-    iter: std::collections::btree_map::IntoIter<SubjectId, (SubjectData, T)>,
+    iter: std::collections::hash_map::IntoIter<SubjectId, (SubjectData, T)>,
 }
 
 impl<T> Iterator for SubjectMapIter<T> {