Add hashmap, hashset, Open Addressing / Linked hash tables

.gitignore

@@ -3,3 +3,4 @@
 /bin
 /thrid-party/
 /mingw32_x86_build/
+/third-party/

CMakeLists.txt

@@ -10,7 +10,7 @@ endif ()
 cmake_minimum_required(VERSION 3.27)
 project(collections_commons C)
 
-set(CMAKE_C_STANDARD 23)
+set(CMAKE_C_STANDARD 99)
 if (CMAKE_GENERATOR MATCHES "Visual Studio")
     set(CMAKE_ROOT_DIRECTORY ${CMAKE_SOURCE_DIR})
     set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/build/)

README.md

@@ -4,7 +4,6 @@ This C/C++ shared library provides a collection of commonly used data structures
 hash maps, and array lists. It allows you to efficiently manage and manipulate collections of data in your C/C++ projects.
 
 ## Features
-
 - [x] Event / Event Bus for creating commands system
 - [x] Linked lists implementations (Simple / Double Chained and Circular) for storing and traversing data in a dynamic manner
 - [x] Hash map and Hash set implementation for fast key-value lookups and storage and traversing data in a dynamic maner

headers/clist.h

@@ -23,7 +23,6 @@ extern "C" {
 #endif
 
 
-
 /**
  * @brief Data structure for circular linked list element
  */
@@ -42,7 +41,7 @@ typedef struct CLinkedElement {
  * @brief Data structure for a circular linked list
  */
 
-typedef struct ClinkedList {
+typedef struct CLinkedList {
     /**
      * @brief Current size of the list
      */
@@ -53,9 +52,9 @@ typedef struct ClinkedList {
     *
     * @param val1 Left value to compare
     * @param val2 Right value to compare
-    * @return true if left is equals to right, otherwise false
+    * @return true if left is equals to right, false otherwise
     */
-    int (*match)(const void *val1, const void *val2);
+    bool (*equals)(const void *val1, const void *val2);
 
     /**
      * @brief Destroy handle
@@ -83,8 +82,8 @@ void clist_create(CLinkedList *list, void (*destroy)(void *value));
 
 /**
  * @brief Destroy the specified list, after the call no other further operations will be permit
- * @param list Reference of the list to destroy otherwise false
- * @complexity O(n) where n is the number of elements in the current list
+ * @param list Reference of the list to destroy false otherwise
+ * @complexity O(n) where n is the number of hashtable in the current list
  */
 void clist_destroy(CLinkedList *list);
 
@@ -94,7 +93,7 @@ void clist_destroy(CLinkedList *list);
  * @param element Reference element of the current list to add after
  * @param value A generic data to add after the element parameter
  * @complexity O(1)
- * @return true if the element was added to the current list, otherwise false
+ * @return true if the element was added to the current list, false otherwise
  *
  */
 bool clist_add(CLinkedList *list, CLinkedElement *element, const void *value);
@@ -105,61 +104,78 @@ bool clist_add(CLinkedList *list, CLinkedElement *element, const void *value);
  * @param element Element of the list to be removed
  * @param value Output pointer on the value of the deleted list element reference
  * @complexity O(1)
- * @return true if the element was correctly removed, otherwise false
+ * @return true if the element was correctly removed, false otherwise
  */
 bool clist_remove(CLinkedList *list, CLinkedElement *element, void **value);
 
+/**
+ * @brief Returns a random element from the given list
+ * @param list List to return a random element from
+ * @param random_element Reference to a random element
+ * @return true if a random element has been returned, false otherwise
+ */
+CLinkedElement *clist_getRandom(CLinkedList *list);
+
+/**
+ * @brief Replace a specified element from the given list with the specified value
+ * @param list List where to replace the element value
+ * @param element Element to replace the value
+ * @param value Value to replace
+ * @return true if the given element's value was replaces, false otherwise
+ */
+bool clist_replace(CLinkedList *list, CLinkedElement *element, void **value);
+
 /* ----- MACRO C++ COMPATIBILITY -----*/
 #ifdef __cplusplus
 /***
- * Inline function that evaluates the number of elements inside the specified list
+ * Inline function that evaluates the number of hashtable inside the specified list
  * @return The current element count of the current list
  * @complexity O(1)
  */
-inline int clist_size(CLinkedList *list){
+inline int clist_size(CLinkedList *list) {
     return list->size;
-};
+} ;
 
 /***
  * Inline function that evaluates the first element of the specified list
  * @return The first element of the current list
  * @complexity O(1)
  */
-inline CLinkedElement* clist_first(CLinkedList * list){
+inline CLinkedElement *clist_first(CLinkedList *list) {
     return list->head;
-};
+} ;
 
 /***
  * Inline function that evaluates if the specified element is the first element of the specified list
- * @return true if the element is the first of the current list, otherwise false
+ * @return true if the element is the first of the current list, false otherwise
  * @complexity O(1)
  */
-inline bool clist_is_first(CLinkedList * list, CLinkedElement  *element){
+inline bool clist_isFirst(CLinkedList *list, CLinkedElement *element) {
     return (list)->head == element;
-};
+} ;
 
 /***
  * Inline function that evaluates the value of a list element
  * @return The value stored inside a list element
  * @complexity O(1)
  */
-inline void *clist_value(CLinkedElement  *element){
+inline void *clist_value(CLinkedElement *element) {
     return ((element)->value);
-};
+} ;
 
 /***
  * Inline function that evaluates the next element of the current list element
  * @return The reference to the next element of the current list element
  * @complexity O(1)
  */
-inline CLinkedElement *clist_next(CLinkedElement *element){
+inline CLinkedElement *clist_next(CLinkedElement *element) {
     return (element)->next;
 }
 
 /* ----- C MACRO  -----*/
 #else
 /**
- * @brief Macro that evaluates the number of elements inside the specified list
+ * @brief Macro that evaluates the number of hashtable inside the specified list
  * @return The current element count of the current list
  * @complexity O(1)
  */
@@ -174,10 +190,10 @@ inline CLinkedElement *clist_next(CLinkedElement *element){
 
 /**
  * @brief Macro that evaluates if the specified element is the first element of the specified list
- * @return true if the element is the first of the current list, otherwise false
+ * @return true if the element is the first of the current list, false otherwise
  * @complexity O(1)
  */
-#define list_is_first(list, element) ((element) == (list)->head ? true : false )
+#define list_isFirst(list, element) ((element) == (list)->head ? true : false )
 
 /**
  * @brief Macro that evaluates the value of a list element
@@ -199,6 +215,4 @@ inline CLinkedElement *clist_next(CLinkedElement *element){
 #endif
 
 
-
-
 #endif //COLLECTIONS_COMMONS_CLIST_H

headers/dlist.h

@@ -22,7 +22,6 @@ extern "C" {
 #endif
 
 
-
 /**
  * @brief Data structure definition for a double chained linked list generic element
  */
@@ -53,9 +52,9 @@ typedef struct DLinkedList {
      *
      * @param val1 Left value to compare
      * @param val2 Right value to compare
-     * @return true if left is equals to right, otherwise false
+     * @return true if left is equals to right, false otherwise
      */
-    int (*match)(const void *val1, const void *val2);
+    bool (*equals)(const void *val1, const void *val2);
 
     /**
      * @brief Destroy handle
@@ -90,8 +89,8 @@ void dlist_create(DLinkedList *list, void( *destroy)(void *value));
 
 /**
  * @brief Destroy the specified list, after the call no other further operations will be permit
- * @param list Reference of the list to destroy otherwise false
- * @complexity O(n) where n is the number of elements in the current list
+ * @param list Reference of the list to destroy false otherwise
+ * @complexity O(n) where n is the number of hashtable in the current list
  */
 void dlist_destroy(DLinkedList *list);
 
@@ -101,7 +100,7 @@ void dlist_destroy(DLinkedList *list);
  * @param element Reference element of the current list to add after
  * @param value A generic data to add after the element parameter
  * @complexity O(1)
- * @return true if the element was added to the current list, otherwise false
+ * @return true if the element was added to the current list, false otherwise
  *
  */
 bool dlist_add(DLinkedList *list, DLinkedElement *element, const void *value);
@@ -112,84 +111,100 @@ bool dlist_add(DLinkedList *list, DLinkedElement *element, const void *value);
  * @param element Reference element of the current list to add after
  * @param value A generic data to add after the element parameter
  * @complexity O(1)
- * @return true if the element was added to the current list, otherwise false
+ * @return true if the element was added to the current list, false otherwise
  *
  */
-bool dlist_add_before(DLinkedList *list, DLinkedElement *element, const void *value);
+bool dlist_addBefore(DLinkedList *list, DLinkedElement *element, const void *value);
 
 /**
- * @brief Remove a given element from the current list, then returns a pointer on the value of the deleted element
- * @param list Reference of the list to remove an element
- * @param element Element of the list to be removed
- * @param value Output pointer on the value of the deleted list element reference
+ * @brief Remove a given entry from the current list, then returns a pointer on the value of the deleted entry
+ * @param list Reference of the list to remove an entry
+ * @param entry Element of the list to be removed
+ * @param value Output pointer on the value of the deleted list entry reference
  * @complexity O(1)
- * @return true if the element was correctly removed, otherwise false
+ * @return true if the entry was correctly removed, false otherwise
+ */
+bool dlist_remove(DLinkedList *list, DLinkedElement *entry, void **value);
+
+/**
+ * @brief Returns a random element from the given list
+ * @param list List to return a random element from
+ * @param value Reference to a random element
+ * @return true if a random element has been returned, false otherwise
  */
-bool dlist_remove(DLinkedList *list, DLinkedElement *element, void **value);
+DLinkedElement *dlist_getRandom(DLinkedList *list);
 
+/**
+ * @brief Replace a specified element from the given list with the specified value
+ * @param list List where to replace the element value
+ * @param element Element to replace the value
+ * @param value Value to replace
+ * @return true if the given element's value was replaces, false otherwise
+ */
+bool dlist_replace(DLinkedList *list, DLinkedElement *element, void **value);
 /* ----- MACRO C++ COMPATIBILITY -----*/
 #ifdef __cplusplus
 
 /***
- * @brief Inline function that evaluates the number of elements inside the specified list
+ * @brief Inline function that evaluates the number of hashtable inside the specified list
  * @return The current element count of the current list
  * @complexity O(1)
  */
-inline int dlist_size(DLinkedList *list){
+inline int dlist_size(DLinkedList *list) {
     return list->size;
-};
+} ;
 
 /***
  * @brief Inline function that evaluates the first element of the specified list
  * @return The first element of the current list
  * @complexity O(1)
  */
-inline DLinkedElement* dlist_first(DLinkedList * list){
+inline DLinkedElement *dlist_first(DLinkedList *list) {
     return list->head;
-};
+} ;
 
 /***
  * @brief Inline function that evaluates the last element of the specified list
  * @return The last element of the current list
  * @complexity O(1)
  */
-inline DLinkedElement *dlist_last(DLinkedList * list){
+inline DLinkedElement *dlist_last(DLinkedList *list) {
     return list->tail;
-};
+} ;
 
 /***
  * @brief Inline function that evaluates if the specified element is the first element of the specified list
- * @return true if the element is the first of the current list, otherwise false
+ * @return true if the element is the first of the current list, false otherwise
  * @complexity O(1)
  */
-inline bool dlist_is_first(DLinkedList * list, DLinkedElement  *element){
+inline bool dlist_isFirst(DLinkedList *list, DLinkedElement *element) {
     return (element)->previous == nullptr;
-};
+} ;
 
 /***
  * @brief Inline function that evaluates if the specified element is the last element of the specified list
- * @return true if the element is the last of the current list, otherwise false
+ * @return true if the element is the last of the current list, false otherwise
  * @complexity O(1)
  */
-inline bool dlist_is_last(DLinkedList * list, DLinkedElement  *element){
+inline bool dlist_isLast(DLinkedList *list, DLinkedElement *element) {
     return (element)->next == nullptr;
-};
+} ;
 
 /***
  * @brief Inline function that evaluates the value of a list element
  * @return The value stored inside a list element
  * @complexity O(1)
  */
-inline void *dlist_value(DLinkedElement  *element){
+inline void *dlist_value(DLinkedElement *element) {
     return ((element)->value);
-};
+} ;
 
 /***
  * @brief Inline function that evaluates the next element of the current list element
  * @return The reference to the next element of the current list element
  * @complexity O(1)
  */
-inline DLinkedElement *dlist_next(DLinkedElement *element){
+inline DLinkedElement *dlist_next(DLinkedElement *element) {
     return (element)->next;
 }
 
@@ -198,14 +213,14 @@ inline DLinkedElement *dlist_next(DLinkedElement *element){
  * @return The reference to the next element of the current list element
  * @complexity O(1)
  */
-inline DLinkedElement *dlist_previous(DLinkedElement *element){
+inline DLinkedElement *dlist_previous(DLinkedElement *element) {
     return (element)->previous;
 }
 
 /* ----- C MACRO  -----*/
 #else
 /***
- * @brief Macro that evaluates the number of elements inside the specified list
+ * @brief Macro that evaluates the number of hashtable inside the specified list
  * @return The current element count of the current list
  * @complexity O(1)
  */
@@ -227,17 +242,17 @@ inline DLinkedElement *dlist_previous(DLinkedElement *element){
 
 /***
  * @brief Macro that evaluates if the specified element is the first element of the specified list
- * @return true if the element is the first of the current list, otherwise false
+ * @return true if the element is the first of the current list, false otherwise
  * @complexity O(1)
  */
-#define dlist_is_first(list, element) ((element)->previous == NULL ? true : false )
+#define dlist_isFirst(list, element) ((element)->previous == NULL ? true : false )
 
 /***
  * @brief Macro that evaluates if the specified element is the last element of the specified list
- * @return true if the element is the last of the current list, otherwise false
+ * @return true if the element is the last of the current list, false otherwise
  * @complexity O(1)
  */
-#define dlist_is_last(list, element) ((element)->next == NULL ? true : false )
+#define dlist_isLast(list, element) ((element)->next == NULL ? true : false )
 
 /***
  * @brief Macro that evaluates the value of a list element
@@ -267,5 +282,4 @@ inline DLinkedElement *dlist_previous(DLinkedElement *element){
 #endif
 
 
-
 #endif //COLLECTIONS_COMMONS_DLIST_H