refactor: remove useless magic in struct

Cargo.toml

@@ -130,6 +130,10 @@ harness = false
 name = "read_metadata"
 harness = false
 
+[[bench]]
+name = "read_many_entries"
+harness = false
+
 [[bench]]
 name = "merge_archive"
 harness = false

benches/read_entry.rs

@@ -25,9 +25,9 @@ fn read_entry(bench: &mut Bencher) {
     let size = 1024 * 1024;
     let bytes = generate_random_archive(size)
         .expect("Failed to create a random archive for the bench read_entry()");
-    let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap();
 
     bench.iter(|| {
+        let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap();
         let mut file = archive.by_name("random.dat").unwrap();
         let mut buf = [0u8; 1024];
         loop {

benches/read_many_entries.rs

@@ -0,0 +1,94 @@
+use bencher::{benchmark_group, benchmark_main};
+
+use std::fs::File;
+use std::io::{Cursor, Write};
+
+use bencher::Bencher;
+use zip::{ZipArchive, ZipWriter, write::SimpleFileOptions};
+
+const NB_FILES: usize = 100;
+const FILENAME: &str = "bench_read_many_entries.zip";
+
+fn generate_random_archive(size: usize) -> Result<Vec<u8>, std::io::Error> {
+    let data = Vec::new();
+    let mut writer = ZipWriter::new(Cursor::new(data));
+    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    for count in 0..NB_FILES {
+        writer.start_file(format!("random_{}.dat", count), options)?;
+        let mut bytes = vec![0u8; size];
+        getrandom::fill(&mut bytes)
+            .map_err(|e| std::io::Error::other(format!("getrandom error: {}", e)))?;
+        writer.write_all(&bytes)?;
+    }
+    let w = writer.finish()?;
+
+    Ok(w.into_inner())
+}
+
+fn generate_random_archive_to_file(size: usize) -> Result<(), std::io::Error> {
+    let bytes = generate_random_archive(size)?;
+    let mut file = File::create(FILENAME)?;
+    file.write_all(&bytes)?;
+    Ok(())
+}
+
+fn read_many_entries_as_file(bench: &mut Bencher) {
+    let size = 1024 * 1024;
+    generate_random_archive_to_file(size)
+        .expect("Failed to create a random archive for the bench read_entry()");
+
+    bench.iter(|| {
+        let file = File::open(FILENAME).unwrap();
+        let mut archive = ZipArchive::new(file).unwrap();
+        for idx in 0..archive.len() {
+            let mut file = archive.by_index(idx).unwrap();
+            let _n = std::io::copy(&mut file, &mut std::io::sink()).unwrap();
+        }
+    });
+
+    bench.bytes = (size * NB_FILES) as u64;
+    std::fs::remove_file(FILENAME).unwrap();
+}
+
+fn read_many_entries_as_file_buf(bench: &mut Bencher) {
+    let size = 1024 * 1024;
+    generate_random_archive_to_file(size)
+        .expect("Failed to create a random archive for the bench read_entry()");
+
+    bench.iter(|| {
+        let file = File::open(FILENAME).unwrap();
+        let file = std::io::BufReader::new(file);
+        let mut archive = ZipArchive::new(file).unwrap();
+        for idx in 0..archive.len() {
+            let mut file = archive.by_index(idx).unwrap();
+            let _n = std::io::copy(&mut file, &mut std::io::sink()).unwrap();
+        }
+    });
+
+    bench.bytes = (size * NB_FILES) as u64;
+    std::fs::remove_file(FILENAME).unwrap();
+}
+
+fn read_many_entries(bench: &mut Bencher) {
+    let size = 1024 * 1024;
+    let bytes = generate_random_archive(size)
+        .expect("Failed to create a random archive for the bench read_entry()");
+
+    bench.iter(|| {
+        let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap();
+        for idx in 0..archive.len() {
+            let mut file = archive.by_index(idx).unwrap();
+            let _n = std::io::copy(&mut file, &mut std::io::sink()).unwrap();
+        }
+    });
+
+    bench.bytes = (size * NB_FILES) as u64;
+}
+
+benchmark_group!(
+    benches,
+    read_many_entries,
+    read_many_entries_as_file,
+    read_many_entries_as_file_buf
+);
+benchmark_main!(benches);

src/read/stream.rs

@@ -236,15 +236,18 @@ pub fn read_zipfile_from_stream<R: Read>(reader: &mut R) -> ZipResult<Option<Zip
     // finished iterating over all the actual files).
     /* TODO: smallvec? */
 
-    let mut block = ZipLocalEntryBlock::zeroed();
-    reader.read_exact(block.as_bytes_mut())?;
+    let mut magic_buf = [0; size_of::<u32>()];
+    reader.read_exact(&mut magic_buf)?;
 
-    match block.magic().from_le() {
+    match Magic::from_le_bytes(magic_buf) {
         Magic::LOCAL_FILE_HEADER_SIGNATURE => (),
         Magic::CENTRAL_DIRECTORY_HEADER_SIGNATURE => return Ok(None),
         _ => return Err(ZipLocalEntryBlock::WRONG_MAGIC_ERROR),
     }
 
+    let mut block = ZipLocalEntryBlock::zeroed();
+    reader.read_exact(block.as_bytes_mut())?;
+
     let block = block.from_le();
 
     let mut result = ZipFileData::from_local_block(block, reader)?;
@@ -284,15 +287,18 @@ pub fn read_zipfile_from_stream_with_compressed_size<R: io::Read>(
     reader: &mut R,
     compressed_size: u64,
 ) -> ZipResult<Option<ZipFile<'_, R>>> {
-    let mut block = ZipLocalEntryBlock::zeroed();
-    reader.read_exact(block.as_bytes_mut())?;
+    let mut magic_buf = [0; size_of::<u32>()];
+    reader.read_exact(&mut magic_buf)?;
 
-    match block.magic().from_le() {
+    match Magic::from_le_bytes(magic_buf) {
         Magic::LOCAL_FILE_HEADER_SIGNATURE => (),
         Magic::CENTRAL_DIRECTORY_HEADER_SIGNATURE => return Ok(None),
         _ => return Err(ZipLocalEntryBlock::WRONG_MAGIC_ERROR),
     }
 
+    let mut block = ZipLocalEntryBlock::zeroed();
+    reader.read_exact(block.as_bytes_mut())?;
+
     let block = block.from_le();
 
     let mut result = ZipFileData::from_local_block(block, reader)?;