parser api wip

benches/allmessages.rs

@@ -30,7 +30,7 @@ impl MessageHandler for AllMessages {
         test::black_box(message);
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         test::black_box(true)
     }
 }
@@ -41,7 +41,7 @@ fn bench_all(input_file: &str, b: &mut Bencher) {
     let stream = demo.get_stream();
     b.iter(|| {
         let _ =
-            test::black_box(DemoParser::parse_with_analyser(stream.clone(), AllMessages).unwrap());
+            test::black_box(DemoParser::new_with_analyser(stream.clone(), AllMessages).unwrap());
     });
 }
 

benches/bench.rs

@@ -13,7 +13,7 @@ fn bench_file(input_file: &str, b: &mut Bencher) {
     let stream: Stream = demo.get_stream();
 
     b.iter(|| {
-        let (_, state) = DemoParser::parse_demo(stream.clone()).unwrap();
+        let (_, state) = DemoParser::new(stream.clone()).unwrap();
         test::black_box(state);
     })
 }

benches/sendprop.rs

@@ -26,7 +26,7 @@ impl MessageHandler for SendPropAnalyser {
         false
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(&self, state: &ParserState) -> Self::Output {
         state
             .send_tables
             .iter()
@@ -43,8 +43,7 @@ fn flatten_bench(input_file: &str, b: &mut Bencher) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
     let stream = demo.get_stream();
-    let (_, send_tables) =
-        DemoParser::parse_with_analyser(stream.clone(), SendPropAnalyser).unwrap();
+    let (_, send_tables) = DemoParser::new_with_analyser(stream.clone(), SendPropAnalyser).unwrap();
     b.iter(|| {
         let flat: Vec<_> = send_tables
             .iter()

src/bin/main.rs

@@ -24,11 +24,12 @@ fn main() -> Result<(), MainError> {
         .unwrap_or_default();
     let file = fs::read(path)?;
     let demo = Demo::new(file);
-    let (_, state) = if all {
-        DemoParser::parse_all(demo.get_stream())
+    let parser = if all {
+        DemoParser::new_all(demo.get_stream())
     } else {
-        DemoParser::parse_demo(demo.get_stream())
-    }?;
+        DemoParser::new(demo.get_stream())
+    };
+    let (_, state) = parser.parse()?;
     println!("{}", serde_json::to_string(&state)?);
     Ok(())
 }

src/demo/parser/analyser.rs

@@ -277,7 +277,7 @@ impl MessageHandler for Analyser {
         }
     }
 
-    fn get_output(self, state: &ParserState) -> MatchState {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         self.state
     }
 }

src/demo/parser/gamestateanalyser.rs

@@ -166,7 +166,7 @@ impl MessageHandler for GameStateAnalyser {
             .collect();
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         self.state
     }
 }

src/demo/parser/handler.rs

@@ -17,7 +17,7 @@ pub trait MessageHandler {
 
     fn handle_data_tables(&mut self, tables: &[ParseSendTable], server_classes: &[ServerClass]) {}
 
-    fn get_output(self, state: &ParserState) -> Self::Output;
+    fn into_output(self, state: &ParserState) -> Self::Output;
 }
 
 pub struct MultiplexMessageHandler<A: MessageHandler, B: MessageHandler> {
@@ -47,10 +47,10 @@ impl<A: MessageHandler, B: MessageHandler> MessageHandler for MultiplexMessageHa
         self.handler_b.handle_data_tables(tables, server_classes);
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         (
-            self.handler_a.get_output(state),
-            self.handler_b.get_output(state),
+            self.handler_a.into_output(state),
+            self.handler_b.into_output(state),
         )
     }
 }
@@ -169,8 +169,8 @@ impl<T: MessageHandler> DemoHandler<T> {
         self.state_handler.handle_message(message, self.tick);
     }
 
-    pub fn get_output(self) -> T::Output {
-        self.analyser.get_output(&self.state_handler)
+    pub fn into_output(self) -> T::Output {
+        self.analyser.into_output(&self.state_handler)
     }
 
     pub fn get_parser_state(&self) -> &ParserState {

src/demo/parser/messagetypeanalyser.rs

@@ -31,7 +31,7 @@ impl MessageHandler for MessageTypeAnalyser {
         self.packet_types.push(message.get_message_type())
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         self.packet_types
     }
 }

src/demo/parser/mod.rs

@@ -43,49 +43,45 @@ impl<T: BitSkip<LittleEndian>> ParseBitSkip for T {
     }
 }
 
