Speedup little entry access in maps and fix missing extension workarounds (#747)

qarmin · web-flow · commit 56fc29fa4f3f · 2022-06-05T08:01:17.000+02:00
diff --git a/czkawka_core/src/bad_extensions.rs b/czkawka_core/src/bad_extensions.rs
@@ -33,7 +33,6 @@ static WORKAROUNDS: &[(&str, &str)] = &[
     ("exe", "bck"),
     ("exe", "com"),
     ("exe", "cpl"),
-    ("exe", "cpl"),
     ("exe", "dll"),
     ("exe", "dll16"),
     ("exe", "drv"),
@@ -48,7 +47,6 @@ static WORKAROUNDS: &[(&str, &str)] = &[
     ("exe", "orig"),
     ("exe", "signed"),
     ("exe", "sys"),
-    ("exe", "sys"),
     ("exe", "tlb"),
     ("exe", "vxd"),
     ("exe", "winmd"),
@@ -120,7 +118,7 @@ static WORKAROUNDS: &[(&str, &str)] = &[
     ("html", "svg"),
     ("xml", "html"),
     // Probably bug in external library
-    ("exe", "doc"), // Not sure whe doc is not recognized
+    ("msi", "doc"), // Not sure whe doc is not recognized
     ("exe", "xls"), // Not sure whe xls is not recognized
 ];
 
@@ -318,9 +316,13 @@ impl BadExtensions {
         mem::swap(&mut files_to_check, &mut self.files_to_check);
         //// PROGRESS THREAD END
 
-        let mut hashmap_workarounds: HashMap<&str, &str> = Default::default();
+        let mut hashmap_workarounds: HashMap<&str, Vec<&str>> = Default::default();
         for (proper, found) in WORKAROUNDS {
-            hashmap_workarounds.insert(found, proper);
+            // This should be enabled when items will have only 1 possible workaround items
+            // if hashmap_workarounds.contains_key(found) {
+            //     panic!("Already have {} key", found);
+            // }
+            hashmap_workarounds.entry(found).or_insert_with(Vec::new).push(proper);
         }
 
         self.bad_extensions_files = files_to_check
@@ -378,9 +380,12 @@ impl BadExtensions {
                         }
 
                         // Workarounds
-                        if let Some(pre) = hashmap_workarounds.get(current_extension.as_str()) {
-                            if all_available_extensions.contains(pre) {
-                                all_available_extensions.insert(current_extension.as_str());
+                        if let Some(vec_pre) = hashmap_workarounds.get(current_extension.as_str()) {
+                            for pre in vec_pre {
+                                if all_available_extensions.contains(pre) {
+                                    all_available_extensions.insert(current_extension.as_str());
+                                    break;
+                                }
                             }
                         }
 
@@ -400,7 +405,6 @@ impl BadExtensions {
                     return Some(None);
                 } else if current_extension.is_empty() {
                     if !include_files_without_extension {
-                        println!("Empty extension which is disabled by settings");
                         return Some(None);
                     }
                 } else if all_available_extensions.take(&current_extension.as_str()).is_some() {
diff --git a/czkawka_core/src/big_file.rs b/czkawka_core/src/big_file.rs
@@ -313,8 +313,7 @@ impl BigFile {
                 folders_to_check.extend(segment);
                 self.text_messages.warnings.extend(warnings);
                 for (size, fe) in fe_result {
-                    old_map.entry(size).or_insert_with(Vec::new);
-                    old_map.get_mut(&size).unwrap().push(fe);
+                    old_map.entry(size).or_insert_with(Vec::new).push(fe);
                 }
             }
         }
diff --git a/czkawka_core/src/duplicate.rs b/czkawka_core/src/duplicate.rs
@@ -568,16 +568,13 @@ impl DuplicateFinder {
                         let name = file_entry.path.to_string_lossy().to_string();
                         if !loaded_hash_map2.contains_key(&name) {
                             // If loaded data doesn't contains current image info
-                            non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);
-                            non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry.clone());
+                            non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());
                         } else if file_entry.size != loaded_hash_map2.get(&name).unwrap().size || file_entry.modified_date != loaded_hash_map2.get(&name).unwrap().modified_date {
                             // When size or modification date of image changed, then it is clear that is different image
-                            non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);
-                            non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry.clone());
+                            non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());
                         } else {
                             // Checking may be omitted when already there is entry with same size and modification date
-                            records_already_cached.entry(file_entry.size).or_insert_with(Vec::new);
-                            records_already_cached.get_mut(&file_entry.size).unwrap().push(file_entry.clone());
+                            records_already_cached.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());
                         }
                     }
                 }
