aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/database.c138
-rw-r--r--src/db.dbbin715 -> 0 bytes
-rw-r--r--src/main.c26
-rw-r--r--src/main.exebin73988 -> 0 bytes
-rw-r--r--src/storage.c131
5 files changed, 159 insertions, 136 deletions
diff --git a/src/database.c b/src/database.c
index 5b6249b..f930539 100644
--- a/src/database.c
+++ b/src/database.c
@@ -14,28 +14,17 @@ database *newDatabase(char *name){
return db;
}
-static void increaseCount(ctable *ct, uint64_t i){
- ct->table[i]++;
-}
-
-static void decreaseCount(ctable *ct, uint64_t i){
- ct->table[i]--;
-}
-
uint64_t addFile(database *db, char *file){
uint32_t l;
file = normalizeStrLimit(file, &l, MAXPATH-1);
uint64_t h = crc64(0, file, l);
- uint64_t i = nodeSearch(db->hfiles, h);
-
+ uint64_t i = searchNode(db->hfiles, h);
if(i == -1){
- ltableAdd(db->lfiles, file);
- ctableAdd(db->cfiles, 0);
+ insertLtable(db->lfiles, file);
+ insertCtable(db->cfiles, 0);
i = db->lfiles->size-1;
db->hfiles = insertNode(db->hfiles, h, i);
}
- increaseCount(db->cfiles, i);
-
return i;
}
@@ -43,34 +32,42 @@ uint64_t addTag(database *db, char *tag){
uint32_t l;
tag = normalizeStrLimit(tag, &l, MAXPATH-1);
uint64_t h = crc64(0, tag, l);
- uint64_t i = nodeSearch(db->htags, h);
-
+ uint64_t i = searchNode(db->htags, h);
if(i == -1){
- ltableAdd(db->ltags, tag);
- ctableAdd(db->ctags, 0);
+ insertLtable(db->ltags, tag);
+ insertCtable(db->ctags, 0);
i = db->ltags->size-1;
db->htags = insertNode(db->htags, h, i);
}
- increaseCount(db->ctags, i);
-
return i;
}
+static void increaseCount(ctable *ct, uint64_t i){
+ ct->table[i]++;
+}
+
+static void decreaseCount(ctable *ct, uint64_t i){
+ ct->table[i]--;
+}
+
static int addRelation(database *db, relation r){
- if(mtableSearch(db->map, r) != -1){
- return -1;
+ if(searchMtable(db->map, r) == UINTMAX_MAX){
+ insertMtable(db->map, r);
+ return 0;
}
- mtableAdd(db->map, r);
-
- return 0;
+ return -1;
}
int addFileTag(database *db, char *file, char *tag){
uint64_t fi = addFile(db, file), ti = addTag(db, tag);
- addRelation(db, (relation){.file = fi, .tag = ti});
-
- return 0;
+ int r = addRelation(db, (relation){.file = fi, .tag = ti});
+ if(r == 0){
+ increaseCount(db->cfiles, fi);
+ increaseCount(db->ctags, ti);
+ return 0;
+ }
+ return -1;
}
int addFileTags(database *db, char *file, int ntags, ...){
@@ -81,14 +78,56 @@ int addFileTags(database *db, char *file, int ntags, ...){
addFileTag(db, file, tag);
}
va_end(tags);
+ return 0;
+}
+int addTagFiles(database *db, char *tag, int nfiles, ...){
+ va_list files;
+ va_start(files, nfiles);
+ for(uint64_t i = 0; i < nfiles; ++i){
+ char *file = va_arg(files, char*);
+ addFileTag(db, file, tag);
+ }
+ va_end(files);
return 0;
}
+// When removing the file from the ltable and ctable we change the indexes of the tags in front
+// of it. Thus, we must change their indexes on the avl tree and mapping table. To do this we
+// simply get all tags with an index higher than the tag we removed and substract one from it,
+// since when removing a tag from the tables all we did was shift down all the tags in front of
+// it one position
+static void decreaseHigherIndexNode(node *n, uint64_t i){
+ if(n == NULL){
+ return;
+ }
+ if(n->i > i){
+ n->i--;
+ }
+ decreaseHigherIndexNode(n->left, i);
+ decreaseHigherIndexNode(n->right, i);
+}
+
+static void decreaseHigherFileIndexMap(mtable *mt, uint64_t i){
+ for(uint64_t j = 0; j < mt->size; ++j){
+ if(mt->table[j].file > i){
+ mt->table[j].file--;
+ }
+ }
+}
+
+static void decreaseHigherTagIndexMap(mtable *mt, uint64_t i){
+ for(uint64_t j = 0; j < mt->size; ++j){
+ if(mt->table[j].tag > i){
+ mt->table[j].tag--;
+ }
+ }
+}
+
int removeFile(database *db, char *file){
uint32_t l;
file = normalizeStrLimit(file, &l, MAXPATH-1);
- uint64_t i = ltableSearch(db->lfiles, file);
+ uint64_t i = searchLtable(db->lfiles, file);
if(i == -1){
return -1;
}
@@ -98,17 +137,20 @@ int removeFile(database *db, char *file){
decreaseCount(db->ctags, r[j]);
}
uint64_t h = crc64(0, file, l);
- ltableRemove(db->lfiles, file);
- ctableRemove(db->cfiles, i);
- deleteNode(db->hfiles, h);
- mtableRemoveFile(db->map, i);
+ removeLtable(db->lfiles, file);
+ removeCtable(db->cfiles, i);
+ removeNode(db->hfiles, h);
+ removeFileMtable(db->map, i);
+
+ decreaseHigherIndexNode(db->hfiles, i);
+ decreaseHigherFileIndexMap(db->map, i);
return 0;
}
int removeTag(database *db, char *tag){
uint32_t l;
tag = normalizeStrLimit(tag, &l, MAXPATH-1);
- uint64_t i = ltableSearch(db->ltags, tag);
+ uint64_t i = searchLtable(db->ltags, tag);
if(i == -1){
return -1;
}
@@ -118,20 +160,21 @@ int removeTag(database *db, char *tag){
decreaseCount(db->cfiles, r[j]);
}
uint64_t h = crc64(0, tag, l);
- ltableRemove(db->ltags, tag);
- ctableRemove(db->ctags, i);
- deleteNode(db->htags, h);
- mtableRemoveTag(db->map, i);
+ removeLtable(db->ltags, tag);
+ removeCtable(db->ctags, i);
+ removeNode(db->htags, h);
+ removeTagMtable(db->map, i);
+
+ decreaseHigherIndexNode(db->htags, i);
+ decreaseHigherTagIndexMap(db->map, i);
return 0;
}
-// Stores in r a list with the indexes of the first n tags that this file has
-// If n is 0 or lower, it returns all of them. Stores in rl the length of r
int searchFile(database *db, char *file, uint64_t n, uint64_t **r, uint64_t *rl){
uint32_t l;
file = normalizeStrLimit(file, &l, MAXPATH-1);
uint64_t h = crc64(0, file, l);
- uint64_t fi = nodeSearch(db->hfiles, h);
+ uint64_t fi = searchNode(db->hfiles, h);
if(fi == -1){
return -1;
}
@@ -151,17 +194,14 @@ int searchFile(database *db, char *file, uint64_t n, uint64_t **r, uint64_t *rl)
(*r)[c++] = db->map->table[i].tag;
}
}
-
return 0;
}
-// Stores in r a list with the indexes of the first n files that have this tag
-// If n is 0 or lower, it returns all of them. Stores in rl the length of r
int searchTag(database *db, char *tag, uint64_t n, uint64_t **r, uint64_t *rl){
uint32_t l;
tag = normalizeStrLimit(tag, &l, MAXPATH-1);
uint64_t h = crc64(0, tag, l);
- uint64_t ti = nodeSearch(db->htags, h);
+ uint64_t ti = searchNode(db->htags, h);
if(ti == -1){
return -1;
}
@@ -181,7 +221,6 @@ int searchTag(database *db, char *tag, uint64_t n, uint64_t **r, uint64_t *rl){
(*r)[c++] = db->map->table[i].file;
}
}
-
return 0;
}
@@ -202,7 +241,6 @@ int storeDatabase(database *db, const char *path){
char end[3] = "END";
fwrite(end, sizeof(char), 3, fp);
-
fclose(fp);
return 0;
}
@@ -255,11 +293,11 @@ void debugDatabase(database *db){
printf("Name: %s\n", db->name);
printf("\t-lfiles: %d\n", db->lfiles->size);
for(uint64_t i = 0; i < db->lfiles->size; ++i){
- printf("\t\t+%s (%" PRIu64 ")\n", db->lfiles->table[i], db->cfiles->table[i]);
+ printf("\t\t+[%" PRIu64 "] %s (%" PRIu64 ")\n", i, db->lfiles->table[i], db->cfiles->table[i]);
}
printf("\t-ltags: %d\n", db->ltags->size);
for(uint64_t i = 0; i < db->ltags->size; ++i){
- printf("\t\t+%s (%" PRIu64 ")\n", db->ltags->table[i], db->ctags->table[i]);
+ printf("\t\t+[%" PRIu64 "] %s (%" PRIu64 ")\n", i, db->ltags->table[i], db->ctags->table[i]);
}
printf("\t-hfiles: %d\n", db->lfiles->size);
debugAVLtree(db->hfiles);
@@ -267,7 +305,7 @@ void debugDatabase(database *db){
debugAVLtree(db->htags);
printf("\t-map: %d\n", db->map->size);
for(uint64_t i = 0; i < db->map->size; ++i){
- printf("\t\t+%" PRIu64 ":%" PRIu64 "\n", db->map->table[i].file, db->map->table[i].tag);
+ printf("\t\t+[%" PRIu64 "] %" PRIu64 ":%" PRIu64 "\n", i, db->map->table[i].file, db->map->table[i].tag);
}
printf("\n");
}
diff --git a/src/db.db b/src/db.db
deleted file mode 100644
index 1c12210..0000000
--- a/src/db.db
+++ /dev/null
Binary files differ
diff --git a/src/main.c b/src/main.c
index c51b5d5..b6a21bc 100644
--- a/src/main.c
+++ b/src/main.c
@@ -4,21 +4,21 @@
int main(){
+
inputBuffer *in = newInputBuffer();
- /*database *db = newDatabase("miDB");
-
-
- addFileTag(db, "vaca.png", "naturaleza");
+ database *db = newDatabase("miDB");
+
+
+ addFileTag(db, "vaca.png", "naturalezas");
addFileTags(db, "terry-davis.jpg", 3, "holyC", "programmer", "very cool");
addFileTag(db, "vaca.png", "lovely");
addFileTags(db, "vaca.png", 3, "nature", "animal", "very cool");
-
- loadDatabase(db, "db.db");
+ addFileTag(db, "terry-davis.jpg", "based");
+
+ storeDatabase(db, "db.db");
+
+ printDatabase(db);
- printDatabase(db);*/
-
- database *db = loadDatabase("db.db");
-
debugDatabase(db);
uint64_t *l, i;
@@ -30,6 +30,12 @@ int main(){
}
+ addTagFiles(db, "elemento", 2, "vaca.png", "terry-davis.jpg");
+
+ printDatabase(db);
+
+ debugDatabase(db);
+
diff --git a/src/main.exe b/src/main.exe
deleted file mode 100644
index 9ac3ba5..0000000
--- a/src/main.exe
+++ /dev/null
Binary files differ
diff --git a/src/storage.c b/src/storage.c
index 3e45b2e..73d8131 100644
--- a/src/storage.c
+++ b/src/storage.c
@@ -5,13 +5,12 @@
ltable *newLtable(uint64_t size){
ltable *lt = malloc(sizeof(ltable));
- size = (((uint64_t)size) < 0) ? 0 : size;
lt->size = size;
lt->table = malloc(size*sizeof(char*));
return lt;
}
-int ltableAdd(ltable *lt, char *str){
+int insertLtable(ltable *lt, char *str){
uint32_t ls;
str = normalizeStrLimit(str, &ls, MAXPATH-1);
@@ -37,19 +36,19 @@ int ltableAdd(ltable *lt, char *str){
return 0;
}
-int ltableRemove(ltable *lt, char *str){
- uint64_t i = ltableSearch(lt, str);
+int removeLtable(ltable *lt, char *str){
+ uint64_t i = searchLtable(lt, str);
if(i == -1){
return -1;
}
lt->size--;
- for(uint64_t j = i; j < lt->size-1; ++j){
+ for(uint64_t j = i; j < lt->size; ++j){
lt->table[j] = lt->table[j+1];
}
return 0;
}
-uint64_t ltableSearch(ltable *lt, char *str){
+uint64_t searchLtable(ltable *lt, char *str){
uint32_t l;
str = normalizeStrLimit(str, &l, MAXPATH-1);
@@ -58,7 +57,7 @@ uint64_t ltableSearch(ltable *lt, char *str){
return i;
}
}
- return -1;
+ return UINTMAX_MAX;
}
int storeLtable(const ltable *lt, FILE *fp){
@@ -102,13 +101,12 @@ ltable *loadLtable(FILE *fp){
ctable *newCtable(uint64_t size){
ctable *ct = malloc(sizeof(ctable));
- size = (((uint64_t)size) < 0) ? 0 : size;
ct->size = size;
- ct->table = malloc(size*sizeof(uint64_t));
+ ct->table = calloc(size, sizeof(uint64_t));
return ct;
}
-int ctableAdd(ctable *ct, uint64_t n){
+int insertCtable(ctable *ct, uint64_t n){
uint64_t *nct = malloc((ct->size+1)*sizeof(uint64_t));
for(uint64_t i = 0; i < ct->size; ++i){
if(n == ct->table[i]){
@@ -126,24 +124,24 @@ int ctableAdd(ctable *ct, uint64_t n){
return 0;
}
-int ctableRemove(ctable *ct, uint64_t i){
- if(i >= ct->size){
+int removeCtable(ctable *ct, uint64_t i){
+ if(i >= ct->size || i < 0){
return -1;
}
ct->size--;
- for(uint64_t j = i; j < ct->size-1; ++j){
+ for(uint64_t j = i; j < ct->size; ++j){
ct->table[j] = ct->table[j+1];
}
return 0;
}
-uint64_t ctableSearch(ctable *ct, uint64_t n){
+uint64_t searchCtable(ctable *ct, uint64_t n){
for(uint64_t i = 0; i < ct->size; ++i){
if(n == ct->table[i]){
return i;
}
}
- return -1;
+ return UINTMAX_MAX;
}
int storeCtable(const ctable *ct, FILE *fp){
@@ -182,13 +180,12 @@ ctable *loadCtable(FILE *fp){
mtable *newMtable(uint64_t size){
mtable *mt = malloc(sizeof(mtable));
- size = (((uint64_t)size) < 0) ? 0 : size;
mt->size = size;
mt->table = malloc(size*sizeof(relation));
return mt;
}
-int mtableAdd(mtable *mt, relation r){
+int insertMtable(mtable *mt, relation r){
relation *nmt = malloc((mt->size+1)*sizeof(relation));
for(uint64_t i = 0; i < mt->size; ++i){
if(r.file == mt->table[i].file && r.tag == mt->table[i].tag){
@@ -205,19 +202,19 @@ int mtableAdd(mtable *mt, relation r){
return 0;
}
-int mtableRemove(mtable *mt, relation r){
- uint64_t i = mtableSearch(mt, r);
+int removeMtable(mtable *mt, relation r){
+ uint64_t i = searchMtable(mt, r);
if(i == -1){
return -1;
}
mt->size--;
- for(uint64_t j = i; j < mt->size-1; ++j){
+ for(uint64_t j = i; j < mt->size; ++j){
mt->table[j] = mt->table[j+1];
}
return 0;
}
-int mtableRemoveFile(mtable *mt, uint64_t file){
+int removeFileMtable(mtable *mt, uint64_t file){
relation *nmt = malloc(mt->size*sizeof(relation));
uint64_t ni = 0;
for(uint64_t i = 0; i < mt->size; ++i){
@@ -234,7 +231,7 @@ int mtableRemoveFile(mtable *mt, uint64_t file){
return 0;
}
-int mtableRemoveTag(mtable *mt, uint64_t tag){
+int removeTagMtable(mtable *mt, uint64_t tag){
relation *nmt = malloc(mt->size*sizeof(relation));
uint64_t ni = 0;
for(uint64_t i = 0; i < mt->size; ++i){
@@ -251,31 +248,13 @@ int mtableRemoveTag(mtable *mt, uint64_t tag){
return 0;
}
-uint64_t mtableSearch(mtable *mt, relation r){
+uint64_t searchMtable(mtable *mt, relation r){
for(uint64_t i = 0; i < mt->size; ++i){
if(r.file == mt->table[i].file && r.tag == mt->table[i].tag){
return i;
}
}
- return -1;
-}
-
-uint64_t mtableSearchFile(mtable *mt, uint64_t file){
- for(uint64_t i = 0; i < mt->size; ++i){
- if(file == mt->table[i].file){
- return i;
- }
- }
- return -1;
-}
-
-uint64_t mtableSearchTag(mtable *mt, uint64_t tag){
- for(uint64_t i = 0; i < mt->size; ++i){
- if(tag == mt->table[i].tag){
- return i;
- }
- }
- return -1;
+ return UINTMAX_MAX;
}
int storeMtable(const mtable *mt, FILE *fp){
@@ -314,32 +293,6 @@ mtable *loadMtable(FILE *fp){
// AVL TREE
-static inline uint64_t max(uint64_t a, uint64_t b){
- return ((a > b) ? a : b);
-}
-
-static uint64_t height(node *n){
- if(n != NULL){
- return 1 + max(height(n->left), height(n->right));
- }
- return 0;
-}
-
-static int64_t balance(node *n){
- if(n != NULL){
- return height(n->left) - height(n->right);
- }
- return 0;
-}
-
-static node *lowestNode(node *n){
- node *t = n;
- while(t->left != NULL){
- t = t->left;
- }
- return t;
-}
-
node *newNode(uint64_t h, uint64_t i){
node *n = malloc(sizeof(node));
n->h = h;
@@ -367,6 +320,24 @@ static node *rotateNodeLeft(node *r){
return nr;
}
+static inline uint64_t max(uint64_t a, uint64_t b){
+ return ((a > b) ? a : b);
+}
+
+static uint64_t height(node *n){
+ if(n != NULL){
+ return 1 + max(height(n->left), height(n->right));
+ }
+ return 0;
+}
+
+static int64_t balance(node *n){
+ if(n != NULL){
+ return height(n->left) - height(n->right);
+ }
+ return 0;
+}
+
node *insertNode(node *r, uint64_t h, uint64_t i){
if(r == NULL){
return newNode(h, i);
@@ -396,13 +367,21 @@ node *insertNode(node *r, uint64_t h, uint64_t i){
return r;
}
-node *deleteNode(node *r, uint64_t h){
+static node *lowestNode(node *n){
+ node *t = n;
+ while(t->left != NULL){
+ t = t->left;
+ }
+ return t;
+}
+
+node *removeNode(node *r, uint64_t h){
if(r == NULL){
return r;
}else if(r->h > h){
- r->left = deleteNode(r->left, h);
+ r->left = removeNode(r->left, h);
}else if(r->h < h){
- r->right = deleteNode(r->right, h);
+ r->right = removeNode(r->right, h);
}else{
if(r->left == NULL || r->right == NULL){
node *t = (r->left) ? r->left : r->right;
@@ -417,7 +396,7 @@ node *deleteNode(node *r, uint64_t h){
node *t = lowestNode(r->right);
r->h = t->h;
r->i = t->i;
- r->right = deleteNode(r->right, t->h);
+ r->right = removeNode(r->right, t->h);
}
}
if(r == NULL){
@@ -443,15 +422,15 @@ node *deleteNode(node *r, uint64_t h){
}
// Searches for h, returns i
-uint64_t nodeSearch(node *n, uint64_t h){
+uint64_t searchNode(node *n, uint64_t h){
if(n == NULL){
- return -1;
+ return UINTMAX_MAX;
}else if(h == n->h){
return n->i;
}else if(h < n->h){
- return nodeSearch(n->left, h);
+ return searchNode(n->left, h);
}else if(h > n->h){
- return nodeSearch(n->right, h);
+ return searchNode(n->right, h);
}
}
generated by cgit v1.2.3 (git 2.46.0) at 2026-02-21 09:02:27 +0000