borrowed data

src/demo/message/bspdecal.rs

@@ -13,7 +13,7 @@ pub struct BSPDecalMessage {
     pub low_priority: bool,
 }
 
-impl BitRead<LittleEndian> for BSPDecalMessage {
+impl BitRead<'_, LittleEndian> for BSPDecalMessage {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let position = {
             let has_x = stream.read()?;

src/demo/message/classinfo.rs

@@ -19,7 +19,7 @@ pub struct ClassInfoMessage {
     entries: Vec<ClassInfoEntry>,
 }
 
-impl BitRead<LittleEndian> for ClassInfoMessage {
+impl BitRead<'_, LittleEndian> for ClassInfoMessage {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let count: u16 = stream.read()?;
         let create: bool = stream.read()?;

src/demo/message/gameevent.rs

@@ -30,7 +30,7 @@ pub struct GameEventMessage {
     pub event: Box<GameEvent>,
 }
 
-impl Parse for GameEventMessage {
+impl Parse<'_> for GameEventMessage {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         let length: u16 = stream.read_sized(11)?;
         let mut data = stream.read_bits(length as usize)?;
@@ -71,7 +71,7 @@ impl Parse for GameEventMessage {
     }
 }
 
-impl ParseBitSkip for GameEventMessage {
+impl ParseBitSkip<'_> for GameEventMessage {
     fn parse_skip(stream: &mut Stream) -> Result<()> {
         let length: u16 = stream.read_sized(11)?;
         stream.skip_bits(length as usize).map_err(ParseError::from)
@@ -98,7 +98,7 @@ pub struct GameEventListMessage {
     pub event_list: Vec<GameEventDefinition>,
 }
 
-impl BitRead<LittleEndian> for GameEventDefinition {
+impl BitRead<'_, LittleEndian> for GameEventDefinition {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let event_type: GameEventTypeId = stream.read()?;
         let name: String = stream.read()?;
@@ -123,7 +123,7 @@ impl BitRead<LittleEndian> for GameEventDefinition {
     }
 }
 
-impl BitRead<LittleEndian> for GameEventListMessage {
+impl BitRead<'_, LittleEndian> for GameEventListMessage {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let count: u16 = stream.read_sized(9)?;
         let length: u32 = stream.read_sized(20)?;

src/demo/message/generated.rs

@@ -74,7 +74,7 @@ pub struct FixAngleMessage {
 
 #[derive(BitRead, Debug)]
 #[endianness = "LittleEndian"]
-pub struct EntityMessage {
+pub struct EntityMessage<'a> {
     #[size = 11]
     pub index: u16,
     #[size = 9]
@@ -82,7 +82,7 @@ pub struct EntityMessage {
     #[size = 11]
     pub length: u16,
     #[size = "length"]
-    pub data: Stream,
+    pub data: Stream<'a>,
 }
 
 #[derive(BitRead, Debug)]
@@ -93,11 +93,11 @@ pub struct PreFetchMessage {
 
 #[derive(BitRead, Debug)]
 #[endianness = "LittleEndian"]
-pub struct MenuMessage {
+pub struct MenuMessage<'a> {
     pub kind: u16,
     pub length: u16,
     #[size = "length.saturating_mul(8)"]
-    pub index: Stream,
+    pub index: Stream<'a>,
 }
 
 #[derive(BitRead, Debug)]
@@ -108,8 +108,8 @@ pub struct GetCvarValueMessage {
 
 #[derive(BitRead, Debug)]
 #[endianness = "LittleEndian"]
-pub struct CmdKeyValuesMessage {
+pub struct CmdKeyValuesMessage<'a> {
     pub length: u32,
     #[size = "length.saturating_mul(8)"]
-    pub data: Stream,
+    pub data: Stream<'a>,
 }

src/demo/message/mod.rs

@@ -61,7 +61,7 @@ pub enum MessageType {
     CmdKeyValues = 32,
 }
 
-impl Parse for MessageType {
+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))
@@ -69,7 +69,7 @@ impl Parse for MessageType {
 }
 
 #[derive(Debug)]
-pub enum Message {
+pub enum Message<'a> {
     Empty,
     File(FileMessage),
     NetTick(NetTickMessage),
@@ -80,34 +80,34 @@ pub enum Message {
     ServerInfo(Box<ServerInfoMessage>),
     ClassInfo(ClassInfoMessage),
     SetPause(SetPauseMessage),
-    CreateStringTable(CreateStringTableMessage),
-    UpdateStringTable(UpdateStringTableMessage),
+    CreateStringTable(CreateStringTableMessage<'a>),
+    UpdateStringTable(UpdateStringTableMessage<'a>),
     VoiceInit(VoiceInitMessage),
-    VoiceData(VoiceDataMessage),
-    ParseSounds(ParseSoundsMessage),
+    VoiceData(VoiceDataMessage<'a>),
+    ParseSounds(ParseSoundsMessage<'a>),
     SetView(SetViewMessage),
     FixAngle(FixAngleMessage),
     BspDecal(BSPDecalMessage),
-    UserMessage(UserMessage),
-    EntityMessage(EntityMessage),
+    UserMessage(UserMessage<'a>),
+    EntityMessage(EntityMessage<'a>),
     GameEvent(GameEventMessage),
     PacketEntities(PacketEntitiesMessage),
     TempEntities(TempEntitiesMessage),
     PreFetch(PreFetchMessage),
-    Menu(MenuMessage),
+    Menu(MenuMessage<'a>),
     GameEventList(GameEventListMessage),
     GetCvarValue(GetCvarValueMessage),
-    CmdKeyValues(CmdKeyValuesMessage),
+    CmdKeyValues(CmdKeyValuesMessage<'a>),
 }
 
-impl Parse for Message {
-    fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
+impl<'a> Parse<'a> for Message<'a> {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
         let message_type = MessageType::parse(stream, state)?;
         Self::from_type(message_type, stream, state)
     }
 }
 
-impl Message {
+impl<'a> Message<'a> {
     pub fn get_message_type(&self) -> MessageType {
         match self {
             Message::Empty => MessageType::Empty,
@@ -143,7 +143,7 @@ impl Message {
 
     pub fn from_type(
         message_type: MessageType,
-        stream: &mut Stream,
+        stream: &mut Stream<'a>,
         state: &ParserState,
     ) -> Result<Self> {
         Ok(match message_type {

src/demo/message/packetentities.rs

@@ -93,7 +93,7 @@ impl PacketEntity {
     }
 }
 
-fn read_bit_var<T: BitReadSized<LittleEndian>>(stream: &mut Stream) -> ReadResult<T> {
+fn read_bit_var<'a, T: BitReadSized<'a, LittleEndian>>(stream: &mut Stream<'a>) -> ReadResult<T> {
     let ty: u8 = stream.read_sized(2)?;
 
     let bits = match ty {
@@ -116,7 +116,7 @@ pub struct PacketEntitiesMessage {
     pub updated_base_line: bool,
 }
 
-fn get_send_table(state: &ParserState, class: ClassId) -> Result<&SendTable> {
+fn get_send_table<'a, 'b>(state: &'b ParserState<'a>, class: ClassId) -> Result<&'b SendTable> {
     state
         .send_tables
         .get(usize::from(class))
@@ -144,7 +144,7 @@ fn get_entity_for_update(
     })
 }
 
-impl Parse for PacketEntitiesMessage {
+impl Parse<'_> for PacketEntitiesMessage {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         let max_entries = stream.read_sized(11)?;
         let delta: Option<u32> = stream.read()?;
@@ -269,7 +269,7 @@ impl PacketEntitiesMessage {
     }
 }
 
-impl ParseBitSkip for PacketEntitiesMessage {
+impl ParseBitSkip<'_> for PacketEntitiesMessage {
     fn parse_skip(stream: &mut Stream) -> Result<()> {
         stream.skip_bits(11)?;
         if stream.read()? {

src/demo/message/setconvar.rs

@@ -8,7 +8,7 @@ pub struct SetConVarMessage {
     vars: Vec<(String, String)>,
 }
 
-impl BitRead<LittleEndian> for SetConVarMessage {
+impl BitRead<'_, LittleEndian> for SetConVarMessage {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let count: u8 = stream.read()?;
         let mut vars: Vec<(String, String)> = Vec::with_capacity(min(count, 128) as usize);

src/demo/message/stringtable.rs

@@ -10,8 +10,8 @@ use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use std::cmp::min;
 
 #[derive(Debug)]
-pub struct CreateStringTableMessage {
-    pub table: Box<StringTable>,
+pub struct CreateStringTableMessage<'a> {
+    pub table: Box<StringTable<'a>>,
 }
 
 #[derive(Debug)]
@@ -20,7 +20,7 @@ pub struct StringTableMeta {
     pub fixed_userdata_size: Option<FixedUserDataSize>,
 }
 
-impl From<&StringTable> for StringTableMeta {
+impl From<&StringTable<'_>> for StringTableMeta {
     fn from(table: &StringTable) -> Self {
         StringTableMeta {
             max_entries: table.max_entries,
@@ -29,8 +29,8 @@ impl From<&StringTable> for StringTableMeta {
     }
 }
 
-impl Parse for CreateStringTableMessage {
-    fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
+impl<'a> Parse<'a> for CreateStringTableMessage<'a> {
+    fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
         let name = stream.read()?;
         let max_entries: u16 = stream.read()?;
         let encode_bits = log_base2(max_entries);
@@ -67,7 +67,7 @@ impl Parse for CreateStringTableMessage {
                 });
             }
 
-            let buffer = BitReadBuffer::new(decompressed_data, LittleEndian);
+            let buffer = BitReadBuffer::new_owned(decompressed_data, LittleEndian);
             table_data = BitReadStream::new(buffer);
         }
 
@@ -92,8 +92,8 @@ impl Parse for CreateStringTableMessage {
     }
 }
 
-impl ParseBitSkip for CreateStringTableMessage {
-    fn parse_skip(stream: &mut Stream) -> Result<()> {
+impl<'a> ParseBitSkip<'a> for CreateStringTableMessage<'a> {
+    fn parse_skip(stream: &mut Stream<'a>) -> Result<()> {
         let _: String = stream.read()?;
         let max_entries: u16 = stream.read()?;
         let encode_bits = log_base2(max_entries);
@@ -109,13 +109,13 @@ impl ParseBitSkip for CreateStringTableMessage {
 }
 
 #[derive(Debug)]
-pub struct UpdateStringTableMessage {
-    pub entries: Vec<(u16, StringTableEntry)>,
+pub struct UpdateStringTableMessage<'a> {
+    pub entries: Vec<(u16, StringTableEntry<'a>)>,
     pub table_id: u8,
 }
 
-impl Parse for UpdateStringTableMessage {
-    fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
+impl<'a> Parse<'a> for UpdateStringTableMessage<'a> {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
         let table_id = stream.read_sized(5)?;
 
         let changed: u16 = if stream.read()? { stream.read()? } else { 1 };
@@ -132,8 +132,8 @@ impl Parse for UpdateStringTableMessage {
     }
 }
 
-impl ParseBitSkip for UpdateStringTableMessage {
-    fn parse_skip(stream: &mut Stream) -> Result<()> {
+impl<'a> ParseBitSkip<'a> for UpdateStringTableMessage<'a> {
+    fn parse_skip(stream: &mut Stream<'a>) -> Result<()> {
         let _: u8 = stream.read_sized(5)?;
 
         let _: u16 = if stream.read()? { stream.read()? } else { 1 };
@@ -142,12 +142,12 @@ impl ParseBitSkip for UpdateStringTableMessage {
     }
 }
 
-struct TableEntries {
-    entries: Vec<(u16, StringTableEntry)>,
+struct TableEntries<'a> {
+    entries: Vec<(u16, StringTableEntry<'a>)>,
     history: Vec<u16>,
 }
 
-impl TableEntries {
+impl<'a> TableEntries<'a> {
     pub fn new(count: usize) -> Self {
         TableEntries {
             entries: Vec::with_capacity(min(count, 128)),
@@ -155,7 +155,7 @@ impl TableEntries {
         }
     }
 
-    pub fn push(&mut self, entry: (u16, StringTableEntry)) {
+    pub fn push(&mut self, entry: (u16, StringTableEntry<'a>)) {
         if self.history.len() > 31 {
             self.history.remove(0);
         }
@@ -164,23 +164,23 @@ impl TableEntries {
         self.history.push(entry_index as u16);
     }
 
-    pub fn get_history(&self, index: usize) -> Option<&StringTableEntry> {
+    pub fn get_history(&self, index: usize) -> Option<&StringTableEntry<'a>> {
         self.history
             .get(index)
             .and_then(|entry_index| self.entries.get(*entry_index as usize))
             .map(|entry| &entry.1)
     }
 
-    pub fn into_entries(self) -> Vec<(u16, StringTableEntry)> {
+    pub fn into_entries(self) -> Vec<(u16, StringTableEntry<'a>)> {
         self.entries
     }
 }
 
-fn parse_string_table_update(
-    stream: &mut Stream,
+fn parse_string_table_update<'a>(
+    stream: &mut Stream<'a>,
     table_meta: &StringTableMeta,
     entry_count: u16,
-) -> ReadResult<Vec<(u16, StringTableEntry)>> {
+) -> ReadResult<Vec<(u16, StringTableEntry<'a>)>> {
     let entry_bits = log_base2(table_meta.max_entries);
     let mut entries = TableEntries::new(entry_count as usize);
 
@@ -202,11 +202,11 @@ fn parse_string_table_update(
     Ok(entries.into_entries())
 }
 
-fn parse_string_table_list(
-    stream: &mut Stream,
+fn parse_string_table_list<'a>(
+    stream: &mut Stream<'a>,
     table_meta: &StringTableMeta,
     entry_count: u16,
-) -> Result<Vec<(u16, StringTableEntry)>> {
+) -> Result<Vec<(u16, StringTableEntry<'a>)>> {
     let mut entries = TableEntries::new(entry_count as usize);
 
     for index in 0..entry_count {
@@ -223,11 +223,11 @@ fn parse_string_table_list(
     Ok(entries.into_entries())
 }
 
-fn read_table_entry(
-    stream: &mut Stream,
+fn read_table_entry<'a>(
+    stream: &mut Stream<'a>,
     table_meta: &StringTableMeta,
     history: &TableEntries,
-) -> ReadResult<StringTableEntry> {
+) -> ReadResult<StringTableEntry<'a>> {
     let text = if stream.read()? {
         // set value
         if stream.read()? {

src/demo/message/tempentities.rs

@@ -9,7 +9,7 @@ pub struct TempEntitiesMessage {
     pub entities: Vec<PacketEntity>,
 }
 
-impl Parse for TempEntitiesMessage {
+impl Parse<'_> for TempEntitiesMessage {
     fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
         let _count: u8 = stream.read()?;
         let length = read_var_int(stream)?;
@@ -21,7 +21,7 @@ impl Parse for TempEntitiesMessage {
     }
 }
 
-impl ParseBitSkip for TempEntitiesMessage {
+impl ParseBitSkip<'_> for TempEntitiesMessage {
     fn parse_skip(stream: &mut Stream) -> Result<()> {
         let _: u8 = stream.read()?;
         let length = read_var_int(stream)?;

src/demo/message/usermessage.rs

@@ -72,18 +72,18 @@ pub enum UserMessageType {
 }
 
 #[derive(Debug)]
-pub enum UserMessage {
+pub enum UserMessage<'a> {
     SayText2(Box<SayText2Message>),
     Text(Box<TextMessage>),
     ResetHUD(ResetHudMessage),
     Train(TrainMessage),
     VoiceSubtitle(VoiceSubtitleMessage),
     Shake(ShakeMessage),
-    Unknown(UnknownUserMessage),
+    Unknown(UnknownUserMessage<'a>),
 }
 
-impl BitRead<LittleEndian> for UserMessage {
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
+impl<'a> BitRead<'a, LittleEndian> for UserMessage<'a> {
+    fn read(stream: &mut Stream<'a>) -> ReadResult<Self> {
         let message_type =
             UserMessageType::try_from(stream.read::<u8>()?).unwrap_or(UserMessageType::Unknown);
         let length = stream.read_int(11)?;
@@ -122,7 +122,7 @@ pub enum ChatMessageKind {
     NameChange,
 }
 
-impl BitRead<LittleEndian> for ChatMessageKind {
+impl BitRead<'_, LittleEndian> for ChatMessageKind {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let raw: String = stream.read()?;
         Ok(match raw.as_str() {
@@ -146,7 +146,7 @@ pub struct SayText2Message {
     pub text: String,
 }
 
-impl BitRead<LittleEndian> for SayText2Message {
+impl BitRead<'_, LittleEndian> for SayText2Message {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let client = stream.read()?;
         let raw = stream.read()?;
@@ -250,12 +250,12 @@ pub struct ShakeMessage {
 }
 
 #[derive(Debug, Clone)]
-pub struct UnknownUserMessage {
-    data: Stream,
+pub struct UnknownUserMessage<'a> {
+    data: Stream<'a>,
 }
 
-impl BitRead<LittleEndian> for UnknownUserMessage {
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
+impl<'a> BitRead<'a, LittleEndian> for UnknownUserMessage<'a> {
+    fn read(stream: &mut Stream<'a>) -> ReadResult<Self> {
         Ok(UnknownUserMessage {
             data: stream.read_bits(stream.bits_left())?,
         })

src/demo/message/voice.rs

@@ -9,7 +9,7 @@ pub struct VoiceInitMessage {
     sampling_rate: u16,
 }
 
-impl BitRead<LittleEndian> for VoiceInitMessage {
+impl BitRead<'_, LittleEndian> for VoiceInitMessage {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
         let codec = stream.read()?;
         let quality = stream.read()?;
@@ -32,24 +32,24 @@ impl BitRead<LittleEndian> for VoiceInitMessage {
 
 #[derive(BitRead, Debug, Clone)]
 #[endianness = "LittleEndian"]
-pub struct VoiceDataMessage {
+pub struct VoiceDataMessage<'a> {
     client: u8,
     proximity: u8,
     length: u16,
     #[size = "length"]
-    data: Stream,
+    data: Stream<'a>,
 }
 
 #[derive(Debug, Clone)]
-pub struct ParseSoundsMessage {
+pub struct ParseSoundsMessage<'a> {
     pub reliable: bool,
     pub num: u8,
     pub length: u16,
-    pub data: Stream,
+    pub data: Stream<'a>,
 }
 
-impl BitRead<LittleEndian> for ParseSoundsMessage {
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
+impl<'a> BitRead<'a, LittleEndian> for ParseSoundsMessage<'a> {
+    fn read(stream: &mut Stream<'a>) -> ReadResult<Self> {
         let reliable = stream.read()?;
         let num = if reliable { 1u8 } else { stream.read()? };
         let length = if reliable {