message write

src/demo/message/gameevent.rs

@@ -204,9 +204,7 @@ impl BitWrite<LittleEndian> for GameEventListMessage {
                 event.write(stream)?;
             }
             Ok(())
-        })?;
-
-        Ok(())
+        })
     }
 }
 

src/demo/message/mod.rs

@@ -1,5 +1,4 @@
 use num_enum::TryFromPrimitive;
-use std::convert::TryFrom;
 
 pub use generated::*;
 
@@ -14,8 +13,9 @@ use crate::demo::message::stringtable::*;
 use crate::demo::message::tempentities::*;
 use crate::demo::message::usermessage::*;
 use crate::demo::message::voice::*;
-use crate::demo::parser::ParseBitSkip;
-use crate::{Parse, ParseError, ParserState, Result, Stream};
+use crate::demo::parser::{Encode, ParseBitSkip};
+use crate::{Parse, ParserState, Result, Stream};
+use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
 
 pub mod bspdecal;
 pub mod classinfo;
@@ -28,8 +28,20 @@ pub mod tempentities;
 pub mod usermessage;
 pub mod voice;
 
-#[derive(TryFromPrimitive, Debug, Clone, Copy, PartialEq, Eq, Serialize_repr, Deserialize_repr)]
+#[derive(
+    TryFromPrimitive,
+    BitRead,
+    BitWrite,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Serialize_repr,
+    Deserialize_repr,
+)]
 #[repr(u8)]
+#[discriminant_bits = 6]
 pub enum MessageType {
     Empty = 0,
     File = 2,
@@ -61,13 +73,6 @@ pub enum MessageType {
     CmdKeyValues = 32,
 }
 
-impl Parse<'_> for MessageType {
-    fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
-        let raw = stream.read_int(6)?;
-        MessageType::try_from(raw).map_err(|_| ParseError::InvalidMessageType(raw))
-    }
-}
-
 #[derive(Debug)]
 pub enum Message<'a> {
     Empty,
@@ -233,3 +238,38 @@ impl<'a> Message<'a> {
         }
     }
 }
+
+impl Encode for Message<'_> {
+    fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
+        match self {
+            Message::Empty => Ok(()),
+            Message::File(message) => message.encode(stream, state),
+            Message::NetTick(message) => message.encode(stream, state),
+            Message::StringCmd(message) => message.encode(stream, state),
+            Message::SetConVar(message) => message.encode(stream, state),
+            Message::SigOnState(message) => message.encode(stream, state),
+            Message::Print(message) => message.encode(stream, state),
+            Message::ServerInfo(message) => message.encode(stream, state),
+            Message::ClassInfo(message) => message.encode(stream, state),
+            Message::SetPause(message) => message.encode(stream, state),
+            Message::CreateStringTable(message) => message.encode(stream, state),
+            Message::UpdateStringTable(message) => message.encode(stream, state),
+            Message::VoiceInit(message) => message.encode(stream, state),
+            Message::VoiceData(message) => message.encode(stream, state),
+            Message::ParseSounds(message) => message.encode(stream, state),
+            Message::SetView(message) => message.encode(stream, state),
+            Message::FixAngle(message) => message.encode(stream, state),
+            Message::BspDecal(message) => message.encode(stream, state),
+            Message::UserMessage(message) => message.encode(stream, state),
+            Message::EntityMessage(message) => message.encode(stream, state),
+            Message::GameEvent(message) => message.encode(stream, state),
+            Message::PacketEntities(message) => message.encode(stream, state),
+            Message::TempEntities(message) => message.encode(stream, state),
+            Message::PreFetch(message) => message.encode(stream, state),
+            Message::Menu(message) => message.encode(stream, state),
+            Message::GameEventList(message) => message.encode(stream, state),
+            Message::GetCvarValue(message) => message.encode(stream, state),
+            Message::CmdKeyValues(message) => message.encode(stream, state),
+        }
+    }
+}

src/demo/message/packetentities.rs

@@ -5,10 +5,7 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 use crate::demo::message::stringtable::log_base2;
 use crate::demo::packet::datatable::{ClassId, SendTable};
 use crate::demo::parser::{Encode, ParseBitSkip};
