demo: Add next_chunk_type to high level reader

Author: Patiga

demo/src/ddnet/reader.rs

@@ -169,6 +169,16 @@ impl<'a, P: for<'p> Protocol<'p>> DemoReader<'a, P> {
             }
         }
     }
+    /// Peeks into the next chunk header to determine the next chunk type.
+    /// It returns `None` in one of three cases:
+    ///  - the demo ends
+    ///  - the stream position couldn't be determined
+    ///  - a read or parsing error happened
+    /// If `Ok` is returned, the reader's position is unchanged.
+    /// If `Err` is returned, the reader's position is unspecified.
+    pub fn next_chunk_type(&mut self) -> Result<Option<reader::ChunkType>, io::Error> {
+        self.raw.next_chunk_type()
+    }
     /// Gets the position of the underlying reader.
     pub fn stream_position(&mut self) -> Result<u64, io::Error> {
         self.raw.stream_position()

demo/src/lib.rs

@@ -7,6 +7,7 @@ pub use self::format::DemoKind;
 pub use self::format::RawChunk;
 pub use self::format::Version;
 pub use self::format::Warning;
+pub use self::reader::ChunkType;
 pub use self::reader::ReadError;
 pub use self::reader::Reader;
 pub use self::writer::WriteError;

demo/src/reader.rs

@@ -9,6 +9,7 @@ use libtw2_warn::Warn;
 use std::io;
 use thiserror::Error;
 
+use crate::format::ChunkHeader;
 use crate::format::TickMarker;
 use crate::format::Warning;
 use crate::format::MAX_SNAPSHOT_SIZE;
@@ -53,6 +54,13 @@ pub struct Reader<'a> {
     huffman: ArrayVec<[u8; MAX_SNAPSHOT_SIZE]>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ChunkType {
+    Tick,
+    Snapshot,
+    Message,
+}
+
 impl<'a> Reader<'a> {
     pub fn new<W, R>(mut data: R, warn: &mut W) -> Result<Reader<'a>, ReadError>
     where
@@ -163,6 +171,31 @@ impl<'a> Reader<'a> {
             }
         }
     }
+    /// Peeks into the next chunk header to determine the next chunk type.
+    /// It returns `None` in one of three cases:
+    ///  - the demo ends
+    ///  - the stream position couldn't be determined
+    ///  - a read or parsing error happened
+    /// If `Ok` is returned, the reader's position is unchanged.
+    /// If `Err` is returned, the reader's position is unspecified.
+    pub(crate) fn next_chunk_type(&mut self) -> Result<Option<ChunkType>, io::Error> {
+        let position = self.stream_position()?;
+        let chunk_type =
+            match ChunkHeader::read(&mut self.data, self.start.version, &mut libtw2_warn::Ignore) {
+                Ok(Some(ChunkHeader::Tick { .. })) => Some(ChunkType::Tick),
+                Ok(Some(ChunkHeader::Data {
+                    kind: format::DataKind::Snapshot | format::DataKind::SnapshotDelta,
+                    ..
+                })) => Some(ChunkType::Snapshot),
+                Ok(Some(ChunkHeader::Data {
+                    kind: format::DataKind::Message,
+                    ..
+                })) => Some(ChunkType::Message),
+                _ => None,
+            };
+        self.data.seek(io::SeekFrom::Start(position))?;
+        Ok(chunk_type)
+    }
     /// Gets the position of the underlying reader.
     pub fn stream_position(&mut self) -> Result<u64, io::Error> {
         self.data.stream_position()

tools/src/bin/demo_check_seeking.rs

@@ -2,6 +2,7 @@ use clap::App;
 use clap::Arg;
 use libtw2_demo::ddnet;
 use libtw2_demo::ddnet::DemoReader;
+use libtw2_demo::ChunkType;
 use libtw2_gamenet_ddnet::Protocol as DDNet;
 use libtw2_warn as warn;
 use std::error::Error;
@@ -28,9 +29,18 @@ impl SeekableDemo for DemoReader<'static, DDNet> {
     fn next_keyframe(&mut self) -> Result<Option<(i32, u64)>, Box<dyn Error>> {
         loop {
             let position = self.stream_position()?;
+            let chunk_type = self.next_chunk_type()?;
             let Some(chunk) = self.next_chunk(&mut warn::Ignore)? else {
+                assert!(chunk_type.is_none());
                 return Ok(None);
             };
+            assert!(matches!(
+                (chunk_type, &chunk),
+                (Some(ChunkType::Message), ddnet::Chunk::Message(_))
+                    | (Some(ChunkType::Snapshot), ddnet::Chunk::Snapshot(_))
+                    | (Some(ChunkType::Tick), ddnet::Chunk::Tick { .. })
+                    | (None, ddnet::Chunk::Invalid)
+            ));
             if let ddnet::Chunk::Tick {
                 keyframe: true,
                 tick,