Revert manifest change, rename some structs

Because QmdlMessageReader no longer cares about tracking the
uncompressed bytes read thus far, we can use the old manifest QMDL file
size name again.

lib/src/qmdl.rs

@@ -21,26 +21,28 @@ where
     T: AsyncWrite + Unpin,
 {
     writer: GzipEncoder<T>,
-    pub total_uncompressed_bytes: usize,
 }
 
 impl<T> QmdlWriter<T>
 where
-    T: AsyncWrite + Unpin,
+    T: AsyncWrite + AsyncSeek + Unpin,
 {
     pub fn new(writer: T) -> Self {
         let gzip_writer = GzipEncoder::new(writer);
         QmdlWriter {
             writer: gzip_writer,
-            total_uncompressed_bytes: 0,
         }
     }
 
+    pub async fn size(&mut self) -> std::io::Result<usize> {
+        let size = self.writer.get_mut().stream_position().await?;
+        Ok(size as usize)
+    }
+
     pub async fn write_container(&mut self, container: &MessagesContainer) -> std::io::Result<()> {
         for msg in &container.messages {
             self.writer.write_all(&msg.data).await?;
             self.writer.flush().await?;
-            self.total_uncompressed_bytes += msg.data.len();
         }
         Ok(())
     }
@@ -120,7 +122,7 @@ where
 }
 
 #[derive(Debug)]
-pub struct QmdlReader<T>
+pub struct QmdlMessageReader<T>
 where
     T: AsyncRead,
 {
@@ -138,7 +140,7 @@ where
     Ok(magic_number == GZIP_MAGIC_NUMBER)
 }
 
-impl<T> QmdlReader<T>
+impl<T> QmdlMessageReader<T>
 where
     T: AsyncRead + AsyncSeek + Unpin,
 {
@@ -146,7 +148,7 @@ where
         let compressed = is_gzip_stream(&mut reader)
             .await
             .unwrap_or(false);
-        Ok(QmdlReader {
+        Ok(QmdlMessageReader {
             buf_reader: BufReader::new(QmdlAsyncReader::new(
                 reader,
                 compressed,
@@ -154,7 +156,11 @@ where
         })
     }
 
-    pub fn as_qmdl_stream(self) -> impl TryStream<Ok = Vec<u8>, Error = std::io::Error> {
+    pub fn is_compressed(&self) -> bool {
+        matches!(self.buf_reader.get_ref().source, QmdlReaderSource::Compressed { .. })
+    }
+
+    pub fn into_qmdl_stream(self) -> impl TryStream<Ok = Vec<u8>, Error = std::io::Error> {
         futures::stream::try_unfold(self, |mut reader| async {
             let mut buf = vec![];
             match reader                .buf_reader
@@ -167,7 +173,7 @@ where
         })
     }
 
-    pub fn as_message_stream(self) -> impl TryStream<Ok = Result<Message, DiagParsingError>, Error = std::io::Error> {
+    pub fn into_message_stream(self) -> impl TryStream<Ok = Result<Message, DiagParsingError>, Error = std::io::Error> {
         futures::stream::try_unfold(self, |mut reader| async {
             match reader.get_next_message().await? {
                 Some(res) => Ok(Some((res, reader))),
@@ -193,7 +199,7 @@ where
     }
 }
 
-impl<T> AsyncRead for QmdlReader<T>
+impl<T> AsyncRead for QmdlMessageReader<T>
 where
     T: AsyncRead + Unpin,
 {
@@ -255,7 +261,8 @@ mod test {
     #[tokio::test]
     async fn test_qmdl_reader() {
         let mut buf = Cursor::new(get_test_message_bytes());
-        let mut reader = QmdlReader::new(&mut buf).await.unwrap();
+        let mut reader = QmdlMessageReader::new(&mut buf).await.unwrap();
+        assert!(!reader.is_compressed());
         let (_, expected_messages) = get_test_messages();
         for msg in expected_messages {
             assert_eq!(
@@ -301,7 +308,7 @@ mod test {
             let whole_bytes: usize = message_lengths.iter().take(truncated_hdlc_i).sum();
             for truncated_byte in 1..message_lengths[truncated_hdlc_i] {
                 let mut truncated_bytes = Cursor::new(&bytes[0..whole_bytes + truncated_byte]);
-                let mut reader = QmdlReader::new(&mut truncated_bytes).await.unwrap();
+                let mut reader = QmdlMessageReader::new(&mut truncated_bytes).await.unwrap();
                 for msg in expected_messages.iter().take(truncated_hdlc_i) {
                     assert_eq!(
                         Ok(msg),
@@ -359,7 +366,7 @@ mod test {
     /// a QmdlWriter, asserting that the containers match what's expected.
     async fn run_compressed_reading_and_writing_tests(do_close: bool) {
         let containers = get_test_containers();
-        let mut buf = Vec::new();
+        let mut buf = Cursor::new(Vec::new());
         {
             let mut writer = QmdlWriter::new(&mut buf);
             for container in &containers {
@@ -369,7 +376,9 @@ mod test {
                 writer.close().await.unwrap();
             }
         }
-        let mut reader = QmdlReader::new(Cursor::new(buf)).await.unwrap();
+        buf.set_position(0);
+        let mut reader = QmdlMessageReader::new(buf).await.unwrap();
+        assert!(reader.is_compressed());
         let (_, expected_messages) = get_test_messages();
         for message in expected_messages {
             assert_eq!(