-use crate::demo::sendprop::{
-    FloatDefinition, SendProp, SendPropDefinition, SendPropIdentifier, SendPropParseDefinition,
-    SendPropValue,
-};
+use crate::demo::sendprop::{SendProp, SendPropIdentifier, SendPropValue};
 use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use parse_display::{Display, FromStr};
 use std::cmp::min;
@@ -452,6 +449,7 @@ impl ParseBitSkip<'_> for PacketEntitiesMessage {
 #[test]
 fn test_packet_entitier_message_roundtrip() {
     use crate::demo::packet::datatable::{SendTable, SendTableName, ServerClass, ServerClassName};
+    use crate::demo::sendprop::{FloatDefinition, SendPropDefinition, SendPropParseDefinition};
 
     let mut state = ParserState::new(|_| false, false);
     state.server_classes = vec![

src/demo/packet/message.rs

@@ -1,9 +1,11 @@
-use bitbuffer::{bit_size_of, BitRead, BitWrite, Endianness, LazyBitRead, LittleEndian};
+use bitbuffer::{
+    bit_size_of, BitRead, BitWrite, BitWriteStream, Endianness, LazyBitRead, LittleEndian,
+};
 
 use crate::demo::message::{Message, MessageType};
+use crate::demo::parser::Encode;
 use crate::demo::vector::Vector;
 use crate::{Parse, ParserState, ReadResult, Result, Stream};
-use std::fmt;
 
 #[derive(Debug, BitRead, BitWrite)]
 pub struct MessagePacketMeta {
@@ -16,7 +18,7 @@ pub struct MessagePacketMeta {
 #[derive(Debug)]
 pub struct MessagePacket<'a> {
     pub tick: u32,
-    pub messages: MessageIterator<'a>,
+    pub messages: Vec<Message<'a>>,
     pub meta: LazyBitRead<'a, MessagePacketMeta, LittleEndian>,
 }
 
@@ -107,15 +109,24 @@ fn test_view_angles_roundtrip() {
 }
 
 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 packet_data = stream.read_bits(length as usize * 8)?;
+        let mut packet_data = stream.read_bits(length as usize * 8)?;
 
-        let messages = MessageIterator::new(packet_data);
+        let mut messages = Vec::with_capacity(8);
+        while packet_data.bits_left() > 6 {
+            let message_type = MessageType::parse(&mut packet_data, state)?;
+
+            if state.should_parse_message(message_type) {
+                messages.push(Message::from_type(message_type, &mut packet_data, state)?);
+            } else {
+                Message::skip_type(message_type, &mut packet_data)?;
+            }
+        }
 
         let packet = MessagePacket {
             tick,
@@ -126,41 +137,17 @@ impl<'a> Parse<'a> for MessagePacket<'a> {
     }
 }
 
-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) -> 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)),
-                }
+impl Encode for MessagePacket<'_> {
+    fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
+        self.tick.write(stream)?;
+        self.meta.read()?.write(stream)?;
+        stream.reserve_byte_length(32, |stream| {
+            for message in self.messages.iter() {
+                message.get_message_type().write(stream)?;
+                message.encode(stream, state)?;
             }
-        }
-        None
+
+            Ok(())
+        })
     }
 }

src/demo/packet/stringtable.rs

@@ -231,8 +231,7 @@ impl Encode for StringTablePacket<'_> {
             self.tables.write(stream)?;
 
             Ok(())
-        })?;
-        Ok(())
+        })
     }
 }
 

src/demo/parser/handler.rs

@@ -78,10 +78,10 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
                     self.handle_string_table(table)
                 }
             }
-            Packet::Message(mut packet) | Packet::Sigon(mut packet) => {
+            Packet::Message(packet) | Packet::Sigon(packet) => {
                 //self.tick = packet.tick;
-                while let Some(message) = packet.messages.next(&self.state_handler) {
-                    match message? {
+                for message in packet.messages {
+                    match message {
                         Message::NetTick(message) => self.tick = message.tick,
                         Message::CreateStringTable(message) => {
                             self.handle_string_table(message.table)