Huge changes to bidimap and added callbacks to it

Callbacks lost their 'on_' prefix
Bidimap was simply not working properly. Many of its functions have been reworked:
- _update_key_by_val is now _update_key
- _update_val_by_key is now _update_val
- Removed _update_key and _update_val because they just weren't what a bidimap really is about

TODO

@@ -31,7 +31,6 @@ TODO
 [ ] Use binary search to find optimum hashtable prime size inside impl_calculate_size
 [ ] Optimize certain loops that use iterators but can simply use a normal loop
 [ ] Replace IntervalHeap node by a simple buffer of two pointers (V (*buffer)[2])
-[ ] Merge bidirectional map key_buffer and val_buffer to a single buffer and make key_dist and val_dist into dist[2]
 
 #!! Done -------------------------------------------------------------------------------------------
 
@@ -64,3 +63,4 @@ TODO
 [X] Add Function Tables that contains data type functions
     (compare, copy, display, free, hash, priority)
 [X] Add error codes that can be accessed from the collection's struct
+[X] Merge bidirectional map key_buffer and val_buffer to a single buffer and make key_dist and val_dist into dist[2]

documentation/source/index.html.md

@@ -136,11 +136,11 @@ Every collection can have an optional callback node. In this node there are five
 
 | | |
 |-|-|
-| `on_create` | Is called when an element is about to be added to the collection      |
-| `on_read`   | Is called when the collection is about to be queried about an element |
-| `on_update` | Is called when an element in the collection is about to be updated    |
-| `on_delete` | Is called when an element is about to be removed from the collection  |
-| `on_resize` | Is called when the collection is full and is about to get resized     |
+| `create` | Is called when an element was successfully added to the collection      |
+| `read`   | Is called when the collection was successfully queried about an element |
+| `update` | Is called when an element in the collection was successfully updated    |
+| `delete` | Is called when an element was successfully removed from the collection  |
+| `resize` | Is called when the collection was full and successfully resized         |
 
 Check the documentation for each collection to see which functions call which callbacks.
 

src/cor/core.h

@@ -10,6 +10,12 @@
 
 /**
  * Core includes and structs used in the library.
+ *
+ * In here you will find:
+ *     struct cmc_string
+ *     struct cmc_alloc_node
+ *     struct cmc_callbacks
+ *     cmc_flags
  */
 
 #ifndef CMC_CORE_H
@@ -51,19 +57,19 @@ static struct cmc_alloc_node
  * struct cmc_callbacks
  *
  * Callback node. Each collection will call one of these functions when:
