/* Composes two views containing only files that are unique to each of them.
* Assumes that both lists are sorted by id. */
static void
make_unique_lists(entries_t curr, entries_t other)
{
int i, j = 0;
flist_custom_start(curr_view, "unique");
flist_custom_start(other_view, "unique");
for(i = 0; i < other.nentries; ++i)
{
const int id = other.entries[i].id;
while(j < curr.nentries && curr.entries[j].id < id)
{
flist_custom_put(curr_view, &curr.entries[j]);
++j;
}
if(j >= curr.nentries || curr.entries[j].id != id)
{
flist_custom_put(other_view, &other.entries[i]);
continue;
}
while(j < curr.nentries && curr.entries[j].id == id)
{
free_dir_entry(curr_view, &curr.entries[j++]);
}
while(i < other.nentries && other.entries[i].id == id)
{
free_dir_entry(other_view, &other.entries[i++]);
}
--i;
}
/* Entries' data has been moved out of them or freed, so need to free only the
* lists. */
dynarray_free(curr.entries);
dynarray_free(other.entries);
(void)flist_custom_finish(curr_view, CV_REGULAR, 1);
(void)flist_custom_finish(other_view, CV_REGULAR, 1);
curr_view->list_pos = 0;
other_view->list_pos = 0;
ui_view_schedule_redraw(curr_view);
ui_view_schedule_redraw(other_view);
}
TEARDOWN()
{
int i;
reset_status(&cfg);
for(i = 0; i < lwin.list_rows; ++i)
{
free_dir_entry(&lwin, &lwin.dir_entry[i]);
}
dynarray_free(lwin.dir_entry);
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
for(i = 0; i < view->custom.entry_count; ++i)
{
free_dir_entry(view, &view->custom.entries[i]);
}
dynarray_free(view->custom.entries);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->auto_filter);
filter_dispose(&view->manual_filter);
}
static void
teardown_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
view->list_rows = 0;
view->selected_files = 0;
}
/* Either puts the entry into the view or frees it (depends on the take
* argument). */
static void
put_or_free(FileView *view, dir_entry_t *entry, int id, int take)
{
if(take)
{
entry->id = id;
flist_custom_put(view, entry);
}
else
{
free_dir_entry(view, entry);
}
}
TEARDOWN()
{
int i;
update_string(&cfg.shell, NULL);
stats_update_shell_type("/bin/sh");
for(i = 0; i < lwin.list_rows; ++i)
{
free_dir_entry(&lwin, &lwin.dir_entry[i]);
}
dynarray_free(lwin.dir_entry);
ft_reset(0);
update_string(&cfg.vi_command, NULL);
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
fswatch_free(view->watch);
view->watch = NULL;
}
/* Makes sorted by path list of entries that. The trie is used to keep track of
* identical files. With non-zero dups_only, new files aren't added to the
* trie. */
static entries_t
make_diff_list(trie_t *trie, FileView *view, int *next_id, CompareType ct,
int skip_empty, int dups_only)
{
int i;
strlist_t files = {};
entries_t r = {};
int last_progress = 0;
show_progress("Listing...", 0);
if(flist_custom_active(view) &&
ONE_OF(view->custom.type, CV_REGULAR, CV_VERY))
{
list_view_entries(view, &files);
}
else
{
list_files_recursively(flist_get_dir(view), view->hide_dot, &files);
}
show_progress("Querying...", 0);
for(i = 0; i < files.nitems && !ui_cancellation_requested(); ++i)
{
char progress_msg[128];
int progress;
int existing_id;
char *fingerprint;
const char *const path = files.items[i];
dir_entry_t *const entry = entry_list_add(view, &r.entries, &r.nentries,
path);
if(skip_empty && entry->size == 0)
{
free_dir_entry(view, entry);
--r.nentries;
continue;
}
fingerprint = get_file_fingerprint(path, entry, ct);
/* In case we couldn't obtain fingerprint (e.g., comparing by contents and
* files isn't readable), ignore the file and keep going. */
if(is_null_or_empty(fingerprint))
{
free(fingerprint);
free_dir_entry(view, entry);
--r.nentries;
continue;
}
entry->tag = i;
if(get_file_id(trie, path, fingerprint, &existing_id, ct))
{
entry->id = existing_id;
}
else if(dups_only)
{
entry->id = -1;
}
else
{
entry->id = *next_id;
++*next_id;
put_file_id(trie, path, fingerprint, entry->id, ct);
}
free(fingerprint);
progress = (i*100)/files.nitems;
if(progress != last_progress)
{
last_progress = progress;
snprintf(progress_msg, sizeof(progress_msg), "Querying... %d (% 2d%%)", i,
progress);
show_progress(progress_msg, -1);
}
}
free_string_array(files.items, files.nitems);
return r;
}
