CodeMirror/czkawka
1
0
Fork 0
mirror of synced 2024-05-21 12:52:37 +12:00
Code Issues Projects Releases Wiki Activity

Cache common

Browse source
This commit is contained in:
Rafał Mikrut 2023-10-06 17:55:52 +02:00
parent 700303941e
commit b1cf6e5527
7 changed files with 183 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
czkawka_core/src/broken_files.rs
View file

@ -18,9 +18,10 @@ use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use crate::common::{
check_folder_children, create_crash_message, load_cache_from_file_generalized, prepare_thread_handler_common, save_cache_to_file_generalized,
send_info_and_wait_for_ending_all_threads, AUDIO_FILES_EXTENSIONS, IMAGE_RS_BROKEN_FILES_EXTENSIONS, PDF_FILES_EXTENSIONS, ZIP_FILES_EXTENSIONS,
check_folder_children, create_crash_message, prepare_thread_handler_common, send_info_and_wait_for_ending_all_threads, AUDIO_FILES_EXTENSIONS,
IMAGE_RS_BROKEN_FILES_EXTENSIONS, PDF_FILES_EXTENSIONS, ZIP_FILES_EXTENSIONS,
};
use crate::common_cache::{get_broken_files_cache_file, load_cache_from_file_generalized, save_cache_to_file_generalized};
use crate::common_dir_traversal::{common_get_entry_data_metadata, common_read_dir, get_lowercase_name, get_modified_time, CheckingMethod, ProgressData, ToolType};
use crate::common_tool::{CommonData, CommonToolData};
use crate::common_traits::*;
@ -356,7 +357,7 @@ impl BrokenFiles {
let files_to_check = mem::take(&mut self.files_to_check);
if self.common_data.use_cache {
let (messages, loaded_items) = load_cache_from_file_generalized::<FileEntry>(&get_cache_file(), self.get_delete_outdated_cache(), &files_to_check);
let (messages, loaded_items) = load_cache_from_file_generalized::<FileEntry>(&get_broken_files_cache_file(), self.get_delete_outdated_cache(), &files_to_check);
self.get_text_messages_mut().extend_with_another_messages(messages);
loaded_hash_map = loaded_items.unwrap_or_default();
@ -437,7 +438,7 @@ impl BrokenFiles {
all_results.insert(file_entry.path.to_string_lossy().to_string(), file_entry);
}
let messages = save_cache_to_file_generalized(&get_cache_file(), &all_results, self.common_data.save_also_as_json);
let messages = save_cache_to_file_generalized(&get_broken_files_cache_file(), &all_results, self.common_data.save_also_as_json);
self.get_text_messages_mut().extend_with_another_messages(messages);
}
debug!("save_to_cache - end");
@ -534,10 +535,6 @@ impl PrintResults for BrokenFiles {
}
}
fn get_cache_file() -> String {
"cache_broken_files_61.bin".to_string()
}
fn check_extension_availability(file_name_lowercase: &str) -> TypeOfFile {
if IMAGE_RS_BROKEN_FILES_EXTENSIONS.iter().any(|e| file_name_lowercase.ends_with(e)) {
TypeOfFile::Image

125
czkawka_core/src/common.rs
View file

@ -1,8 +1,6 @@
use rayon::iter::ParallelIterator;
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::fs::{DirEntry, File, OpenOptions};
use std::io::{BufReader, BufWriter};
use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
@ -20,15 +18,12 @@ use imagepipe::{ImageSource, Pipeline};
#[cfg(feature = "heif")]
use libheif_rs::{ColorSpace, HeifContext, RgbChroma};
use log::{debug, LevelFilter, Record};
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
// #[cfg(feature = "heif")]
// use libheif_rs::LibHeif;
use crate::common_dir_traversal::{CheckingMethod, ProgressData, ToolType};
use crate::common_directory::Directories;
use crate::common_items::ExcludedItems;
use crate::common_messages::Messages;
use crate::common_traits::ResultEntry;
static NUMBER_OF_THREADS: state::InitCell<usize> = state::InitCell::new();
@ -160,124 +155,6 @@ pub fn open_cache_folder(cache_file_name: &str, save_to_cache: bool, use_json: b
None
}
pub fn save_cache_to_file_generalized<T>(cache_file_name: &str, hashmap: &BTreeMap<String, T>, save_also_as_json: bool) -> Messages
where
T: Serialize + ResultEntry + Sized + Send + Sync,
{
debug!("Saving cache to file {} (or also json alternative) - {} results", cache_file_name, hashmap.len());
let mut text_messages = Messages::new();
if let Some(((file_handler, cache_file), (file_handler_json, cache_file_json))) = open_cache_folder(cache_file_name, true, save_also_as_json, &mut text_messages.warnings) {
{
let writer = BufWriter::new(file_handler.unwrap()); // Unwrap because cannot fail here
if let Err(e) = bincode::serialize_into(writer, &hashmap.values().collect::<Vec<_>>()) {
text_messages
.warnings
.push(format!("Cannot write data to cache file {}, reason {}", cache_file.display(), e));
debug!("Failed to save cache to file {:?}", cache_file);
return text_messages;
}
debug!("Saved binary to file {:?}", cache_file);
}
if save_also_as_json {
if let Some(file_handler_json) = file_handler_json {
let writer = BufWriter::new(file_handler_json);
if let Err(e) = serde_json::to_writer(writer, &hashmap.values().collect::<Vec<_>>()) {
text_messages
.warnings
.push(format!("Cannot write data to cache file {}, reason {}", cache_file_json.display(), e));
debug!("Failed to save cache to file {:?}", cache_file_json);
return text_messages;
}
debug!("Saved json to file {:?}", cache_file_json);
}
}
text_messages.messages.push(format!("Properly saved to file {} cache entries.", hashmap.len()));
} else {
debug!("Failed to save cache to file {cache_file_name} because not exists");
}
text_messages
}
pub fn load_cache_from_file_generalized<T>(cache_file_name: &str, delete_outdated_cache: bool, used_files: &BTreeMap<String, T>) -> (Messages, Option<BTreeMap<String, T>>)
where
for<'a> T: Deserialize<'a> + ResultEntry + Sized + Send + Sync,
{
debug!("Loading cache from file {} (or json alternative)", cache_file_name);
let mut text_messages = Messages::new();
if let Some(((file_handler, cache_file), (file_handler_json, cache_file_json))) = open_cache_folder(cache_file_name, false, true, &mut text_messages.warnings) {
let mut vec_loaded_entries: Vec<T>;
if let Some(file_handler) = file_handler {
let reader = BufReader::new(file_handler);
vec_loaded_entries = match bincode::deserialize_from(reader) {
Ok(t) => t,
Err(e) => {
text_messages
.warnings
.push(format!("Failed to load data from cache file {}, reason {}", cache_file.display(), e));
debug!("Failed to load cache from file {:?}", cache_file);
return (text_messages, None);
}
};
} else {
let reader = BufReader::new(file_handler_json.unwrap()); // Unwrap cannot fail, because at least one file must be valid
vec_loaded_entries = match serde_json::from_reader(reader) {
Ok(t) => t,
Err(e) => {
text_messages
.warnings
.push(format!("Failed to load data from cache file {}, reason {}", cache_file_json.display(), e));
debug!("Failed to load cache from file {:?}", cache_file);
return (text_messages, None);
}
};
}
// Don't load cache data if destination file not exists
if delete_outdated_cache {
debug!("Starting to removing outdated cache entries");
let initial_number_of_entries = vec_loaded_entries.len();
vec_loaded_entries = vec_loaded_entries
.into_par_iter()
.filter(|file_entry| {
if delete_outdated_cache && !file_entry.get_path().exists() {
return false;
}
let file_entry_path_str = file_entry.get_path().to_string_lossy().to_string();
if let Some(used_file) = used_files.get(&file_entry_path_str) {
if file_entry.get_size() != used_file.get_size() {
return false;
}
if file_entry.get_modified_date() != used_file.get_modified_date() {
return false;
}
}
true
})
.collect();
debug!(
"Completed removing outdated cache entries, removed {} out of all {} entries",
initial_number_of_entries - vec_loaded_entries.len(),
initial_number_of_entries
);
}
text_messages.messages.push(format!("Properly loaded {} cache entries.", vec_loaded_entries.len()));
let map_loaded_entries: BTreeMap<_, _> = vec_loaded_entries
.into_iter()
.map(|file_entry| (file_entry.get_path().to_string_lossy().into_owned(), file_entry))
.collect();
debug!("Loaded cache from file {cache_file_name} (or json alternative) - {} results", map_loaded_entries.len());
return (text_messages, Some(map_loaded_entries));
}
debug!("Failed to load cache from file {cache_file_name} because not exists");
(text_messages, None)
}
#[cfg(feature = "heif")]
pub fn get_dynamic_image_from_heic(path: &str) -> Result<DynamicImage> {
// let libheif = LibHeif::new();

156
czkawka_core/src/common_cache.rs
View file

@ -0,0 +1,156 @@
use crate::common;
use crate::common_messages::Messages;
use crate::common_traits::ResultEntry;
use crate::similar_images::{convert_algorithm_to_string, convert_filters_to_string};
use image::imageops::FilterType;
use image_hasher::HashAlg;
use log::debug;
use rayon::iter::{IntoParallelIterator, ParallelIterator};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::io::{BufReader, BufWriter};
pub fn get_broken_files_cache_file() -> String {
"cache_broken_files_61.bin".to_string()
}
pub fn get_similar_images_cache_file(hash_size: &u8, hash_alg: &HashAlg, image_filter: &FilterType) -> String {
format!(
"cache_similar_images_{}_{}_{}_61.bin",
hash_size,
convert_algorithm_to_string(hash_alg),
convert_filters_to_string(image_filter),
)
}
pub fn get_similar_videos_cache_file() -> String {
"cache_similar_videos_61.bin".to_string()
}
pub fn get_similar_music_cache_file(checking_tags: bool) -> &'static str {
if checking_tags {
"cache_same_music_tags_61.bin"
} else {
"cache_same_music_fingerprints_61.bin"
}
}
pub fn save_cache_to_file_generalized<T>(cache_file_name: &str, hashmap: &BTreeMap<String, T>, save_also_as_json: bool) -> Messages
where
T: Serialize + ResultEntry + Sized + Send + Sync,
{
debug!("Saving cache to file {} (or also json alternative) - {} results", cache_file_name, hashmap.len());
let mut text_messages = Messages::new();
if let Some(((file_handler, cache_file), (file_handler_json, cache_file_json))) =
common::open_cache_folder(cache_file_name, true, save_also_as_json, &mut text_messages.warnings)
{
{
let writer = BufWriter::new(file_handler.unwrap()); // Unwrap because cannot fail here
if let Err(e) = bincode::serialize_into(writer, &hashmap.values().collect::<Vec<_>>()) {
text_messages
.warnings
.push(format!("Cannot write data to cache file {}, reason {}", cache_file.display(), e));
debug!("Failed to save cache to file {:?}", cache_file);
return text_messages;
}
debug!("Saved binary to file {:?}", cache_file);
}
if save_also_as_json {
if let Some(file_handler_json) = file_handler_json {
let writer = BufWriter::new(file_handler_json);
if let Err(e) = serde_json::to_writer(writer, &hashmap.values().collect::<Vec<_>>()) {
text_messages
.warnings
.push(format!("Cannot write data to cache file {}, reason {}", cache_file_json.display(), e));
debug!("Failed to save cache to file {:?}", cache_file_json);
return text_messages;
}
debug!("Saved json to file {:?}", cache_file_json);
}
}
text_messages.messages.push(format!("Properly saved to file {} cache entries.", hashmap.len()));
} else {
debug!("Failed to save cache to file {cache_file_name} because not exists");
}
text_messages
}
pub fn load_cache_from_file_generalized<T>(cache_file_name: &str, delete_outdated_cache: bool, used_files: &BTreeMap<String, T>) -> (Messages, Option<BTreeMap<String, T>>)
where
for<'a> T: Deserialize<'a> + ResultEntry + Sized + Send + Sync,
{
debug!("Loading cache from file {} (or json alternative)", cache_file_name);
let mut text_messages = Messages::new();
if let Some(((file_handler, cache_file), (file_handler_json, cache_file_json))) = common::open_cache_folder(cache_file_name, false, true, &mut text_messages.warnings) {
let mut vec_loaded_entries: Vec<T>;
if let Some(file_handler) = file_handler {
let reader = BufReader::new(file_handler);
vec_loaded_entries = match bincode::deserialize_from(reader) {
Ok(t) => t,
Err(e) => {
text_messages
.warnings
.push(format!("Failed to load data from cache file {}, reason {}", cache_file.display(), e));
debug!("Failed to load cache from file {:?}", cache_file);
return (text_messages, None);
}
};
} else {
let reader = BufReader::new(file_handler_json.unwrap()); // Unwrap cannot fail, because at least one file must be valid
vec_loaded_entries = match serde_json::from_reader(reader) {
Ok(t) => t,
Err(e) => {
text_messages
.warnings
.push(format!("Failed to load data from cache file {}, reason {}", cache_file_json.display(), e));
debug!("Failed to load cache from file {:?}", cache_file);
return (text_messages, None);
}
};
}
// Don't load cache data if destination file not exists
if delete_outdated_cache {
debug!("Starting to removing outdated cache entries");
let initial_number_of_entries = vec_loaded_entries.len();
vec_loaded_entries = vec_loaded_entries
.into_par_iter()
.filter(|file_entry| {
if delete_outdated_cache && !file_entry.get_path().exists() {
return false;
}
let file_entry_path_str = file_entry.get_path().to_string_lossy().to_string();
if let Some(used_file) = used_files.get(&file_entry_path_str) {
if file_entry.get_size() != used_file.get_size() {
return false;
}
if file_entry.get_modified_date() != used_file.get_modified_date() {
return false;
}
}
true
})
.collect();
debug!(
"Completed removing outdated cache entries, removed {} out of all {} entries",
initial_number_of_entries - vec_loaded_entries.len(),
initial_number_of_entries
);
}
text_messages.messages.push(format!("Properly loaded {} cache entries.", vec_loaded_entries.len()));
let map_loaded_entries: BTreeMap<_, _> = vec_loaded_entries
.into_iter()
.map(|file_entry| (file_entry.get_path().to_string_lossy().into_owned(), file_entry))
.collect();
debug!("Loaded cache from file {cache_file_name} (or json alternative) - {} results", map_loaded_entries.len());
return (text_messages, Some(map_loaded_entries));
}
debug!("Failed to load cache from file {cache_file_name} because not exists");
(text_messages, None)
}

20
czkawka_core/src/same_music.rs
View file

@ -23,10 +23,8 @@ use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::probe::Hint;
use crate::common::{
create_crash_message, filter_reference_folders_generic, load_cache_from_file_generalized, prepare_thread_handler_common, save_cache_to_file_generalized,
send_info_and_wait_for_ending_all_threads, AUDIO_FILES_EXTENSIONS,
};
use crate::common::{create_crash_message, filter_reference_folders_generic, prepare_thread_handler_common, send_info_and_wait_for_ending_all_threads, AUDIO_FILES_EXTENSIONS};
use crate::common_cache::{get_similar_music_cache_file, load_cache_from_file_generalized, save_cache_to_file_generalized};
use crate::common_dir_traversal::{CheckingMethod, DirTraversalBuilder, DirTraversalResult, FileEntry, ProgressData, ToolType};
use crate::common_tool::{CommonData, CommonToolData};
use crate::common_traits::*;
@ -235,7 +233,8 @@ impl SameMusic {
let mut non_cached_files_to_check: BTreeMap<String, MusicEntry> = Default::default();
if self.common_data.use_cache {
let (messages, loaded_items) = load_cache_from_file_generalized::<MusicEntry>(get_cache_file(checking_tags), self.get_delete_outdated_cache(), &self.music_to_check);
let (messages, loaded_items) =
load_cache_from_file_generalized::<MusicEntry>(get_similar_music_cache_file(checking_tags), self.get_delete_outdated_cache(), &self.music_to_check);
self.get_text_messages_mut().extend_with_another_messages(messages);
loaded_hash_map = loaded_items.unwrap_or_default();
@ -266,7 +265,7 @@ impl SameMusic {
all_results.insert(file_entry.path.to_string_lossy().to_string(), file_entry);
}
let messages = save_cache_to_file_generalized(get_cache_file(checking_tags), &all_results, self.common_data.save_also_as_json);
let messages = save_cache_to_file_generalized(get_similar_music_cache_file(checking_tags), &all_results, self.common_data.save_also_as_json);
self.get_text_messages_mut().extend_with_another_messages(messages);
debug!("save_cache - end");
}
@ -907,15 +906,6 @@ fn read_single_file_tag(path: &str, music_entry: &mut MusicEntry) -> bool {
true
}
// Using different cache folders, because loading cache just for finding duplicated tags would be really slow
fn get_cache_file(checking_tags: bool) -> &'static str {
if checking_tags {
"cache_same_music_tags_61.bin"
} else {
"cache_same_music_fingerprints_61.bin"
}
}
impl Default for SameMusic {
fn default() -> Self {
Self::new()

22
czkawka_core/src/similar_images.rs
View file

@ -19,9 +19,10 @@ use serde::{Deserialize, Serialize};
#[cfg(feature = "heif")]
use crate::common::get_dynamic_image_from_heic;
use crate::common::{
check_folder_children, create_crash_message, get_dynamic_image_from_raw_image, load_cache_from_file_generalized, prepare_thread_handler_common, save_cache_to_file_generalized,
send_info_and_wait_for_ending_all_threads, HEIC_EXTENSIONS, IMAGE_RS_SIMILAR_IMAGES_EXTENSIONS, RAW_IMAGE_EXTENSIONS,
check_folder_children, create_crash_message, get_dynamic_image_from_raw_image, prepare_thread_handler_common, send_info_and_wait_for_ending_all_threads, HEIC_EXTENSIONS,
IMAGE_RS_SIMILAR_IMAGES_EXTENSIONS, RAW_IMAGE_EXTENSIONS,
};
use crate::common_cache::{get_similar_images_cache_file, load_cache_from_file_generalized, save_cache_to_file_generalized};
use crate::common_dir_traversal::{common_get_entry_data_metadata, common_read_dir, get_lowercase_name, get_modified_time, CheckingMethod, ProgressData, ToolType};
use crate::common_tool::{CommonData, CommonToolData};
use crate::common_traits::{DebugPrint, PrintResults, ResultEntry, SaveResults};
@ -287,7 +288,7 @@ impl SimilarImages {
if self.common_data.use_cache {
let (messages, loaded_items) = load_cache_from_file_generalized::<FileEntry>(
&get_cache_file(&self.hash_size, &self.hash_alg, &self.image_filter),
&get_similar_images_cache_file(&self.hash_size, &self.hash_alg, &self.image_filter),
self.get_delete_outdated_cache(),
&self.images_to_check,
);
@ -377,7 +378,7 @@ impl SimilarImages {
}
let messages = save_cache_to_file_generalized(
&get_cache_file(&self.hash_size, &self.hash_alg, &self.image_filter),
&get_similar_images_cache_file(&self.hash_size, &self.hash_alg, &self.image_filter),
&all_results,
self.common_data.save_also_as_json,
);
@ -938,15 +939,6 @@ impl PrintResults for SimilarImages {
}
}
pub fn get_cache_file(hash_size: &u8, hash_alg: &HashAlg, image_filter: &FilterType) -> String {
format!(
"cache_similar_images_{}_{}_{}_61.bin",
hash_size,
convert_algorithm_to_string(hash_alg),
convert_filters_to_string(image_filter),
)
}
pub fn get_string_from_similarity(similarity: &u32, hash_size: u8) -> String {
let index_preset = match hash_size {
8 => 0,
@ -995,7 +987,7 @@ pub fn return_similarity_from_similarity_preset(similarity_preset: &SimilarityPr
}
}
fn convert_filters_to_string(image_filter: &FilterType) -> String {
pub fn convert_filters_to_string(image_filter: &FilterType) -> String {
match image_filter {
FilterType::Lanczos3 => "Lanczos3",
FilterType::Nearest => "Nearest",
@ -1006,7 +998,7 @@ fn convert_filters_to_string(image_filter: &FilterType) -> String {
.to_string()
}
fn convert_algorithm_to_string(hash_alg: &HashAlg) -> String {
pub fn convert_algorithm_to_string(hash_alg: &HashAlg) -> String {
match hash_alg {
HashAlg::Mean => "Mean",
HashAlg::Gradient => "Gradient",

14
czkawka_core/src/similar_videos.rs
View file

@ -15,10 +15,8 @@ use serde::{Deserialize, Serialize};
use vid_dup_finder_lib::HashCreationErrorKind::DetermineVideo;
use vid_dup_finder_lib::{NormalizedTolerance, VideoHash};
use crate::common::{
check_folder_children, load_cache_from_file_generalized, prepare_thread_handler_common, save_cache_to_file_generalized, send_info_and_wait_for_ending_all_threads,
VIDEO_FILES_EXTENSIONS,
};
use crate::common::{check_folder_children, prepare_thread_handler_common, send_info_and_wait_for_ending_all_threads, VIDEO_FILES_EXTENSIONS};
use crate::common_cache::{get_similar_videos_cache_file, load_cache_from_file_generalized, save_cache_to_file_generalized};
use crate::common_dir_traversal::{common_get_entry_data_metadata, common_read_dir, get_lowercase_name, get_modified_time, CheckingMethod, ProgressData, ToolType};
use crate::common_tool::{CommonData, CommonToolData};
use crate::common_traits::{DebugPrint, PrintResults, ResultEntry, SaveResults};
@ -267,7 +265,7 @@ impl SimilarVideos {
let mut non_cached_files_to_check: BTreeMap<String, FileEntry> = Default::default();
if self.common_data.use_cache {
let (messages, loaded_items) = load_cache_from_file_generalized::<FileEntry>(&get_cache_file(), self.get_delete_outdated_cache(), &self.videos_to_check);
let (messages, loaded_items) = load_cache_from_file_generalized::<FileEntry>(&get_similar_videos_cache_file(), self.get_delete_outdated_cache(), &self.videos_to_check);
self.get_text_messages_mut().extend_with_another_messages(messages);
loaded_hash_map = loaded_items.unwrap_or_default();
@ -375,7 +373,7 @@ impl SimilarVideos {
all_results.insert(file_entry.path.to_string_lossy().to_string(), file_entry);
}
let messages = save_cache_to_file_generalized(&get_cache_file(), &all_results, self.common_data.save_also_as_json);
let messages = save_cache_to_file_generalized(&get_similar_videos_cache_file(), &all_results, self.common_data.save_also_as_json);
self.get_text_messages_mut().extend_with_another_messages(messages);
}
debug!("save_cache - end");
@ -513,10 +511,6 @@ impl PrintResults for SimilarVideos {
}
}
pub fn get_cache_file() -> String {
"cache_similar_videos_61.bin".to_string()
}
pub fn check_if_ffmpeg_is_installed() -> bool {
let vid = "9999czekoczekoczekolada999.txt";
if let Err(DetermineVideo {

10
czkawka_gui/src/connect_things/connect_settings.rs
View file

@ -1,7 +1,7 @@
use std::collections::BTreeMap;
use std::default::Default;
use czkawka_core::common::{load_cache_from_file_generalized, save_cache_to_file_generalized};
use czkawka_core::common_cache::{get_similar_images_cache_file, get_similar_videos_cache_file, load_cache_from_file_generalized, save_cache_to_file_generalized};
use directories_next::ProjectDirs;
use gtk4::prelude::*;
use gtk4::{Label, ResponseType, Window};
@ -171,14 +171,14 @@ pub fn connect_settings(gui_data: &GuiData) {
] {
for hash_alg in &[HashAlg::Blockhash, HashAlg::Gradient, HashAlg::DoubleGradient, HashAlg::VertGradient, HashAlg::Mean] {
let (mut messages, loaded_items) = load_cache_from_file_generalized::<czkawka_core::similar_images::FileEntry>(
&czkawka_core::similar_images::get_cache_file(hash_size, hash_alg, image_filter),
&get_similar_images_cache_file(hash_size, hash_alg, image_filter),
true,
&Default::default(),
);
if let Some(cache_entries) = loaded_items {
let save_messages =
save_cache_to_file_generalized(&czkawka_core::similar_images::get_cache_file(hash_size, hash_alg, image_filter), &cache_entries, false);
save_cache_to_file_generalized(&get_similar_images_cache_file(hash_size, hash_alg, image_filter), &cache_entries, false);
messages.extend_with_another_messages(save_messages);
}
}
@ -206,10 +206,10 @@ pub fn connect_settings(gui_data: &GuiData) {
dialog.connect_response(move |dialog, response_type| {
if response_type == ResponseType::Ok {
let (mut messages, loaded_items) =
load_cache_from_file_generalized::<czkawka_core::similar_videos::FileEntry>(&czkawka_core::similar_videos::get_cache_file(), true, &Default::default());
load_cache_from_file_generalized::<czkawka_core::similar_videos::FileEntry>(&get_similar_videos_cache_file(), true, &Default::default());
if let Some(cache_entries) = loaded_items {
let save_messages = save_cache_to_file_generalized(&czkawka_core::similar_videos::get_cache_file(), &cache_entries, false);
let save_messages = save_cache_to_file_generalized(&get_similar_videos_cache_file(), &cache_entries, false);
messages.extend_with_another_messages(save_messages);
}