parser api wip

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 {}
+pub struct DemoParser<A: MessageHandler> {
+    handler: DemoHandler<A>,
+    stream: Stream,
+}
 
-impl DemoParser {
-    pub fn parse_demo(stream: Stream) -> Result<(Header, MatchState)> {
-        Self::parse_with_analyser(stream, Analyser::new())
+impl DemoParser<Analyser> {
+    pub fn new(stream: Stream) -> DemoParser<Analyser> {
+        DemoParser::new_with_analyser(stream, Analyser::new())
     }
 
-    pub fn parse_all(stream: Stream) -> Result<(Header, MatchState)> {
-        Self::parse_all_with_analyser(stream, Analyser::new())
+    pub fn new_all(stream: Stream) -> DemoParser<Analyser> {
+        DemoParser::new_all_with_analyser(stream, Analyser::new())
     }
+}
 
-    pub fn parse_with_analyser<T: MessageHandler>(
-        stream: Stream,
-        analyser: T,
-    ) -> Result<(Header, T::Output)> {
-        Self::parse(stream, analyser, false)
+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 parse_all_with_analyser<T: MessageHandler>(
-        stream: Stream,
-        analyser: T,
-    ) -> Result<(Header, T::Output)> {
-        Self::parse(stream, analyser, true)
+    pub fn new_all_with_analyser(stream: Stream, analyser: A) -> DemoParser<A> {
+        DemoParser {
+            handler: DemoHandler::parse_all_with_analyser(analyser),
+            stream,
+        }
     }
 
-    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 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()))
     }
 }