int main(void) {
RmTrie trie;
rm_trie_init(&trie);
GTimer *timer = g_timer_new();
g_timer_start(timer);
char buf[1024];
int i = 0;
while(fgets(buf, sizeof(buf), stdin)) {
buf[strlen(buf) - 1] = 0;
rm_trie_insert(&trie, buf, GUINT_TO_POINTER(++i));
memset(buf, 0, sizeof(buf));
}
g_printerr("Took %2.5f to insert %d items\n", g_timer_elapsed(timer, NULL), i);
rm_trie_print(&trie);
memset(buf, 0, sizeof(buf));
rm_trie_build_path(&trie, rm_trie_search_node(&trie, "/usr/bin/rmlint"), buf,
sizeof(buf));
g_printerr("=> %s\n", buf);
g_timer_start(timer);
const int N = 10000000;
for(int x = 0; x < N; x++) {
rm_trie_search(&trie, "/usr/bin/rmlint");
}
g_printerr("Took %2.5f to search\n", g_timer_elapsed(timer, NULL));
g_printerr("%u\n", GPOINTER_TO_UINT(rm_trie_search(&trie, "/usr/bin/rmlint")));
g_printerr("%u\n", GPOINTER_TO_UINT(rm_trie_search(&trie, "/a/b/c")));
rm_trie_destroy(&trie);
g_timer_destroy(timer);
return 0;
}
static ino_t rm_path_parent_inode(RmFile *file) {
char parent_path[PATH_MAX];
rm_trie_build_path((RmTrie *)&file->session->cfg->file_trie, file->folder->parent, parent_path, PATH_MAX);
RmStat stat_buf;
int retval = rm_sys_stat(parent_path, &stat_buf);
rm_assert_gentle(retval != -1);
return stat_buf.st_ino;
}
static ino_t rm_path_parent_inode(RmFile *file) {
char parent_path[PATH_MAX];
rm_trie_build_path((RmTrie *)&file->session->cfg->file_trie, file->folder->parent, parent_path, PATH_MAX);
RmStat stat_buf;
int retval = rm_sys_stat(parent_path, &stat_buf);
if (retval == -1) {
rm_log_error_line("Failed to get parent path: stat failed: %s", g_strerror(errno));
return 0;
}
return stat_buf.st_ino;
}
int rm_tm_count_art_callback(RmTrie *self, RmNode *node, _U int level, void *user_data) {
/* Note: this method has a time complexity of O(log(n) * m) which may
result in a few seconds buildup time for large sets of directories. Since this
will only happen when rmlint ran for long anyways and since we can keep the
code easy and memory efficient this way, Im against more clever but longer
solutions. (Good way of saying "Im just too stupid", eh?)
*/
RmTrie *count_tree = user_data;
bool error_flag = GPOINTER_TO_INT(node->data);
char path[PATH_MAX];
memset(path, 0, sizeof(path));
rm_trie_build_path(self, node, path, sizeof(path));
/* Ascend the path parts up, add one for each part we meet.
If a part was never found before, add it.
This is the 'm' above: The count of separators in the path.
Hack: path[key_len] is nul, at key_len it must be either an
extra slash (bad) or the beginning of a file name.
Therefore start at -2.
*/
for(int i = strlen(path) - 1; i >= 0; --i) {
if(path[i] == G_DIR_SEPARATOR) {
/* Do not use an empty path, use a slash for root */
if(i == 0) {
path[0] = G_DIR_SEPARATOR;
path[1] = 0;
} else {
path[i] = 0;
}
/* Include the nulbyte */
int new_count = -1;
if(error_flag == false) {
/* Lookup the count on this level */
int old_count = GPOINTER_TO_INT(rm_trie_search(count_tree, path));
/* Propagate old error up or just increment the count */
new_count = (old_count == -1) ? -1 : old_count + 1;
}
/* Accumulate the count ('n' above is the height of the trie) */
rm_trie_insert(count_tree, path, GINT_TO_POINTER(new_count));
}
}
return 0;
}
void rm_file_build_path(RmFile *file, char *buf) {
g_assert(file);
rm_trie_build_path(&file->session->cfg->file_trie, file->folder, buf, PATH_MAX);
}
