finish api changes and rawpacketstream

src/demo/parser/analyser.rs

@@ -10,7 +10,7 @@ use crate::demo::message::packetentities::EntityId;
 use crate::demo::message::usermessage::{ChatMessageKind, SayText2Message, UserMessage};
 use crate::demo::message::{Message, MessageType};
 use crate::demo::packet::stringtable::StringTableEntry;
-use crate::demo::parser::handler::MessageHandler;
+use crate::demo::parser::handler::{BorrowMessageHandler, MessageHandler};
 use crate::demo::vector::Vector;
 use crate::{ParserState, ReadResult, Stream};
 use num_enum::TryFromPrimitive;
@@ -282,6 +282,12 @@ impl MessageHandler for Analyser {
     }
 }
 
+impl BorrowMessageHandler for Analyser {
+    fn borrow_output(&self, state: &ParserState) -> &Self::Output {
+        &self.state
+    }
+}
+
 impl Analyser {
     pub fn new() -> Self {
         Self::default()

src/demo/parser/gamestateanalyser.rs

@@ -3,6 +3,7 @@ use crate::demo::message::packetentities::{EntityId, PacketEntity};
 use crate::demo::message::Message;
 use crate::demo::packet::datatable::{ParseSendTable, SendTableName, ServerClass, ServerClassName};
 use crate::demo::parser::analyser::{Class, Team, UserId};
+use crate::demo::parser::handler::BorrowMessageHandler;
 use crate::demo::parser::MessageHandler;
 use crate::demo::vector::{Vector, VectorXY};
 use crate::{MessageType, ParserState};
@@ -171,6 +172,12 @@ impl MessageHandler for GameStateAnalyser {
     }
 }
 
+impl BorrowMessageHandler for GameStateAnalyser {
+    fn borrow_output(&self, state: &ParserState) -> &Self::Output {
+        &self.state
+    }
+}
+
 impl GameStateAnalyser {
     pub fn new() -> Self {
         Self::default()

src/demo/parser/handler.rs

@@ -3,7 +3,8 @@ use crate::demo::packet::datatable::{ParseSendTable, SendTable, ServerClass};
 use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::packet::Packet;
 use crate::demo::parser::analyser::Analyser;
-use crate::ParserState;
+use crate::demo::parser::Parse;
+use crate::{ParseError, ParserState, Stream};
 use std::rc::Rc;
 
 pub trait MessageHandler {
@@ -20,6 +21,10 @@ pub trait MessageHandler {
     fn into_output(self, state: &ParserState) -> Self::Output;
 }
 
+pub trait BorrowMessageHandler: MessageHandler {
+    fn borrow_output(&self, state: &ParserState) -> &Self::Output;
+}
+
 pub struct MultiplexMessageHandler<A: MessageHandler, B: MessageHandler> {
     handler_a: A,
     handler_b: B,
@@ -177,3 +182,9 @@ impl<T: MessageHandler> DemoHandler<T> {
         &self.state_handler
     }
 }
+
+impl<T: MessageHandler + BorrowMessageHandler> DemoHandler<T> {
+    pub fn borrow_output(&self) -> &T::Output {
+        self.analyser.borrow_output(&self.state_handler)
+    }
+}

src/demo/parser/mod.rs

@@ -21,6 +21,8 @@ mod messagetypeanalyser;
 mod state;
 
 pub use self::error::*;
+use crate::demo::parser::handler::BorrowMessageHandler;
+use serde::export::PhantomData;
 
 pub trait Parse: Sized {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self>;
@@ -75,13 +77,42 @@ impl<A: MessageHandler> DemoParser<A> {
 
     pub fn parse(mut self) -> Result<(Header, A::Output)> {
         let header = Header::read(&mut self.stream)?;
-        loop {
-            let packet = Packet::parse(&mut self.stream, self.handler.get_parser_state())?;
-            match packet {
-                Packet::Stop(_) => break,
-                packet => self.handler.handle_packet(packet),
-            };
+        let mut packets = RawPacketStream::new(self.stream);
+        while let Some(packet) = packets.next(self.handler.get_parser_state())? {
+            self.handler.handle_packet(packet)
         }
         Ok((header, self.handler.into_output()))
     }
 }
+
+pub struct RawPacketStream {
+    stream: Stream,
+    ended: bool,
+}
+
+impl RawPacketStream {
+    pub fn new(stream: Stream) -> Self {
+        RawPacketStream {
+            stream,
+            ended: false,
+        }
+    }
+
+    pub fn next(&mut self, state: &ParserState) -> Result<Option<Packet>> {
+        if self.ended {
+            Ok(None)
+        } else {
+            match Packet::parse(&mut self.stream, state) {
+                Ok(Packet::Stop(_)) => {
+                    self.ended = true;
+                    Ok(None)
+                }
+                Ok(packet) => Ok(Some(packet)),
+                Err(e) => {
+                    self.ended = true;
+                    Err(e)
+                }
+            }
+        }
+    }
+}

tests/entity.rs

@@ -118,8 +118,9 @@ impl MessageHandler for EntityDumper {
 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::new_with_analyser(demo.get_stream(), EntityDumper::new()).unwrap();
+    let (_, entities) = DemoParser::new_with_analyser(demo.get_stream(), EntityDumper::new())
+        .parse()
+        .unwrap();
 
     let json_file = File::open(snapshot_file).expect("Unable to read file");
     let mut reader = BufReader::new(json_file);

tests/sendprops.rs

@@ -46,6 +46,7 @@ fn flatten_test(input_file: &str, snapshot_file: &str) {
     let demo = Demo::new(file);
     let (_, send_tables) =
         DemoParser::new_with_analyser(demo.get_stream(), SendPropAnalyser::new())
+            .parse()
             .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::new(demo.get_stream()).unwrap();
+    let (_, state) = DemoParser::new(demo.get_stream()).parse().unwrap();
 
     let expected: MatchState = serde_json::from_slice(
         fs::read(snapshot_file)
@@ -22,7 +22,9 @@ 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::new_with_analyser(demo.get_stream(), MessageTypeAnalyser::default()).unwrap();
+        DemoParser::new_with_analyser(demo.get_stream(), MessageTypeAnalyser::default())
+            .parse()
+            .unwrap();
 
     let expected: Vec<MessageType> = serde_json::from_slice(
         fs::read(snapshot_file)
@@ -36,8 +38,9 @@ fn test_message_types(input_file: &str, snapshot_file: &str) {
 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::new_with_analyser(demo.get_stream(), GameStateAnalyser::new()).unwrap();
+    let (_, state) = DemoParser::new_with_analyser(demo.get_stream(), GameStateAnalyser::new())
+        .parse()
+        .unwrap();
 
     let expected: GameState = serde_json::from_slice(
         fs::read(snapshot_file)