-pub struct DemoParser {}
-
-impl DemoParser {
-    pub fn parse_demo(stream: Stream) -> Result<(Header, MatchState)> {
-        Self::parse_with_analyser(stream, Analyser::new())
-    }
-
-    pub fn parse_all(stream: Stream) -> Result<(Header, MatchState)> {
-        Self::parse_all_with_analyser(stream, Analyser::new())
-    }
-
-    pub fn parse_with_analyser<T: MessageHandler>(
+pub struct DemoParser<A: MessageHandler> {
+    handler: DemoHandler<A>,
     stream: Stream,
-        analyser: T,
-    ) -> Result<(Header, T::Output)> {
-        Self::parse(stream, analyser, false)
 }
 
-    pub fn parse_all_with_analyser<T: MessageHandler>(
-        stream: Stream,
-        analyser: T,
-    ) -> Result<(Header, T::Output)> {
-        Self::parse(stream, analyser, true)
+impl DemoParser<Analyser> {
+    pub fn new(stream: Stream) -> DemoParser<Analyser> {
+        DemoParser::new_with_analyser(stream, Analyser::new())
     }
 
-    fn parse<T: MessageHandler>(
-        mut stream: Stream,
-        analyser: T,
-        all: bool,
-    ) -> Result<(Header, T::Output)> {
-        let mut handler = if all {
-            DemoHandler::parse_all_with_analyser(analyser)
-        } else {
-            DemoHandler::with_analyser(analyser)
-        };
-        let header = Header::read(&mut stream)?;
+    pub fn new_all(stream: Stream) -> DemoParser<Analyser> {
+        DemoParser::new_all_with_analyser(stream, Analyser::new())
+    }
+}
+
+impl<A: MessageHandler> DemoParser<A> {
+    pub fn new_with_analyser(stream: Stream, analyser: A) -> DemoParser<A> {
+        DemoParser {
+            handler: DemoHandler::with_analyser(analyser),
+            stream,
+        }
+    }
+
+    pub fn new_all_with_analyser(stream: Stream, analyser: A) -> DemoParser<A> {
+        DemoParser {
+            handler: DemoHandler::parse_all_with_analyser(analyser),
+            stream,
+        }
+    }
+
+    pub fn parse(mut self) -> Result<(Header, A::Output)> {
+        let header = Header::read(&mut self.stream)?;
         loop {
-            let packet = Packet::parse(&mut stream, handler.get_parser_state())?;
+            let packet = Packet::parse(&mut self.stream, self.handler.get_parser_state())?;
             match packet {
                 Packet::Stop(_) => break,
-                packet => handler.handle_packet(packet),
+                packet => self.handler.handle_packet(packet),
             };
         }
-        Ok((header, handler.get_output()))
+        Ok((header, self.handler.into_output()))
     }
 }

tests/entity.rs

@@ -107,7 +107,7 @@ impl MessageHandler for EntityDumper {
         }
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         self.entities
             .into_iter()
             .map(|(tick, entity)| EntityDump::from_entity(entity, tick, &state.server_classes))
@@ -119,7 +119,7 @@ fn entity_test(input_file: &str, snapshot_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
     let (_, entities) =
-        DemoParser::parse_with_analyser(demo.get_stream(), EntityDumper::new()).unwrap();
+        DemoParser::new_with_analyser(demo.get_stream(), EntityDumper::new()).unwrap();
 
     let json_file = File::open(snapshot_file).expect("Unable to read file");
     let mut reader = BufReader::new(json_file);

tests/sendprops.rs

@@ -36,7 +36,7 @@ impl MessageHandler for SendPropAnalyser {
         self.tables = tables.to_vec()
     }
 
-    fn get_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, state: &ParserState) -> Self::Output {
         self.tables
     }
 }
@@ -45,7 +45,7 @@ fn flatten_test(input_file: &str, snapshot_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
     let (_, send_tables) =
-        DemoParser::parse_with_analyser(demo.get_stream(), SendPropAnalyser::new())
+        DemoParser::new_with_analyser(demo.get_stream(), SendPropAnalyser::new())
             .expect("Failed to parse");
     let flat_props: HashMap<SendTableName, Vec<String>> = send_tables
         .iter()

tests/tests.rs

@@ -7,7 +7,7 @@ use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnaly
 fn snapshot_test(input_file: &str, snapshot_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
-    let (_, state) = DemoParser::parse_demo(demo.get_stream()).unwrap();
+    let (_, state) = DemoParser::new(demo.get_stream()).unwrap();
 
     let expected: MatchState = serde_json::from_slice(
         fs::read(snapshot_file)
@@ -22,7 +22,7 @@ fn test_message_types(input_file: &str, snapshot_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
     let (_, message_types) =
-        DemoParser::parse_with_analyser(demo.get_stream(), MessageTypeAnalyser::default()).unwrap();
+        DemoParser::new_with_analyser(demo.get_stream(), MessageTypeAnalyser::default()).unwrap();
 
     let expected: Vec<MessageType> = serde_json::from_slice(
         fs::read(snapshot_file)
@@ -37,7 +37,7 @@ fn game_state_test(input_file: &str, snapshot_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(file);
     let (_, state) =
-        DemoParser::parse_with_analyser(demo.get_stream(), GameStateAnalyser::new()).unwrap();
+        DemoParser::new_with_analyser(demo.get_stream(), GameStateAnalyser::new()).unwrap();
 
     let expected: GameState = serde_json::from_slice(
         fs::read(snapshot_file)