Add `Clone` derive and edit trait types

1 files changed, 36 insertions, 39 deletions

diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index 0db845d..a280dc7 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -2,13 +2,12 @@ use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
 use crate::zip::structs::{deserialize, EOCDR64Locator, ExtraHeader, CDR, EOCDR, EOCDR64};
 use crate::zip::{BitFlag, CompressionMethod, ZipError, ZipFile, ZipFileInfo, ZipResult};
 use chrono::{Local, NaiveDate, NaiveDateTime, NaiveTime};
-use std::collections::HashMap as Map;
 use std::io::{Read, Seek, SeekFrom, Write};
 
 pub struct Zip<Io> {
     io: Io,
 
-    files: Map<String, ZipFileInfo>,
+    files: Vec<ZipFileInfo>,
     comment: String,
 }
 
@@ -80,7 +79,7 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
             };
 
         // Read cd records
-        let mut files = Map::with_capacity(cd_records as usize);
+        let mut files = Vec::with_capacity(cd_records as usize);
         io.seek(SeekFrom::Start(cd_pointer))?;
         let buf = {
             let mut buf = vec![0; cd_size as usize];
@@ -135,52 +134,50 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
                 }
             }
 
-            files.insert(
-                name.clone(),
-                ZipFileInfo::new(
-                    CompressionMethod::from_struct_id(cdr.compression_method)?,
-                    BitFlag::new(cdr.bit_flag),
-                    NaiveDateTime::new(
-                        NaiveDate::from_ymd_opt(
-                            (cdr.dos_date as i32 >> 9 & 0x7F) + 1980,
-                            cdr.dos_date as u32 >> 5 & 0xF,
-                            cdr.dos_date as u32 & 0x1F,
-                        )
-                        .ok_or(ZipError::InvalidDate)?,
-                        NaiveTime::from_hms_opt(
-                            (cdr.dos_time as u32 >> 11) & 0x1F,
-                            (cdr.dos_time as u32 >> 5) & 0x3F,
-                            (cdr.dos_time as u32 & 0x1F) * 2,
-                        )
-                        .ok_or(ZipError::InvalidTime)?,
+            files.push(ZipFileInfo::new(
+                CompressionMethod::from_struct_id(cdr.compression_method)?,
+                BitFlag::new(cdr.bit_flag),
+                NaiveDateTime::new(
+                    NaiveDate::from_ymd_opt(
+                        (cdr.dos_date as i32 >> 9 & 0x7F) + 1980,
+                        cdr.dos_date as u32 >> 5 & 0xF,
+                        cdr.dos_date as u32 & 0x1F,
                     )
-                    .and_local_timezone(Local)
-                    .unwrap(),
-                    cdr.crc,
-                    compressed_size,
-                    size,
-                    header_pointer,
-                    name,
-                    comment,
-                ),
-            );
+                    .ok_or(ZipError::InvalidDate)?,
+                    NaiveTime::from_hms_opt(
+                        (cdr.dos_time as u32 >> 11) & 0x1F,
+                        (cdr.dos_time as u32 >> 5) & 0x3F,
+                        (cdr.dos_time as u32 & 0x1F) * 2,
+                    )
+                    .ok_or(ZipError::InvalidTime)?,
+                )
+                .and_local_timezone(Local)
+                .unwrap(),
+                cdr.crc,
+                compressed_size,
+                size,
+                header_pointer,
+                name,
+                comment,
+            ));
         }
 
         Ok(Self { io, files, comment })
     }
 
-    fn files(&self) -> Vec<&Self::FileInfo> {
-        let mut files: Vec<&Self::FileInfo> = self.files.values().collect();
-        files.sort_by_key(|f| &f.name);
-        files
+    fn files(&self) -> &Vec<Self::FileInfo> {
+        &self.files
     }
 
-    fn get_file_info(&self, name: &str) -> Option<&Self::FileInfo> {
-        self.files.get(name)
+    fn get_file_info(&self, index: usize) -> ZipResult<&Self::FileInfo> {
+        self.files.get(index).ok_or(ZipError::FileNotFound.into())
     }
 
-    fn get_file_reader<'d>(&'d mut self, name: &str) -> Option<Self::FileDriver<'d>> {
-        Some(ZipFile::new(&mut self.io, self.files.get(name)?).unwrap())
+    fn get_file_reader<'d>(&'d mut self, index: usize) -> ZipResult<Self::FileDriver<'d>> {
+        Ok(ZipFile::new(
+            &mut self.io,
+            self.files.get(index).ok_or(ZipError::FileNotFound)?,
+        )?)
     }
 }