code cleanup

src/demo/header.rs

@@ -1,6 +1,4 @@
-use bitstream_reader::{BitRead, LittleEndian};
-
-use crate::{Parse, ParseError, ParserState, Result, Stream};
+use bitstream_reader::{BitRead};
 
 #[derive(BitRead, Debug, PartialEq)]
 pub struct Header {

src/demo/mod.rs

@@ -1,7 +1,5 @@
 use bitstream_reader::{BitBuffer, BitStream, LittleEndian};
 
-use crate::{Parse, ParseError, ParserState, Result};
-
 pub mod gamevent;
 pub mod header;
 pub mod message;

src/demo/packet/consolecmd.rs

@@ -1,6 +1,6 @@
 use bitstream_reader::{BitRead, LittleEndian};
 
-use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
+use crate::{Stream, ReadResult};
 
 #[derive(Debug)]
 pub struct ConsoleCmdPacket {

src/demo/packet/datatable.rs

@@ -1,11 +1,11 @@
-use bitstream_reader::{BitRead, LittleEndian};
+use bitstream_reader::BitRead;
 
-use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
+use crate::{Parse, ParseError, ParserState, Result, Stream};
 use crate::demo::sendprop::{SendPropDefinition, SendPropFlag, SendPropType};
 
-#[derive(Debug)]
+#[derive(BitRead, Debug)]
 pub struct ServerClass {
-    id: u32,
+    id: u16,
     name: String,
     data_table: String,
 }
@@ -35,7 +35,7 @@ impl Parse for DataTablePacket {
         let mut tables = vec![];
         while packet_data.read_bool()? {
             let needs_decoder = packet_data.read_bool()?;
-            let name = packet_data.read_string(None)?;
+            let name: String = packet_data.read()?;
             let prop_count = packet_data.read_int(10)?;
 
             let mut array_element_prop = None;
@@ -78,17 +78,7 @@ impl Parse for DataTablePacket {
         // TODO linked tables?
 
         let server_class_count = packet_data.read_int(16)?;
-        let mut server_classes = Vec::with_capacity(server_class_count);
-        for i in 0..server_class_count {
-            let id = packet_data.read_int(16)?;
-            let name = packet_data.read_string(None)?;
-            let data_table = packet_data.read_string(None)?;
-            server_classes.push(ServerClass {
-                id,
-                name,
-                data_table,
-            });
-        }
+        let server_classes = packet_data.read_sized(server_class_count)?;
 
         if packet_data.bits_left() > 7 {
             Err(ParseError::DataRemaining(packet_data.bits_left()))

src/demo/packet/mod.rs

@@ -1,8 +1,7 @@
-use bitstream_reader::{BitRead, LittleEndian};
+use bitstream_reader::{BitRead};
 use enum_primitive_derive::Primitive;
-use num_traits::FromPrimitive;
 
-use crate::{Parse, ParseError, ParserState, Result, Stream};
+use crate::{Parse, ParserState, Result, Stream};
 
 use self::consolecmd::ConsoleCmdPacket;
 use self::datatable::DataTablePacket;

src/demo/packet/stop.rs

@@ -1,6 +1,6 @@
 use bitstream_reader::{BitRead, LittleEndian};
 
-use crate::{Parse, ParserState, Result, Stream, ReadResult};
+use crate::{Stream, ReadResult};
 
 #[derive(Debug)]
 pub struct StopPacket;

src/demo/packet/stringtable.rs

@@ -1,7 +1,9 @@
+use std::fmt;
+
 use bitstream_reader::{BitRead, LittleEndian};
 
-use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
-use std::fmt;
+use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
+use crate::demo::sendprop::SendPropFlag::Exclude;
 
 #[derive(Debug)]
 pub struct StringTable {
@@ -15,21 +17,14 @@ pub struct StringTable {
 }
 
 impl BitRead<LittleEndian> for StringTable {
-    fn read(stream: &mut Stream) -> ReadResult <Self> {
-        let name = stream.read_string(None)?;
-        let entry_count: u32 = stream.read_int(16)?;
-        let mut entries = Vec::with_capacity(entry_count as usize);
-        for _ in 0..entry_count {
-            entries.push(StringTableEntry::read(stream)?);
-        }
+    fn read(stream: &mut Stream) -> ReadResult<Self> {
+        let name = stream.read()?;
+        let entry_count = stream.read_int(16)?;
+        let entries = stream.read_sized(entry_count as usize)?;
 
         let client_entries = if stream.read_bool()? {
             let count = stream.read_int(16)?;
-            let mut vec = Vec::with_capacity(count);
-            for _ in 0..count {
-                vec.push(StringTableEntry::read(stream)?);
-            }
-            Some(vec)
+            Some(stream.read_sized(count)?)
         } else {
             None
         };
@@ -46,22 +41,19 @@ impl BitRead<LittleEndian> for StringTable {
     }
 }
 
-pub struct StringTableEntry {
-    text: String,
-    extra_data: Option<Stream>,
+#[derive(BitRead)]
+#[endianness = "LittleEndian"]
+pub struct ExtraData {
+    len: u16,
+    #[size = "len * 8"]
+    data: Stream,
 }
 
-impl BitRead<LittleEndian> for StringTableEntry {
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
-        let text = stream.read_string(None)?;
-        let extra_data = if stream.read_bool()? {
-            let byte_len: usize = stream.read_int(16)?;
-            Some(stream.read_bits(byte_len * 8)?)
-        } else {
-            None
-        };
-        Ok(StringTableEntry { text, extra_data })
-    }
+#[derive(BitRead)]
+#[endianness = "LittleEndian"]
+pub struct StringTableEntry {
+    text: String,
+    extra_data: Option<ExtraData>,
 }
 
 impl fmt::Debug for StringTableEntry {
@@ -70,9 +62,9 @@ impl fmt::Debug for StringTableEntry {
             None => write!(f, "Table Entry: '{}'", self.text),
             Some(extra_data) => write!(
                 f,
-                "Table Entry: '{}' with {} bits of extra data",
+                "StringTableEntry{{ '{}' with {} bits of extra data }}",
                 self.text,
-                extra_data.bit_len()
+                extra_data.len
             ),
         }
     }
@@ -90,11 +82,9 @@ impl Parse for StringTablePacket {
         let start = stream.pos();
         let length: usize = stream.read_int(32)?;
         let mut packet_data = stream.read_bits(length * 8)?;
-        let count: u32 = packet_data.read_int(8)?;
-        let mut tables = Vec::with_capacity(count as usize);
-        for _ in 0..count {
-            tables.push(StringTable::read(&mut packet_data)?);
-        }
+        let count: usize = packet_data.read_int(8)?;
+        let tables = packet_data.read_sized(count)?;
+
         if packet_data.bits_left() > 7 {
             Err(ParseError::DataRemaining(packet_data.bits_left()))
         } else {

src/demo/packet/synctick.rs

@@ -1,7 +1,5 @@
 use bitstream_reader::{BitRead};
 
-use crate::{Parse, ParseError, ParserState, Result, Stream};
-
 #[derive(BitRead, Debug)]
 pub struct SyncTickPacket {
     tick: u32,

src/demo/packet/usercmd.rs

@@ -1,6 +1,6 @@
 use bitstream_reader::{BitRead, LittleEndian};
 
-use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
+use crate::{Stream, ReadResult};
 
 #[derive(Debug)]
 pub struct UserCmdPacket {

src/demo/parser/mod.rs

@@ -1,5 +1,3 @@
-use std::error::Error;
-
 use bitstream_reader::{ReadError, BitRead, LittleEndian};
 
 use crate::demo::header::Header;
@@ -43,7 +41,7 @@ pub trait Parse: Sized {
 }
 
 impl<T: BitRead<LittleEndian>> Parse for T {
-    fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
+    fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         Self::read(stream).map_err(ParseError::from)
     }
 

src/demo/sendprop.rs

@@ -1,10 +1,8 @@
 use bitstream_reader::{BitRead, LittleEndian};
-use enum_primitive_derive::Primitive;
 use enumflags2::BitFlags;
 use enumflags2_derive::EnumFlags;
-use num_traits::cast::FromPrimitive;
 
-use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
+use crate::{ReadResult, Result, Stream};
 
 use super::packet::datatable::SendTable;
 use super::vector::{Vector, VectorXY};

src/demo/vector.rs

@@ -1,7 +1,5 @@
 use bitstream_reader::BitRead;
 
-use crate::{Parse, ParseError, ParserState, Result, Stream};
-
 #[derive(BitRead, Debug)]
 pub struct Vector {
     pub x: f32,

src/lib.rs

@@ -1,6 +1,3 @@
-use std::error::Error;
-use std::fs;
-
 pub use crate::demo::{
     parser::{DemoParser, Parse, ParseError, ParserState, Result},
     Demo, Stream,
@@ -10,4 +7,3 @@ pub use bitstream_reader::Result as ReadResult;
 
 mod demo;
 mod state;
-mod test;

src/test.rs

@@ -1,17 +0,0 @@
-use crate::*;
-use std::fmt::Debug;
-use std::fs;
-
-//pub fn test_parse<'a, T: Parse<'a> + Debug + PartialEq>(path: &str, expected: T, offset: usize) {
-//    let file = fs::read(path).expect("Unable to read file");
-//    let demo = Demo::new(file);
-//    let stream: Stream = demo.get_stream();
-//    let mut parser = DemoParser::new(stream);
-//    let _ = parser.set_stream_pos(offset);
-//    let result = parser.read().unwrap();
-//    assert_eq!(expected, result);
-//    let end_pos = parser.stream_pos();
-//    let _ = parser.set_stream_pos(offset);
-//    let _ = parser.skip::<T>();
-//    assert_eq!(parser.stream_pos(), end_pos);
-//}