- * - on_create : an element is about to be added to the collection
- * - on_read   : the collection is about to be queried about an element
- * - on_update : an element in the collection is about to be updated
- * - on_delete : element is about to be removed from the collection
- * - on_resize : the collection is full and is about to get resized
+ * - create : an element was successfully added to the collection
+ * - read   : the collection was successfully queried about an element
+ * - update : an element in the collection was successfully updated
+ * - delete : an element was successfully removed from the collection
+ * - resize : the collection was full and successfully resized
  */
 struct cmc_callbacks
 {
-    void (*on_create)(void);
-    void (*on_read)(void);
-    void (*on_update)(void);
-    void (*on_delete)(void);
-    void (*on_resize)(void);
+    void (*create)(void);
+    void (*read)(void);
+    void (*update)(void);
+    void (*delete)(void);
+    void (*resize)(void);
 };
 
 /**

tests/main/unt/bidimap.c

@@ -41,8 +41,8 @@ CMC_CREATE_UNIT(bidimap_test, true, {
 
         for (size_t i = 0; i < map->capacity; i++)
         {
-            cmc_assert_equals(ptr, NULL, map->key_buffer[i]);
-            cmc_assert_equals(ptr, NULL, map->val_buffer[i]);
+            cmc_assert_equals(ptr, NULL, map->buffer[i][0]);
+            cmc_assert_equals(ptr, NULL, map->buffer[i][1]);
         }
 
         bm_free(map);
@@ -62,6 +62,23 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         bm_free(map);
     });
 
+    CMC_CREATE_TEST(insert[references], {
+        struct bidimap *map = bm_new(500, 0.7, bm_ftab_key, bm_ftab_val);
+
+        cmc_assert_not_equals(ptr, NULL, map);
+
+        for (size_t i = 0; i < 500; i++)
+            cmc_assert(bm_insert(map, i, i));
+
+        for (size_t i = 0; i < map->capacity; i++)
+        {
+            struct bidimap_entry *kentry = map->buffer[i][0];
+            struct bidimap_entry *ventry = map->buffer[i][1];
+        }
+
+        bm_free(map);
+    });
+
     CMC_CREATE_TEST(new_custom[insert remove], {
         struct bidimap *map =
             bm_new_custom(500, 0.6, bm_ftab_key, bm_ftab_val,
@@ -124,9 +141,9 @@ CMC_CREATE_UNIT(bidimap_test, true, {
 
         for (size_t i = 0; i < bm_capacity(map); i++)
         {
-            if (map->key_buffer[i] && map->key_buffer[i] != CMC_ENTRY_DELETED)
+            if (map->buffer[i][0] && map->buffer[i][0] != CMC_ENTRY_DELETED)
             {
-                sum += map->key_buffer[i]->key;
+                sum += map->buffer[i][0]->key;
             }
         }
 
@@ -254,8 +271,8 @@ CMC_CREATE_UNIT(bidimap_test, true, {
 
         for (size_t i = 0; i < map->capacity; i++)
         {
-            struct bidimap_entry *k = map->key_buffer[i];
-            struct bidimap_entry *v = map->val_buffer[i];
+            struct bidimap_entry *k = map->buffer[i][0];
+            struct bidimap_entry *v = map->buffer[i][1];
 
             cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
                        (v == NULL || v == CMC_ENTRY_DELETED));
@@ -287,8 +304,8 @@ CMC_CREATE_UNIT(bidimap_test, true, {
 
         for (size_t i = 0; i < map->capacity; i++)
         {
-            struct bidimap_entry *k = map->key_buffer[i];
-            struct bidimap_entry *v = map->val_buffer[i];
+            struct bidimap_entry *k = map->buffer[i][0];
+            struct bidimap_entry *v = map->buffer[i][1];
 
             cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
                        (v == NULL || v == CMC_ENTRY_DELETED));
@@ -383,7 +400,7 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         bm_clear(map);
         cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
 
-        // update_key
+        // bm_update_key
         cmc_assert(!bm_update_key(map, 1, 1));
         cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
 
@@ -392,36 +409,17 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
 
         cmc_assert(bm_insert(map, 2, 2));
-        cmc_assert(!bm_update_key(map, 1, 2));
-        cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
-        map->flag = cmc_flags.ERROR;
         cmc_assert(!bm_update_key(map, 2, 1));
         cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
-
-        // clear
-        bm_clear(map);
-        cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
-
-        // update_key_by_val
-        cmc_assert(!bm_update_key_by_val(map, 1, 1));
-        cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
-
-        cmc_assert(bm_insert(map, 1, 1));
-        cmc_assert(!bm_update_key_by_val(map, 2, 1));
-        cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
-
-        cmc_assert(bm_insert(map, 2, 2));
-        cmc_assert(!bm_update_key_by_val(map, 2, 1));
-        cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
         map->flag = cmc_flags.ERROR;
-        cmc_assert(!bm_update_key_by_val(map, 1, 2));
+        cmc_assert(!bm_update_key(map, 1, 2));
         cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
 
         // clear
         bm_clear(map);
         cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
 
-        // update_val
+        // bm_update_val
         cmc_assert(!bm_update_val(map, 1, 1));
         cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
 
@@ -430,29 +428,10 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
 
         cmc_assert(bm_insert(map, 2, 2));
-        cmc_assert(!bm_update_val(map, 1, 2));
-        cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
-        map->flag = cmc_flags.ERROR;
         cmc_assert(!bm_update_val(map, 2, 1));
         cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
-
-        // clear
-        bm_clear(map);
-        cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
-
-        // update_val_by_key
-        cmc_assert(!bm_update_val_by_key(map, 1, 1));
-        cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
-
-        cmc_assert(bm_insert(map, 1, 1));
-        cmc_assert(!bm_update_val_by_key(map, 2, 1));
-        cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
-
-        cmc_assert(bm_insert(map, 2, 2));
-        cmc_assert(!bm_update_val_by_key(map, 2, 1));
-        cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
         map->flag = cmc_flags.ERROR;
-        cmc_assert(!bm_update_val_by_key(map, 1, 2));
+        cmc_assert(!bm_update_val(map, 1, 2));
         cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
 
         // remove_by_key
@@ -530,4 +509,56 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         bm_free(map);
         bm_free(map2);
     });
+
+    CMC_CREATE_TEST(callbacks, {
+        struct bidimap *map = bm_new_custom(100, 0.7, bm_ftab_key, bm_ftab_val, NULL, callbacks);
+
+        cmc_assert_not_equals(ptr, NULL, map);
+        cmc_assert_equals(ptr, callbacks, map->callbacks);
+
+        total_create = 0;
+        total_read = 0;
+        total_update = 0;
+        total_delete = 0;
+        total_resize = 0;
+
+        cmc_assert(bm_insert(map, 10, 10));
+        cmc_assert_equals(int32_t, 1, total_create);
+
+        cmc_assert(bm_update_key(map, 10, 5));
+        cmc_assert_equals(int32_t, 1, total_update);
+
+        cmc_assert(bm_update_val(map, 5, 5));
+        cmc_assert_equals(int32_t, 2, total_update);
+
+        cmc_assert(bm_insert(map, 10, 10));
+        cmc_assert_equals(int32_t, 2, total_create);
+
+        cmc_assert(bm_remove_by_key(map, 5, NULL, NULL));
+        cmc_assert_equals(int32_t, 1, total_delete);
+
+        cmc_assert(bm_remove_by_val(map, 10, NULL, NULL));
+        cmc_assert_equals(int32_t, 2, total_delete);
+
+        cmc_assert(bm_insert(map, 1, 2));
+        cmc_assert_equals(size_t, 1, bm_get_key(map, 2));
+        cmc_assert_equals(int32_t, 1, total_read);
+
+        cmc_assert_equals(size_t, 2, bm_get_val(map, 1));
+        cmc_assert_equals(int32_t, 2, total_read);
+
+        cmc_assert(bm_resize(map, 1000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(bm_resize(map, 200));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert(bm_contains_key(map, 1));
+        cmc_assert_equals(int32_t, 3, total_read);
+
+        cmc_assert(bm_contains_val(map, 2));
+        cmc_assert_equals(int32_t, 4, total_read);
+
+        bm_free(map);
+    });
 });

tests/main/unt/utl.c

@@ -65,4 +65,45 @@ size_t hash0(size_t a)
     return 0;
 }
 
+// callbacks
+
+int total_create = 0;
+int total_read = 0;
+int total_update = 0;
+int total_delete = 0;
+int total_resize = 0;
+
+void callback_create(void)
+{
+    total_create++;
+}
+
+void callback_read(void)
+{
+    total_read++;
+}
+
+void callback_update(void)
+{
+    total_update++;
+}
+
+void callback_delete(void)
+{
+    total_delete++;
+}
+
+void callback_resize(void)
+{
+    total_resize++;
+}
+
+struct cmc_callbacks *callbacks = &(struct cmc_callbacks) {
+    .create = callback_create,
+    .read = callback_read,
+    .update = callback_update,
+    .delete = callback_delete,
+    .resize = callback_resize
+};
+
 #endif /* CMC_UNIT_TEST_UTL__ */