fixes

src/demo/gameevent_gen.rs

@@ -1,5 +1,5 @@
 use super::gamevent::{FromGameEventValue, FromRawGameEvent, GameEventValue, RawGameEvent};
-use crate::{GameEventError, Result};
+use crate::Result;
 #[derive(Debug)]
 pub struct ServerSpawnEvent {
     pub hostname: String,
@@ -9034,3 +9034,4 @@ pub fn get_sizes() -> std::collections::hash_map::HashMap<&'static str, usize> {
     .into_iter()
     .collect()
 }
+

src/demo/gamevent.rs

@@ -6,9 +6,8 @@ pub use super::gameevent_gen::{GameEvent, GameEventType};
 use crate::demo::message::gameevent::GameEventTypeId;
 use parse_display::Display;
 use std::cmp::Ordering;
-use std::fmt;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct GameEventDefinition {
     pub id: GameEventTypeId,
     pub event_type: GameEventType,
@@ -36,7 +35,7 @@ impl Ord for GameEventDefinition {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct GameEventEntry {
     pub name: String,
     pub kind: GameEventValueType,

src/demo/message/gameevent.rs

@@ -1,5 +1,5 @@
-use std::collections::HashMap;
-use std::iter::FromIterator;
+
+
 
 use bitbuffer::{BitRead, LittleEndian};
 use parse_display::Display;

src/demo/message/generated.rs

@@ -1,7 +1,7 @@
 use crate::Stream;
 /// Messages that consists only of primitives and string and can be derived
 use bitbuffer::{BitRead, LittleEndian};
-use std::collections::HashMap;
+
 
 #[derive(BitRead, Debug)]
 pub struct FileMessage {

src/demo/message/mod.rs

@@ -2,7 +2,7 @@ use num_enum::TryFromPrimitive;
 use std::convert::TryFrom;
 
 pub use generated::*;
-use serde::{Deserialize, Serialize};
+
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::demo::message::bspdecal::*;

src/demo/message/packetentities.rs

@@ -2,17 +2,17 @@ use bitbuffer::{BitRead, BitReadSized, LittleEndian};
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
-use crate::demo::message::stringtable::{log_base2, read_var_int};
-use crate::demo::packet::datatable::{ClassId, SendTable, SendTableName, ServerClass};
+use crate::demo::message::stringtable::{log_base2};
+use crate::demo::packet::datatable::{ClassId, SendTable};
 use crate::demo::parser::ParseBitSkip;
 use crate::demo::sendprop::{SendProp, SendPropDefinition, SendPropValue};
 use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use parse_display::{Display, FromStr};
 use std::cmp::min;
-use std::collections::HashMap;
+
 use std::fmt;
 use std::hint::unreachable_unchecked;
-use std::num::{NonZeroU32, ParseIntError};
+use std::num::{NonZeroU32};
 use std::rc::Rc;
 
 #[derive(
@@ -221,7 +221,7 @@ impl PacketEntitiesMessage {
         let props = match state.instance_baselines[baseline_index].get(&entity_index) {
             Some(baseline) => baseline.clone(),
             None => match state.static_baselines.get(&class_index) {
-                Some(static_baseline) => state.get_static_baseline(class_index, send_table)?,
+                Some(_static_baseline) => state.get_static_baseline(class_index, send_table)?,
                 None => Vec::with_capacity(8),
             },
         };

src/demo/message/setconvar.rs

@@ -1,6 +1,5 @@
-use bitbuffer::{BitRead, BitReadSized, LittleEndian};
+use bitbuffer::{BitRead, LittleEndian};
 
-use crate::demo::message::stringtable::log_base2;
 use crate::{ReadResult, Stream};
 use std::cmp::min;
 

src/demo/message/usermessage.rs

@@ -1,11 +1,11 @@
-use bitbuffer::{BitRead, LittleEndian, ReadError};
+use bitbuffer::{BitRead, LittleEndian};
 use num_enum::TryFromPrimitive;
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
 use crate::demo::handle_utf8_error;
-use crate::demo::parser::ParseBitSkip;
-use crate::{ParseError, ReadResult, Result, Stream};
+
+use crate::{ReadResult, Stream};
 
 #[derive(TryFromPrimitive, Clone, Copy, Debug)]
 #[repr(u8)]

src/demo/packet/datatable.rs

@@ -1,18 +1,18 @@
-use bitbuffer::{BitRead, LittleEndian};
+use bitbuffer::{BitRead};
 
 use crate::demo::parser::MalformedSendPropDefinitionError;
 use crate::demo::sendprop::{
     SendPropDefinition, SendPropDefinitionIndex, SendPropFlag, SendPropName, SendPropType,
 };
-use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
+use crate::{Parse, ParseError, ParserState, Result, Stream};
 use parse_display::{Display, FromStr};
 use serde::{Deserialize, Serialize};
-use std::borrow::Borrow;
-use std::cell::{Cell, RefCell};
+
+
 use std::cmp::min;
-use std::fmt;
-use std::num::ParseIntError;
-use std::ops::Deref;
+
+
+
 use std::rc::Rc;
 
 #[derive(BitRead, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd, Display, FromStr)]

src/demo/packet/mod.rs

@@ -1,6 +1,6 @@
 use bitbuffer::BitRead;
 use num_enum::TryFromPrimitive;
-use std::convert::TryFrom;
+
 
 use crate::{Parse, ParserState, Result, Stream};
 

src/demo/parser/analyser.rs

@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, HashMap};
 
-use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{ser::SerializeMap, Deserialize, Serialize, Serializer};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::demo::gameevent_gen::{
@@ -289,13 +289,13 @@ impl MessageHandler for Analyser {
         }
     }
 
-    fn into_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, _state: &ParserState) -> Self::Output {
         self.state
     }
 }
 
 impl BorrowMessageHandler for Analyser {
-    fn borrow_output(&self, state: &ParserState) -> &Self::Output {
+    fn borrow_output(&self, _state: &ParserState) -> &Self::Output {
         &self.state
     }
 }

src/demo/parser/gamestateanalyser.rs

@@ -1,7 +1,7 @@
-use crate::demo::gameevent_gen::GameEventType::PlayerSappedObject;
+
 use crate::demo::message::packetentities::{EntityId, PacketEntity};
 use crate::demo::message::Message;
-use crate::demo::packet::datatable::{ParseSendTable, SendTableName, ServerClass, ServerClassName};
+use crate::demo::packet::datatable::{ParseSendTable, ServerClass, ServerClassName};
 pub use crate::demo::parser::analyser::{Class, Team, UserId};
 use crate::demo::parser::handler::BorrowMessageHandler;
 use crate::demo::parser::MessageHandler;
@@ -114,7 +114,7 @@ impl GameState {
             .players
             .iter_mut()
             .enumerate()
-            .find(|(index, player)| player.entity == entity_id)
+            .find(|(_index, player)| player.entity == entity_id)
             .map(|(index, _)| index)
         {
             Some(index) => index,
@@ -156,7 +156,7 @@ impl MessageHandler for GameStateAnalyser {
         }
     }
 
-    fn handle_message(&mut self, message: &Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, _tick: u32) {
         match message {
             Message::PacketEntities(message) => {
                 for entity in &message.entities {
@@ -167,7 +167,7 @@ impl MessageHandler for GameStateAnalyser {
         }
     }
 
-    fn handle_data_tables(&mut self, tables: &[ParseSendTable], server_classes: &[ServerClass]) {
+    fn handle_data_tables(&mut self, _tables: &[ParseSendTable], server_classes: &[ServerClass]) {
         self.class_names = server_classes
             .iter()
             .map(|class| &class.name)
@@ -175,13 +175,13 @@ impl MessageHandler for GameStateAnalyser {
             .collect();
     }
 
-    fn into_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, _state: &ParserState) -> Self::Output {
         self.state
     }
 }
 
 impl BorrowMessageHandler for GameStateAnalyser {
-    fn borrow_output(&self, state: &ParserState) -> &Self::Output {
+    fn borrow_output(&self, _state: &ParserState) -> &Self::Output {
         &self.state
     }
 }

src/demo/parser/handler.rs

@@ -1,21 +1,21 @@
 use crate::demo::message::{Message, MessageType};
-use crate::demo::packet::datatable::{ParseSendTable, SendTable, ServerClass};
+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::demo::parser::Parse;
-use crate::{ParseError, ParserState, Stream};
+
+use crate::ParserState;
 
 pub trait MessageHandler {
     type Output;
 
     fn does_handle(message_type: MessageType) -> bool;
 
-    fn handle_message(&mut self, message: &Message, tick: u32) {}
+    fn handle_message(&mut self, _message: &Message, _tick: u32) {}
 
-    fn handle_string_entry(&mut self, table: &str, index: usize, entries: &StringTableEntry) {}
+    fn handle_string_entry(&mut self, _table: &str, _index: usize, _entries: &StringTableEntry) {}
 
-    fn handle_data_tables(&mut self, tables: &[ParseSendTable], server_classes: &[ServerClass]) {}
+    fn handle_data_tables(&mut self, _tables: &[ParseSendTable], _server_classes: &[ServerClass]) {}
 
     fn into_output(self, state: &ParserState) -> Self::Output;
 }

src/demo/parser/messagetypeanalyser.rs

@@ -1,19 +1,17 @@
-use std::collections::HashMap;
 
-use serde::{Deserialize, Serialize};
-use serde_repr::{Deserialize_repr, Serialize_repr};
 
-use crate::demo::gameevent_gen::{
-    GameEvent, PlayerDeathEvent, PlayerSpawnEvent, TeamPlayRoundWinEvent,
-};
-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::packet::PacketType;
+
+
 use crate::demo::parser::handler::MessageHandler;
-use crate::demo::vector::Vector;
-use crate::{ParserState, ReadResult, Stream};
+
+use crate::{ParserState};
 
 #[derive(Default)]
 pub struct MessageTypeAnalyser {
@@ -23,15 +21,15 @@ pub struct MessageTypeAnalyser {
 impl MessageHandler for MessageTypeAnalyser {
     type Output = Vec<MessageType>;
 
-    fn does_handle(message_type: MessageType) -> bool {
+    fn does_handle(_message_type: MessageType) -> bool {
         true
     }
 
-    fn handle_message(&mut self, message: &Message, tick: u32) {
+    fn handle_message(&mut self, message: &Message, _tick: u32) {
         self.packet_types.push(message.get_message_type())
     }
 
-    fn into_output(self, state: &ParserState) -> Self::Output {
+    fn into_output(self, _state: &ParserState) -> Self::Output {
         self.packet_types
     }
 }

src/demo/parser/mod.rs

@@ -1,17 +1,15 @@
-use bitbuffer::{BitRead, FromUtf8Error, LittleEndian, ReadError};
+use bitbuffer::{BitRead, LittleEndian};
 
 pub use self::messagetypeanalyser::MessageTypeAnalyser;
-use crate::demo::gamevent::{GameEventValue, GameEventValueType};
+
 use crate::demo::header::Header;
-use crate::demo::message::packetentities::EntityId;
-use crate::demo::packet::datatable::{ClassId, SendTableName};
+
 use crate::demo::packet::Packet;
 use crate::demo::parser::analyser::Analyser;
 pub use crate::demo::parser::analyser::MatchState;
 pub use crate::demo::parser::handler::{DemoHandler, MessageHandler};
 pub use crate::demo::parser::state::ParserState;
 use crate::Stream;
-use err_derive::Error;
 
 mod analyser;
 mod error;
@@ -22,7 +20,6 @@ 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>;

src/demo/parser/state.rs

@@ -1,7 +1,8 @@
-use std::collections::{BTreeMap, HashMap};
+use fnv::FnvHashMap;
+use std::collections::HashMap;
 
 use crate::demo::gamevent::GameEventDefinition;
-use crate::demo::message::gameevent::GameEventTypeId;
+
 use crate::demo::message::packetentities::{EntityId, PacketEntitiesMessage, PVS};
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::demo::message::{Message, MessageType};
@@ -9,13 +10,11 @@ use crate::demo::packet::datatable::{
     ClassId, ParseSendTable, SendTable, SendTableName, ServerClass,
 };
 use crate::demo::packet::stringtable::StringTableEntry;
-use crate::demo::parser::analyser::Analyser;
-use crate::demo::parser::handler::MessageHandler;
+
 use crate::demo::sendprop::SendProp;
 use crate::nullhasher::NullHasherBuilder;
 use crate::{Result, Stream};
 use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Default)]
 pub struct DemoMeta {
@@ -106,7 +105,7 @@ impl ParserState {
                 .map(|table| table.flatten_props(&parse_tables))
                 .collect();
 
-            let mut send_tables: HashMap<SendTableName, SendTable> = parse_tables
+            let mut send_tables: FnvHashMap<SendTableName, SendTable> = parse_tables
                 .into_iter()
                 .zip(flat_props.into_iter())
                 .map(|(parse_table, flat)| {

src/demo/sendprop.rs

@@ -2,7 +2,7 @@ use bitbuffer::{BitRead, LittleEndian};
 use enumflags2::BitFlags;
 use serde::{Deserialize, Serialize};
 
-use crate::{Parse, ParseError, ReadResult, Result, Stream};
+use crate::{ParseError, ReadResult, Result, Stream};
 
 use super::packet::datatable::ParseSendTable;
 use super::vector::{Vector, VectorXY};
@@ -12,7 +12,7 @@ use crate::demo::parser::MalformedSendPropDefinitionError;
 use parse_display::Display;
 use serde::export::TryFrom;
 use std::cmp::min;
-use std::convert::TryInto;
+
 use std::fmt;
 use std::rc::Rc;
 
@@ -438,7 +438,7 @@ impl SendPropValue {
         Ok(values)
     }
 
-    fn read_string(stream: &mut Stream, definition: &SendPropDefinition) -> Result<String> {
+    fn read_string(stream: &mut Stream, _definition: &SendPropDefinition) -> Result<String> {
         let length = stream.read_int(9)?;
         stream.read_sized(length).map_err(ParseError::from)
     }

src/lib.rs

@@ -1,7 +1,3 @@
-#![allow(dead_code)]
-#![allow(unused_imports)]
-#![allow(unused_variables)]
-
 pub use bitbuffer::Result as ReadResult;
 
 pub use crate::demo::{