remove the need to allocate all messages in a packet

src/demo/message/mod.rs

@@ -101,7 +101,7 @@ pub enum Message<'a> {
 }
 
 impl<'a> Parse<'a> for Message<'a> {
-    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState<'a>) -> Result<Self> {
         let message_type = MessageType::parse(stream, state)?;
         Self::from_type(message_type, stream, state)
     }
@@ -144,7 +144,7 @@ impl<'a> Message<'a> {
     pub fn from_type(
         message_type: MessageType,
         stream: &mut Stream<'a>,
-        state: &ParserState,
+        state: &ParserState<'a>,
     ) -> Result<Self> {
         Ok(match message_type {
             MessageType::Empty => Message::Empty,

src/demo/message/stringtable.rs

@@ -31,7 +31,7 @@ impl From<&StringTable<'_>> for StringTableMeta {
 }
 
 impl<'a> Parse<'a> for CreateStringTableMessage<'a> {
-    fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, _state: &ParserState<'a>) -> Result<Self> {
         let name = stream.read()?;
         let max_entries: u16 = stream.read()?;
         let encode_bits = log_base2(max_entries);
@@ -116,7 +116,7 @@ pub struct UpdateStringTableMessage<'a> {
 }
 
 impl<'a> Parse<'a> for UpdateStringTableMessage<'a> {
-    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState<'a>) -> Result<Self> {
         let table_id = stream.read_sized(5)?;
 
         let changed: u16 = if stream.read()? { stream.read()? } else { 1 };

src/demo/packet/message.rs

@@ -3,6 +3,7 @@ use bitbuffer::{bit_size_of, BitRead, Endianness, LazyBitRead, LittleEndian};
 use crate::demo::message::{Message, MessageType};
 use crate::demo::vector::Vector;
 use crate::{Parse, ParserState, ReadResult, Result, Stream};
+use std::fmt;
 
 #[derive(Debug, BitRead)]
 pub struct MessagePacketMeta {
@@ -15,7 +16,7 @@ pub struct MessagePacketMeta {
 #[derive(Debug)]
 pub struct MessagePacket<'a> {
     pub tick: u32,
-    pub messages: Vec<Message<'a>>,
+    pub messages: MessageIterator<'a>,
     pub meta: LazyBitRead<'a, MessagePacketMeta, LittleEndian>,
 }
 
@@ -47,25 +48,15 @@ impl<E: Endianness> BitRead<'_, E> for ViewAngles {
 }
 
 impl<'a> Parse<'a> for MessagePacket<'a> {
-    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
         let tick = stream.read()?;
 
         let meta = stream.read()?;
 
         let length: u32 = stream.read()?;
-        let mut packet_data = stream.read_bits(length as usize * 8)?;
+        let packet_data = stream.read_bits(length as usize * 8)?;
 
-        let mut messages: Vec<Message> = Vec::with_capacity(10);
-        while packet_data.bits_left() > 6 {
-            let message_type = MessageType::parse(&mut packet_data, state)?;
-
-            if state.should_parse_message(message_type) {
-                let message = Message::from_type(message_type, &mut packet_data, state)?;
-                messages.push(message);
-            } else {
-                Message::skip_type(message_type, &mut packet_data)?;
-            }
-        }
+        let messages = MessageIterator::new(packet_data);
 
         let packet = MessagePacket {
             tick,
@@ -75,3 +66,42 @@ impl<'a> Parse<'a> for MessagePacket<'a> {
         Ok(packet)
     }
 }
+
+pub struct MessageIterator<'a> {
+    packet_data: Stream<'a>,
+}
+
+impl fmt::Debug for MessageIterator<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "MessageIterator {{}}")
+    }
+}
+
+impl<'a> MessageIterator<'a> {
+    fn new(packet_data: Stream<'a>) -> Self {
+        MessageIterator { packet_data }
+    }
+
+    pub fn next(&mut self, state: &ParserState<'a>) -> Option<Result<Message<'a>>> {
+        while self.packet_data.bits_left() > 6 {
+            let message_type = match MessageType::parse(&mut self.packet_data, state) {
+                Ok(message_type) => message_type,
+                Err(e) => return Some(Err(e)),
+            };
+
+            if state.should_parse_message(message_type) {
+                return Some(Message::from_type(
+                    message_type,
+                    &mut self.packet_data,
+                    state,
+                ));
+            } else {
+                match Message::skip_type(message_type, &mut self.packet_data) {
+                    Ok(_) => (),
+                    Err(e) => return Some(Err(e)),
+                }
+            }
+        }
+        None
+    }
+}

src/demo/packet/mod.rs

@@ -46,7 +46,7 @@ pub enum PacketType {
 }
 
 impl<'a> Parse<'a> for Packet<'a> {
-    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState<'a>) -> Result<Self> {
         let packet_type = PacketType::read(stream)?;
         Ok(match packet_type {
             PacketType::Sigon => Packet::Sigon(MessagePacket::parse(stream, state)?),

src/demo/parser/handler.rs

@@ -3,6 +3,7 @@ use crate::demo::packet::datatable::{ParseSendTable, ServerClass};
 use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::packet::Packet;
 use crate::demo::parser::analyser::Analyser;
+use crate::Result;
 
 use crate::ParserState;
 use std::borrow::Cow;
@@ -29,7 +30,7 @@ pub struct DemoHandler<'a, T: MessageHandler> {
     pub tick: u32,
     string_table_names: Vec<Cow<'a, str>>,
     analyser: T,
-    state_handler: ParserState<'a>,
+    pub state_handler: ParserState<'a>,
 }
 
 impl<'a> DemoHandler<'a, Analyser> {
@@ -66,7 +67,7 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
         }
     }
 
-    pub fn handle_packet(&mut self, packet: Packet<'a>) {
+    pub fn handle_packet(&mut self, packet: Packet<'a>) -> Result<()> {
         match packet {
             Packet::DataTables(packet) => {
                 self.handle_data_table(packet.tables, packet.server_classes);
@@ -76,10 +77,10 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
                     self.handle_string_table(table)
                 }
             }
-            Packet::Message(packet) | Packet::Sigon(packet) => {
+            Packet::Message(mut packet) | Packet::Sigon(mut packet) => {
                 //self.tick = packet.tick;
-                for message in packet.messages {
-                    match message {
+                while let Some(message) = packet.messages.next(&self.state_handler) {
+                    match message? {
                         Message::NetTick(message) => self.tick = message.tick,
                         Message::CreateStringTable(message) => {
                             self.handle_string_table(*message.table)
@@ -87,12 +88,13 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
                         Message::UpdateStringTable(message) => {
                             self.handle_table_update(message.table_id, message.entries)
                         }
-                        _ => self.handle_message(message),
+                        message => self.handle_message(message),
                     }
                 }
             }
             _ => {}
-        }
+        };
+        Ok(())
     }
 
     fn handle_string_table(&mut self, table: StringTable<'a>) {
@@ -143,7 +145,7 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
         self.analyser.into_output(&self.state_handler)
     }
 
-    pub fn get_parser_state(&self) -> &ParserState<'a> {
+    pub fn get_parser_state(&'a self) -> &ParserState<'a> {
         &self.state_handler
     }
 }

src/demo/parser/mod.rs

@@ -22,11 +22,11 @@ pub use self::error::*;
 use crate::demo::parser::handler::BorrowMessageHandler;
 
 pub trait Parse<'a>: Sized {
-    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self>;
+    fn parse(stream: &mut Stream<'a>, state: &ParserState<'a>) -> Result<Self>;
 }
 
 impl<'a, T: BitRead<'a, LittleEndian>> Parse<'a> for T {
-    fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream<'a>, _state: &ParserState<'a>) -> Result<Self> {
         Self::read(stream).map_err(ParseError::from)
     }
 }
@@ -105,7 +105,7 @@ impl<'a> RawPacketStream<'a> {
         }
     }
 
-    pub fn next(&mut self, state: &ParserState) -> Result<Option<Packet<'a>>> {
+    pub fn next(&mut self, state: &ParserState<'a>) -> Result<Option<Packet<'a>>> {
         if self.ended {
             Ok(None)
         } else {
@@ -135,8 +135,8 @@ impl<'a, A: MessageHandler> DemoTicker<'a, A> {
     /// returns whether or not there are still packets left in the demo
     pub fn tick(&mut self) -> Result<bool> {
         Ok(
-            if let Some(packet) = self.packets.next(self.handler.get_parser_state())? {
-                self.handler.handle_packet(packet);
+            if let Some(packet) = self.packets.next(&self.handler.state_handler)? {
+                self.handler.handle_packet(packet)?;
 
                 true
             } else {