@@ -602,8 +599,7 @@ impl DuplicateFinder {
                         }
                         match hash_calculation(&mut buffer, file_entry, &check_type, 0) {
                             Ok(hash_string) => {
-                                hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new);
-                                hashmap_with_hash.get_mut(hash_string.as_str()).unwrap().push(file_entry.clone());
+                                hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new).push(file_entry.clone());
                             }
                             Err(s) => errors.push(s),
                         }
@@ -624,17 +620,15 @@ impl DuplicateFinder {
 
             // Add data from cache
             for (size, vec_file_entry) in &records_already_cached {
-                pre_checked_map.entry(*size).or_insert_with(Vec::new);
-                pre_checked_map.get_mut(size).unwrap().append(&mut vec_file_entry.clone());
+                pre_checked_map.entry(*size).or_insert_with(Vec::new).append(&mut vec_file_entry.clone());
             }
 
             // Check results
             for (size, hash_map, errors) in &pre_hash_results {
                 self.text_messages.warnings.append(&mut errors.clone());
                 for vec_file_entry in hash_map.values() {
                     if vec_file_entry.len() > 1 {
-                        pre_checked_map.entry(*size).or_insert_with(Vec::new);
-                        pre_checked_map.get_mut(size).unwrap().append(&mut vec_file_entry.clone());
+                        pre_checked_map.entry(*size).or_insert_with(Vec::new).append(&mut vec_file_entry.clone());
                     }
                 }
             }
@@ -732,16 +726,14 @@ impl DuplicateFinder {
                             let mut found: bool = false;
                             for loaded_file_entry in loaded_vec_file_entry {
                                 if file_entry.path == loaded_file_entry.path && file_entry.modified_date == loaded_file_entry.modified_date {
-                                    records_already_cached.entry(file_entry.size).or_insert_with(Vec::new);
-                                    records_already_cached.get_mut(&file_entry.size).unwrap().push(loaded_file_entry.clone());
+                                    records_already_cached.entry(file_entry.size).or_insert_with(Vec::new).push(loaded_file_entry.clone());
                                     found = true;
                                     break;
                                 }
                             }
 
                             if !found {
-                                non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);
-                                non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry);
+                                non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry);
                             }
                         }
                     }
@@ -768,8 +760,7 @@ impl DuplicateFinder {
                         match hash_calculation(&mut buffer, &file_entry, &check_type, u64::MAX) {
                             Ok(hash_string) => {
                                 file_entry.hash = hash_string.clone();
-                                hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new);
-                                hashmap_with_hash.get_mut(hash_string.as_str()).unwrap().push(file_entry);
+                                hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new).push(file_entry);
                             }
                             Err(s) => errors.push(s),
                         }
@@ -785,17 +776,15 @@ impl DuplicateFinder {
                     for (full_size, full_hashmap, _errors) in &mut full_hash_results {
                         if size == *full_size {
                             for file_entry in vec_file_entry {
-                                full_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new);
-                                full_hashmap.get_mut(&file_entry.hash).unwrap().push(file_entry);
+                                full_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new).push(file_entry);
                             }
                             continue 'main;
                         }
                     }
                     // Size doesn't exists add results to files
                     let mut temp_hashmap: BTreeMap<String, Vec<FileEntry>> = Default::default();
                     for file_entry in vec_file_entry {
-                        temp_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new);
-                        temp_hashmap.get_mut(&file_entry.hash).unwrap().push(file_entry);
+                        temp_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                     full_hash_results.push((size, temp_hashmap, Vec::new()));
                 }
@@ -830,8 +819,7 @@ impl DuplicateFinder {
                 self.text_messages.warnings.append(&mut errors);
                 for (_hash, vec_file_entry) in hash_map {
                     if vec_file_entry.len() > 1 {
-                        self.files_with_identical_hashes.entry(size).or_insert_with(Vec::new);
-                        self.files_with_identical_hashes.get_mut(&size).unwrap().push(vec_file_entry);
+                        self.files_with_identical_hashes.entry(size).or_insert_with(Vec::new).push(vec_file_entry);
                     }
                 }
             }
