francesco/myclib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(hm): remove namespace mcl

Browse Source
This commit is contained in:
Francesco
2025-09-08 19:27:23 +02:00
parent ed23ef8bf2
commit 47856a43d9
4 changed files with 66 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
hashmap/myhashmap.c
View File

@@ -4,14 +4,14 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static size_t mcl_get_mutex(mcl_hashmap_s *hashmap, size_t hash) { return hash % hashmap->num_locks; } static size_t get_mutex(hashmap_s *hashmap, size_t hash) { return hash % hashmap->num_locks; }
static size_t mcl_get_bucket_index(mcl_hashmap_s *hashmap, void *key) { static size_t get_bucket_index(hashmap_s *hashmap, void *key) {
unsigned int hash = hashmap->hash_fn(key); unsigned int hash = hashmap->hash_fn(key);
return hash % MYCLIB_HASHMAP_SIZE; return hash % MYCLIB_HASHMAP_SIZE;
} }
static void mcl_free_bucket_content(mcl_hashmap_s *hashmap, mcl_bucket_s *bucket) { static void free_bucket_content(hashmap_s *hashmap, bucket_s *bucket) {
if (bucket == NULL) { if (bucket == NULL) {
return; return;
} }
@@ -27,9 +27,9 @@ static void mcl_free_bucket_content(mcl_hashmap_s *hashmap, mcl_bucket_s *bucket
} }
} }
static mcl_bucket_s *mcl_find_bucket(mcl_hashmap_s *hashmap, void *key, mcl_bucket_s **prev) { static bucket_s *find_bucket(hashmap_s *hashmap, void *key, bucket_s **prev) {
size_t index = mcl_get_bucket_index(hashmap, key); size_t index = get_bucket_index(hashmap, key);
mcl_bucket_s *bucket = &hashmap->map[index]; bucket_s *bucket = &hashmap->map[index];
*prev = NULL; *prev = NULL;
@@ -50,8 +50,8 @@ static mcl_bucket_s *mcl_find_bucket(mcl_hashmap_s *hashmap, void *key, mcl_buck
return NULL; return NULL;
} }
mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size) { hashmap_s *hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size) {
mcl_hashmap_s *hashmap = malloc(sizeof(mcl_hashmap_s)); hashmap_s *hashmap = malloc(sizeof(hashmap_s));
if (hashmap == NULL) { if (hashmap == NULL) {
return NULL; return NULL;
} }
@@ -90,25 +90,25 @@ mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_k
return hashmap; return hashmap;
} }
void mcl_hm_free(mcl_hashmap_s *hashmap) { void hm_free(hashmap_s *hashmap) {
if (hashmap == NULL) { if (hashmap == NULL) {
return; return;
} }
/* Iterate through all buckets in the hash map */ /* Iterate through all buckets in the hash map */
for (size_t i = 0; i < MYCLIB_HASHMAP_SIZE; ++i) { for (size_t i = 0; i < MYCLIB_HASHMAP_SIZE; ++i) {
mcl_bucket_s *bucket = &hashmap->map[i]; bucket_s *bucket = &hashmap->map[i];
/* Free the first bucket if it contains data */ /* Free the first bucket if it contains data */
if (bucket->key != NULL) { if (bucket->key != NULL) {
mcl_free_bucket_content(hashmap, bucket); free_bucket_content(hashmap, bucket);
} }
/* Free all chained buckets */ /* Free all chained buckets */
bucket = bucket->next; bucket = bucket->next;
while (bucket != NULL) { while (bucket != NULL) {
mcl_bucket_s *next = bucket->next; bucket_s *next = bucket->next;
mcl_free_bucket_content(hashmap, bucket); free_bucket_content(hashmap, bucket);
free(bucket); free(bucket);
bucket = next; bucket = next;
} }
@@ -124,7 +124,7 @@ void mcl_hm_free(mcl_hashmap_s *hashmap) {
free(hashmap); free(hashmap);
} }
void mcl_hm_free_bucket(mcl_bucket_s *bucket) { void hm_free_bucket(bucket_s *bucket) {
if (bucket == NULL) { if (bucket == NULL) {
return; return;
} }
@@ -134,17 +134,17 @@ void mcl_hm_free_bucket(mcl_bucket_s *bucket) {
free(bucket); free(bucket);
} }
bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) { bool hm_set(hashmap_s *hashmap, void *key, void *value) {
if (hashmap == NULL || key == NULL || value == NULL) { if (hashmap == NULL || key == NULL || value == NULL) {
return false; return false;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; bucket_s *prev;
mcl_bucket_s *existing = mcl_find_bucket(hashmap, key, &prev); bucket_s *existing = find_bucket(hashmap, key, &prev);
if (existing != NULL) { if (existing != NULL) {
/* Key exists, update value */ /* Key exists, update value */
@@ -166,8 +166,8 @@ bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) {
} }
/* Key doesn't exist, need to insert new bucket */ /* Key doesn't exist, need to insert new bucket */
size_t index = mcl_get_bucket_index(hashmap, key); size_t index = get_bucket_index(hashmap, key);
mcl_bucket_s *bucket = &hashmap->map[index]; bucket_s *bucket = &hashmap->map[index];
if (bucket->key == NULL) { if (bucket->key == NULL) {
/* First bucket is empty, use it */ /* First bucket is empty, use it */
@@ -196,7 +196,7 @@ bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) {
} }
/* Create new bucket and insert at head of collision chain */ /* Create new bucket and insert at head of collision chain */
mcl_bucket_s *new_bucket = malloc(sizeof(mcl_bucket_s)); bucket_s *new_bucket = malloc(sizeof(bucket_s));
if (new_bucket == NULL) { if (new_bucket == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
@@ -230,12 +230,12 @@ bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) {
return true; return true;
} }
static mcl_bucket_s *mcl_get_bucket_copy(mcl_bucket_s *from, size_t key_size, size_t value_size) { static bucket_s *get_bucket_copy(bucket_s *from, size_t key_size, size_t value_size) {
mcl_bucket_s *copy = malloc(sizeof(mcl_bucket_s)); bucket_s *copy = malloc(sizeof(bucket_s));
if (copy == NULL) { if (copy == NULL) {
return NULL; return NULL;
} }
memcpy(copy, from, sizeof(mcl_bucket_s)); memcpy(copy, from, sizeof(bucket_s));
copy->key = malloc(key_size); copy->key = malloc(key_size);
if (copy->key == NULL) { if (copy->key == NULL) {
@@ -257,20 +257,20 @@ static mcl_bucket_s *mcl_get_bucket_copy(mcl_bucket_s *from, size_t key_size, si
return copy; return copy;
} }
mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key) { bucket_s *hm_get(hashmap_s *hashmap, void *key) {
if (hashmap == NULL || key == NULL) { if (hashmap == NULL || key == NULL) {
return NULL; return NULL;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; bucket_s *prev;
mcl_bucket_s *found = mcl_find_bucket(hashmap, key, &prev); bucket_s *found = find_bucket(hashmap, key, &prev);
if (found) { if (found) {
mcl_bucket_s *copy = mcl_get_bucket_copy(found, hashmap->key_size, hashmap->value_size); bucket_s *copy = get_bucket_copy(found, hashmap->key_size, hashmap->value_size);
mtx_unlock(mutex); mtx_unlock(mutex);
@@ -282,17 +282,17 @@ mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key) {
return NULL; return NULL;
} }
bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key) { bool hm_remove(hashmap_s *hashmap, void *key) {
if (hashmap == NULL || key == NULL) { if (hashmap == NULL || key == NULL) {
return false; return false;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; bucket_s *prev;
mcl_bucket_s *to_remove = mcl_find_bucket(hashmap, key, &prev); bucket_s *to_remove = find_bucket(hashmap, key, &prev);
if (to_remove == NULL) { if (to_remove == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
@@ -301,14 +301,14 @@ bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key) {
} }
/* Free the content of the bucket */ /* Free the content of the bucket */
mcl_free_bucket_content(hashmap, to_remove); free_bucket_content(hashmap, to_remove);
/* Handle removal based on position in chain */ /* Handle removal based on position in chain */
if (prev == NULL) { if (prev == NULL) {
/* Removing first bucket in chain */ /* Removing first bucket in chain */
if (to_remove->next != NULL) { if (to_remove->next != NULL) {
/* Move next bucket's content to first bucket and free the next bucket */ /* Move next bucket's content to first bucket and free the next bucket */
mcl_bucket_s *next_bucket = to_remove->next; bucket_s *next_bucket = to_remove->next;
to_remove->key = next_bucket->key; to_remove->key = next_bucket->key;
to_remove->value = next_bucket->value; to_remove->value = next_bucket->value;
to_remove->next = next_bucket->next; to_remove->next = next_bucket->next;

46
hashmap/myhashmap.h
View File

@@ -13,11 +13,11 @@
* Each bucket can hold one key-value pair and points to the next bucket * Each bucket can hold one key-value pair and points to the next bucket
* in case of hash collisions (separate chaining). * in case of hash collisions (separate chaining).
*/ */
typedef struct mcl_bucket { typedef struct bucket {
void *key; /**< Pointer to the key */ void *key; /**< Pointer to the key */
void *value; /**< Pointer to the value */ void *value; /**< Pointer to the value */
struct mcl_bucket *next; /**< Pointer to the next bucket in case of collision */ struct bucket *next; /**< Pointer to the next bucket in case of collision */
} mcl_bucket_s; } bucket_s;
/** /**
* @brief Function pointer type for a hash function * @brief Function pointer type for a hash function
@@ -56,17 +56,17 @@ typedef void free_value_f(void *value);
* Contains function pointers for hash computation, key comparison, * Contains function pointers for hash computation, key comparison,
* and memory management, along with the bucket array. * and memory management, along with the bucket array.
*/ */
typedef struct mcl_hashmap { typedef struct hashmap {
hash_f *hash_fn; /**< Hash function */ hash_f *hash_fn; /**< Hash function */
equal_f *equal_fn; /**< Equality comparison function */ equal_f *equal_fn; /**< Equality comparison function */
free_key_f *free_key_fn; /**< Key deallocation function (optional) */ free_key_f *free_key_fn; /**< Key deallocation function (optional) */
free_value_f *free_value_fn; /**< Value deallocation function (optional) */ free_value_f *free_value_fn; /**< Value deallocation function (optional) */
size_t key_size; /**< Size in bytes of the key */ size_t key_size; /**< Size in bytes of the key */
size_t value_size; /**< Size in bytes of the value */ size_t value_size; /**< Size in bytes of the value */
mcl_bucket_s map[MYCLIB_HASHMAP_SIZE]; /**< Array of bucket chains */ bucket_s map[MYCLIB_HASHMAP_SIZE]; /**< Array of bucket chains */
mtx_t *locks; /**< Mutex array */ mtx_t *locks; /**< Mutex array */
size_t num_locks; /**< Number of mutex */ size_t num_locks; /**< Number of mutex */
} mcl_hashmap_s; } hashmap_s;
/** /**
* @brief Initialize a new hash map with user-defined behavior functions * @brief Initialize a new hash map with user-defined behavior functions
@@ -83,7 +83,7 @@ typedef struct mcl_hashmap {
* @param[in] value_size Size in bytes of each value to be stored * @param[in] value_size Size in bytes of each value to be stored
* @return A pointer to the newly initialized hash map, or NULL on failure * @return A pointer to the newly initialized hash map, or NULL on failure
*/ */
mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size); hashmap_s *hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size);
/** /**
* @brief Free all resources used by the hash map * @brief Free all resources used by the hash map
@@ -93,14 +93,14 @@ mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_k
* *
* @param[in] hashmap Pointer to the hash map to free * @param[in] hashmap Pointer to the hash map to free
*/ */
void mcl_hm_free(mcl_hashmap_s *hashmap); void hm_free(hashmap_s *hashmap);
/** /**
* @brief Free a bucket returned by mcl_hm_get() * @brief Free a bucket returned by get
* *
* @param[in] bucket Pointer to the bucket to free * @param[in] bucket Pointer to the bucket to free
*/ */
void mcl_hm_free_bucket(mcl_bucket_s *bucket); void hm_free_bucket(bucket_s *bucket);
/** /**
* @brief Insert or update a key-value pair in the hash map * @brief Insert or update a key-value pair in the hash map
@@ -114,7 +114,7 @@ void mcl_hm_free_bucket(mcl_bucket_s *bucket);
* @param[in] value Pointer to the value to insert (will be copied, must not be NULL) * @param[in] value Pointer to the value to insert (will be copied, must not be NULL)
* @return true if the operation succeeded, false on failure (NULL hashmap/key/value or memory allocation failure) * @return true if the operation succeeded, false on failure (NULL hashmap/key/value or memory allocation failure)
*/ */
bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value); bool hm_set(hashmap_s *hashmap, void *key, void *value);
/** /**
* @brief Retrieve a bucket by key * @brief Retrieve a bucket by key
@@ -126,7 +126,7 @@ bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value);
* @param[in] key Pointer to the key to search for * @param[in] key Pointer to the key to search for
* @return Pointer to the copy of the bucket, to avoid race conditions, or NULL if not found or on invalid input * @return Pointer to the copy of the bucket, to avoid race conditions, or NULL if not found or on invalid input
*/ */
mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key); bucket_s *hm_get(hashmap_s *hashmap, void *key);
/** /**
* @brief Remove a key-value pair from the hash map * @brief Remove a key-value pair from the hash map
@@ -138,6 +138,6 @@ mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key);
* @param[in] key Pointer to the key to remove * @param[in] key Pointer to the key to remove
* @return true if the key was found and removed, false if not found or on invalid input * @return true if the key was found and removed, false if not found or on invalid input
*/ */
bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key); bool hm_remove(hashmap_s *hashmap, void *key);
#endif /* MYCLIB_HASHMAP_H */ #endif /* MYCLIB_HASHMAP_H */

4
string/mystring.c
View File

@@ -190,7 +190,7 @@ void string_free(string_s *string) {
free(string); free(string);
} }
size_t string_length(string_s *string) { size_t string_len(string_s *string) {
if (string == NULL) { if (string == NULL) {
return 0; return 0;
} }
@@ -206,7 +206,7 @@ size_t string_length(string_s *string) {
return len; return len;
} }
size_t string_capacity(string_s *string) { size_t string_cap(string_s *string) {
if (string == NULL) { if (string == NULL) {
return 0; return 0;
} }

12
test/hashmap/hm1.c
View File

@@ -53,7 +53,7 @@ void test_hm1(void) {
/* This hashmap will contain names as keys and a custom type as value */ /* This hashmap will contain names as keys and a custom type as value */
size_t key_size = sizeof(char) * MAX_STR_LEN; size_t key_size = sizeof(char) * MAX_STR_LEN;
size_t value_size = sizeof(int) + sizeof(char) * MAX_STR_LEN; size_t value_size = sizeof(int) + sizeof(char) * MAX_STR_LEN;
mcl_hashmap_s *map = mcl_hm_new(my_hash_func, my_equal_fun, my_free_key, my_free_value, key_size, value_size); hashmap_s *map = hm_new(my_hash_func, my_equal_fun, my_free_key, my_free_value, key_size, value_size);
assert(map != NULL); assert(map != NULL);
/* Make a new value */ /* Make a new value */
@@ -63,11 +63,11 @@ void test_hm1(void) {
strncpy(p1.favourite_brand, "Ferrari", sizeof(p1.favourite_brand)); strncpy(p1.favourite_brand, "Ferrari", sizeof(p1.favourite_brand));
/* Insert a new pair */ /* Insert a new pair */
assert(mcl_hm_set(map, "John", &p1)); assert(hm_set(map, "John", &p1));
/* Retrieve the data */ /* Retrieve the data */
/* Remember to free the value from the get function */ /* Remember to free the value from the get function */
mcl_bucket_s *john = mcl_hm_get(map, "John"); bucket_s *john = hm_get(map, "John");
assert(john != NULL); assert(john != NULL);
char *name = (char *)john->key; char *name = (char *)john->key;
@@ -80,11 +80,11 @@ void test_hm1(void) {
assert(strcmp(fav_brand, "Ferrari") == 0); assert(strcmp(fav_brand, "Ferrari") == 0);
/* Free the bucket */ /* Free the bucket */
mcl_hm_free_bucket(john); hm_free_bucket(john);
/* Remove a key from hash map */ /* Remove a key from hash map */
assert(mcl_hm_remove(map, "John")); assert(hm_remove(map, "John"));
/* Deallocate */ /* Deallocate */
mcl_hm_free(map); hm_free(map);
} }