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)
+                }
+            }
+        }
+    }
+}