@@ -1374,8 +1362,7 @@ pub fn load_hashes_from_file(text_messages: &mut Messages, delete_outdated_cache
                     hash: uuu[3].to_string(),
                     symlink_info: None,
                 };
-                hashmap_loaded_entries.entry(file_entry.size).or_insert_with(Vec::new);
-                hashmap_loaded_entries.get_mut(&file_entry.size).unwrap().push(file_entry);
+                hashmap_loaded_entries.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry);
             }
         }
 
diff --git a/czkawka_core/src/same_music.rs b/czkawka_core/src/same_music.rs
@@ -552,8 +552,7 @@ impl SameMusic {
                         get_approximate_conversion(&mut thing);
                     }
                     if !thing.is_empty() {
-                        hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                        hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                        hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                 }
                 for (_title, vec_file_entry) in hash_map {
@@ -581,8 +580,7 @@ impl SameMusic {
                         get_approximate_conversion(&mut thing);
                     }
                     if !thing.is_empty() {
-                        hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                        hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                        hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                 }
                 for (_title, vec_file_entry) in hash_map {
@@ -607,8 +605,7 @@ impl SameMusic {
                 for file_entry in vec_file_entry {
                     let thing = file_entry.year.to_lowercase().trim().to_string();
                     if !thing.is_empty() {
-                        hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                        hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                        hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                 }
                 for (_title, vec_file_entry) in hash_map {
@@ -633,8 +630,7 @@ impl SameMusic {
                 for file_entry in vec_file_entry {
                     let thing = file_entry.length.to_lowercase().trim().to_string();
                     if !thing.is_empty() {
-                        hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                        hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                        hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                 }
                 for (_title, vec_file_entry) in hash_map {
@@ -659,8 +655,7 @@ impl SameMusic {
                 for file_entry in vec_file_entry {
                     let thing = file_entry.genre.to_lowercase().trim().to_string();
                     if !thing.is_empty() {
-                        hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                        hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                        hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                     }
                 }
                 for (_title, vec_file_entry) in hash_map {
@@ -686,8 +681,7 @@ impl SameMusic {
                     if file_entry.bitrate != 0 {
                         let thing = file_entry.bitrate.to_string();
                         if !thing.is_empty() {
-                            hash_map.entry(thing.clone()).or_insert_with(Vec::new);
-                            hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);
+                            hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);
                         }
                     }
                 }
diff --git a/czkawka_core/src/similar_images.rs b/czkawka_core/src/similar_images.rs
@@ -631,8 +631,7 @@ impl SimilarImages {
         for (file_entry, buf) in &vec_file_entry {
             // Only use to comparing, non broken hashes(all 0 or 255 hashes means that algorithm fails to decode them because e.g. contains a log of alpha channel)
             if !(buf.is_empty() || buf.iter().all(|e| *e == 0) || buf.iter().all(|e| *e == 255)) {
-                self.image_hashes.entry(buf.clone()).or_insert_with(Vec::<FileEntry>::new);
-                self.image_hashes.get_mut(buf).unwrap().push(file_entry.clone());
+                self.image_hashes.entry(buf.clone()).or_insert_with(Vec::<FileEntry>::new).push(file_entry.clone());
             }
         }
 
diff --git a/czkawka_gui/src/connect_things/connect_button_delete.rs b/czkawka_gui/src/connect_things/connect_button_delete.rs
@@ -503,8 +503,7 @@ pub fn tree_remove(
 
         model.remove(&iter);
 
-        map_with_path_to_delete.entry(path.clone()).or_insert_with(Vec::new);
-        map_with_path_to_delete.get_mut(path.as_str()).unwrap().push(file_name);
+        map_with_path_to_delete.entry(path.clone()).or_insert_with(Vec::new).push(file_name);
     }
 
     // Delete duplicated entries, and remove real files
diff --git a/czkawka_gui/src/saving_loading.rs b/czkawka_gui/src/saving_loading.rs
@@ -311,8 +311,7 @@ impl LoadSaveStruct {
                 if line.starts_with("--") {
                     header = line.to_string();
                 } else if !header.is_empty() {
-                    self.loaded_items.entry(header.clone()).or_insert_with(Vec::new);
-                    self.loaded_items.get_mut(&header).unwrap().push(line.to_string());
+                    self.loaded_items.entry(header.clone()).or_insert_with(Vec::new).push(line.to_string());
                 } else {
                     add_text_to_text_view(
                         text_view_errors,

Original file line number	Diff line number	Diff line change
`@@ -313,8 +313,7 @@ impl BigFile {`
`313`	`313`	`folders_to_check.extend(segment);`
`314`	`314`	`self.text_messages.warnings.extend(warnings);`
`315`	`315`	`for (size, fe) in fe_result {`
`316`		`- old_map.entry(size).or_insert_with(Vec::new);`
`317`		`- old_map.get_mut(&size).unwrap().push(fe);`
	`316`	`+ old_map.entry(size).or_insert_with(Vec::new).push(fe);`
`318`	`317`	`}`
`319`	`318`	`}`
`320`	`319`	`}`
Original file line number	Diff line number	Diff line change
`@@ -568,16 +568,13 @@ impl DuplicateFinder {`
`568`	`568`	`let name = file_entry.path.to_string_lossy().to_string();`
`569`	`569`	`if !loaded_hash_map2.contains_key(&name) {`
`570`	`570`	`// If loaded data doesn't contains current image info`
`571`		`- non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);`
`572`		`- non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry.clone());`
	`571`	`+ non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());`
`573`	`572`	`} else if file_entry.size != loaded_hash_map2.get(&name).unwrap().size \|\| file_entry.modified_date != loaded_hash_map2.get(&name).unwrap().modified_date {`
`574`	`573`	`// When size or modification date of image changed, then it is clear that is different image`
`575`		`- non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);`
`576`		`- non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry.clone());`
	`574`	`+ non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());`
`577`	`575`	`} else {`
`578`	`576`	`// Checking may be omitted when already there is entry with same size and modification date`
`579`		`- records_already_cached.entry(file_entry.size).or_insert_with(Vec::new);`
`580`		`- records_already_cached.get_mut(&file_entry.size).unwrap().push(file_entry.clone());`
	`577`	`+ records_already_cached.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry.clone());`
`581`	`578`	`}`
`582`	`579`	`}`
`583`	`580`	`}`
`@@ -602,8 +599,7 @@ impl DuplicateFinder {`
`602`	`599`	`}`
`603`	`600`	`match hash_calculation(&mut buffer, file_entry, &check_type, 0) {`
`604`	`601`	`Ok(hash_string) => {`
`605`		`- hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new);`
`606`		`- hashmap_with_hash.get_mut(hash_string.as_str()).unwrap().push(file_entry.clone());`
	`602`	`+ hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new).push(file_entry.clone());`
`607`	`603`	`}`
`608`	`604`	`Err(s) => errors.push(s),`
`609`	`605`	`}`
`@@ -624,17 +620,15 @@ impl DuplicateFinder {`
`624`	`620`
`625`	`621`	`// Add data from cache`
`626`	`622`	`for (size, vec_file_entry) in &records_already_cached {`
`627`		`- pre_checked_map.entry(*size).or_insert_with(Vec::new);`
`628`		`- pre_checked_map.get_mut(size).unwrap().append(&mut vec_file_entry.clone());`
	`623`	`+ pre_checked_map.entry(*size).or_insert_with(Vec::new).append(&mut vec_file_entry.clone());`
`629`	`624`	`}`
`630`	`625`
`631`	`626`	`// Check results`
`632`	`627`	`for (size, hash_map, errors) in &pre_hash_results {`
`633`	`628`	`self.text_messages.warnings.append(&mut errors.clone());`
`634`	`629`	`for vec_file_entry in hash_map.values() {`
`635`	`630`	`if vec_file_entry.len() > 1 {`
`636`		`- pre_checked_map.entry(*size).or_insert_with(Vec::new);`
`637`		`- pre_checked_map.get_mut(size).unwrap().append(&mut vec_file_entry.clone());`
	`631`	`+ pre_checked_map.entry(*size).or_insert_with(Vec::new).append(&mut vec_file_entry.clone());`
`638`	`632`	`}`
`639`	`633`	`}`
`640`	`634`	`}`
`@@ -732,16 +726,14 @@ impl DuplicateFinder {`
`732`	`726`	`let mut found: bool = false;`
`733`	`727`	`for loaded_file_entry in loaded_vec_file_entry {`
`734`	`728`	`if file_entry.path == loaded_file_entry.path && file_entry.modified_date == loaded_file_entry.modified_date {`
`735`		`- records_already_cached.entry(file_entry.size).or_insert_with(Vec::new);`
`736`		`- records_already_cached.get_mut(&file_entry.size).unwrap().push(loaded_file_entry.clone());`
	`729`	`+ records_already_cached.entry(file_entry.size).or_insert_with(Vec::new).push(loaded_file_entry.clone());`
`737`	`730`	`found = true;`
`738`	`731`	`break;`
`739`	`732`	`}`
`740`	`733`	`}`
`741`	`734`
`742`	`735`	`if !found {`
`743`		`- non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new);`
`744`		`- non_cached_files_to_check.get_mut(&file_entry.size).unwrap().push(file_entry);`
	`736`	`+ non_cached_files_to_check.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry);`
`745`	`737`	`}`
`746`	`738`	`}`
`747`	`739`	`}`
`@@ -768,8 +760,7 @@ impl DuplicateFinder {`
`768`	`760`	`match hash_calculation(&mut buffer, &file_entry, &check_type, u64::MAX) {`
`769`	`761`	`Ok(hash_string) => {`
`770`	`762`	`file_entry.hash = hash_string.clone();`
`771`		`- hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new);`
`772`		`- hashmap_with_hash.get_mut(hash_string.as_str()).unwrap().push(file_entry);`
	`763`	`+ hashmap_with_hash.entry(hash_string.clone()).or_insert_with(Vec::new).push(file_entry);`
`773`	`764`	`}`
`774`	`765`	`Err(s) => errors.push(s),`
`775`	`766`	`}`
`@@ -785,17 +776,15 @@ impl DuplicateFinder {`
`785`	`776`	`for (full_size, full_hashmap, _errors) in &mut full_hash_results {`
`786`	`777`	`if size == *full_size {`
`787`	`778`	`for file_entry in vec_file_entry {`
`788`		`- full_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new);`
`789`		`- full_hashmap.get_mut(&file_entry.hash).unwrap().push(file_entry);`
	`779`	`+ full_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new).push(file_entry);`
`790`	`780`	`}`
`791`	`781`	`continue 'main;`
`792`	`782`	`}`
`793`	`783`	`}`
`794`	`784`	`// Size doesn't exists add results to files`
`795`	`785`	`let mut temp_hashmap: BTreeMap<String, Vec<FileEntry>> = Default::default();`
`796`	`786`	`for file_entry in vec_file_entry {`
`797`		`- temp_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new);`
`798`		`- temp_hashmap.get_mut(&file_entry.hash).unwrap().push(file_entry);`
	`787`	`+ temp_hashmap.entry(file_entry.hash.clone()).or_insert_with(Vec::new).push(file_entry);`
`799`	`788`	`}`
`800`	`789`	`full_hash_results.push((size, temp_hashmap, Vec::new()));`
`801`	`790`	`}`
`@@ -830,8 +819,7 @@ impl DuplicateFinder {`
`830`	`819`	`self.text_messages.warnings.append(&mut errors);`
`831`	`820`	`for (_hash, vec_file_entry) in hash_map {`
`832`	`821`	`if vec_file_entry.len() > 1 {`
`833`		`- self.files_with_identical_hashes.entry(size).or_insert_with(Vec::new);`
`834`		`- self.files_with_identical_hashes.get_mut(&size).unwrap().push(vec_file_entry);`
	`822`	`+ self.files_with_identical_hashes.entry(size).or_insert_with(Vec::new).push(vec_file_entry);`
`835`	`823`	`}`
`836`	`824`	`}`
`837`	`825`	`}`
`@@ -1374,8 +1362,7 @@ pub fn load_hashes_from_file(text_messages: &mut Messages, delete_outdated_cache`
`1374`	`1362`	`hash: uuu[3].to_string(),`
`1375`	`1363`	`symlink_info: None,`
`1376`	`1364`	`};`
`1377`		`- hashmap_loaded_entries.entry(file_entry.size).or_insert_with(Vec::new);`
`1378`		`- hashmap_loaded_entries.get_mut(&file_entry.size).unwrap().push(file_entry);`
	`1365`	`+ hashmap_loaded_entries.entry(file_entry.size).or_insert_with(Vec::new).push(file_entry);`
`1379`	`1366`	`}`
`1380`	`1367`	`}`
`1381`	`1368`
Original file line number	Diff line number	Diff line change
`@@ -552,8 +552,7 @@ impl SameMusic {`
`552`	`552`	`get_approximate_conversion(&mut thing);`
`553`	`553`	`}`
`554`	`554`	`if !thing.is_empty() {`
`555`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`556`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`555`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`557`	`556`	`}`
`558`	`557`	`}`
`559`	`558`	`for (_title, vec_file_entry) in hash_map {`
`@@ -581,8 +580,7 @@ impl SameMusic {`
`581`	`580`	`get_approximate_conversion(&mut thing);`
`582`	`581`	`}`
`583`	`582`	`if !thing.is_empty() {`
`584`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`585`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`583`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`586`	`584`	`}`
`587`	`585`	`}`
`588`	`586`	`for (_title, vec_file_entry) in hash_map {`
`@@ -607,8 +605,7 @@ impl SameMusic {`
`607`	`605`	`for file_entry in vec_file_entry {`
`608`	`606`	`let thing = file_entry.year.to_lowercase().trim().to_string();`
`609`	`607`	`if !thing.is_empty() {`
`610`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`611`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`608`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`612`	`609`	`}`
`613`	`610`	`}`
`614`	`611`	`for (_title, vec_file_entry) in hash_map {`
`@@ -633,8 +630,7 @@ impl SameMusic {`
`633`	`630`	`for file_entry in vec_file_entry {`
`634`	`631`	`let thing = file_entry.length.to_lowercase().trim().to_string();`
`635`	`632`	`if !thing.is_empty() {`
`636`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`637`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`633`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`638`	`634`	`}`
`639`	`635`	`}`
`640`	`636`	`for (_title, vec_file_entry) in hash_map {`
`@@ -659,8 +655,7 @@ impl SameMusic {`
`659`	`655`	`for file_entry in vec_file_entry {`
`660`	`656`	`let thing = file_entry.genre.to_lowercase().trim().to_string();`
`661`	`657`	`if !thing.is_empty() {`
`662`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`663`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`658`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`664`	`659`	`}`
`665`	`660`	`}`
`666`	`661`	`for (_title, vec_file_entry) in hash_map {`
`@@ -686,8 +681,7 @@ impl SameMusic {`
`686`	`681`	`if file_entry.bitrate != 0 {`
`687`	`682`	`let thing = file_entry.bitrate.to_string();`
`688`	`683`	`if !thing.is_empty() {`
`689`		`- hash_map.entry(thing.clone()).or_insert_with(Vec::new);`
`690`		`- hash_map.get_mut(thing.as_str()).unwrap().push(file_entry);`
	`684`	`+ hash_map.entry(thing.clone()).or_insert_with(Vec::new).push(file_entry);`
`691`	`685`	`}`
`692`	`686`	`}`
`693`	`687`	`}`
Original file line number	Diff line number	Diff line change
`@@ -631,8 +631,7 @@ impl SimilarImages {`
`631`	`631`	`for (file_entry, buf) in &vec_file_entry {`
`632`	`632`	`// Only use to comparing, non broken hashes(all 0 or 255 hashes means that algorithm fails to decode them because e.g. contains a log of alpha channel)`
`633`	`633`	`if !(buf.is_empty() \|\| buf.iter().all(\|e\| e == 0) \|\| buf.iter().all(\|e\| e == 255)) {`
`634`		`- self.image_hashes.entry(buf.clone()).or_insert_with(Vec::<FileEntry>::new);`
`635`		`- self.image_hashes.get_mut(buf).unwrap().push(file_entry.clone());`
	`634`	`+ self.image_hashes.entry(buf.clone()).or_insert_with(Vec::<FileEntry>::new).push(file_entry.clone());`
`636`	`635`	`}`
`637`	`636`	`}`
`638`	`637`
Original file line number	Diff line number	Diff line change
`@@ -503,8 +503,7 @@ pub fn tree_remove(`
`503`	`503`
`504`	`504`	`model.remove(&iter);`
`505`	`505`
`506`		`- map_with_path_to_delete.entry(path.clone()).or_insert_with(Vec::new);`
`507`		`- map_with_path_to_delete.get_mut(path.as_str()).unwrap().push(file_name);`
	`506`	`+ map_with_path_to_delete.entry(path.clone()).or_insert_with(Vec::new).push(file_name);`
`508`	`507`	`}`
`509`	`508`
`510`	`509`	`// Delete duplicated entries, and remove real files`