Draft: iterable zip

Cargo.toml

@@ -133,3 +133,7 @@ harness = false
 [[bench]]
 name = "merge_archive"
 harness = false
+
+[[bench]]
+name = "zip_file_list"
+harness = false

benches/read_entry.rs

@@ -25,7 +25,7 @@ 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();
+    let mut archive = ZipArchive::new(Cursor::new(&bytes)).unwrap();
 
     bench.iter(|| {
         let mut file = archive.by_name("random.dat").unwrap();
@@ -41,5 +41,39 @@ fn read_entry(bench: &mut Bencher) {
     bench.bytes = size as u64;
 }
 
-benchmark_group!(benches, read_entry);
+fn read_entry_iterable(bench: &mut Bencher) {
+    use zip::read::Config;
+    use zip::unstable::read::IterableZip;
+    let size = 1024 * 1024;
+    let bytes = generate_random_archive(size)
+        .expect("Failed to create a random archive for the bench read_entry()");
+    let mut reader = Cursor::new(&bytes);
+    let mut archive = IterableZip::try_new(reader.clone(), Config::default()).unwrap();
+
+    bench.iter(|| {
+        let file = archive
+            .files()
+            .unwrap()
+            .find(|f| {
+                let file = f.as_ref().unwrap();
+                let filename = file.file_name().unwrap();
+                filename == "random.dat"
+            })
+            .unwrap()
+            .unwrap();
+        let mut buf = [0u8; 1024];
+        let zip_data = &file.into_zip_file_data(&mut reader).unwrap();
+        let mut file_reader = archive.by_file_data(&zip_data, Default::default()).unwrap();
+        loop {
+            let n = file_reader.read(&mut buf).unwrap();
+            if n == 0 {
+                break;
+            }
+        }
+    });
+
+    bench.bytes = size as u64;
+}
+
+benchmark_group!(benches, read_entry, read_entry_iterable);
 benchmark_main!(benches);

benches/zip_file_list.rs

@@ -0,0 +1,116 @@
+use bencher::{benchmark_group, benchmark_main};
+
+use std::io::{Cursor, Write};
+
+use bencher::Bencher;
+use zip::{ZipArchive, ZipWriter, write::SimpleFileOptions};
+
+const NB_FILES: usize = 100;
+const FILENAME: &str = "bench_file_listing.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> {
+    use std::fs::File;
+
+    let bytes = generate_random_archive(size)?;
+    let mut file = File::create(FILENAME)?;
+    file.write_all(&bytes)?;
+    Ok(())
+}
+
+fn file_listing_memory(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)).unwrap();
+        let mut names = vec![];
+        for idx in 0..archive.len() {
+            let file = archive.by_index(idx).unwrap();
+            names.push(file.name().to_string());
+        }
+    });
+}
+
+fn file_listing_file(bench: &mut Bencher) {
+    use std::fs::File;
+
+    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();
+        let mut names = vec![];
+        for idx in 0..archive.len() {
+            let file = archive.by_index(idx).unwrap();
+            names.push(file.name().to_string());
+        }
+    });
+
+    std::fs::remove_file(FILENAME).unwrap();
+}
+
+fn file_listing_iterable_memory(bench: &mut Bencher) {
+    use zip::read::Config;
+    use zip::unstable::read::IterableZip;
+    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 = IterableZip::try_new(Cursor::new(&bytes), Config::default()).unwrap();
+        let mut names = vec![];
+        for file in archive.files().unwrap() {
+            let file = file.unwrap();
+            names.push(file.file_name().unwrap().to_string());
+        }
+    });
+}
+
+fn file_listing_iterable_file(bench: &mut Bencher) {
+    use std::fs::File;
+    use zip::read::Config;
+    use zip::unstable::read::IterableZip;
+
+    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 = IterableZip::try_new(file, Config::default()).unwrap();
+        let mut names = vec![];
+        for file in archive.files().unwrap() {
+            let file = file.unwrap();
+            names.push(file.file_name().unwrap().to_string());
+        }
+    });
+    std::fs::remove_file(FILENAME).unwrap();
+}
+
+benchmark_group!(
+    benches,
+    file_listing_memory,
+    file_listing_iterable_memory,
+    file_listing_file,
+    file_listing_iterable_file
+);
+benchmark_main!(benches);

src/read.rs

@@ -33,6 +33,8 @@ pub(crate) mod stream;
 pub use stream::read_zipfile_from_stream;
 pub use stream::read_zipfile_from_stream_with_compressed_size;
 
+pub(crate) mod iterable_zip;
+
 pub(crate) mod magic_finder;
 
 pub use zip_archive::ZipArchive;