383 lines
9.3 KiB
C
383 lines
9.3 KiB
C
#define SET_MSG(result, msg) \
|
|
snprintf((char *)result.message, RESULT_MSG_SIZE, msg)
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "map.h"
|
|
|
|
// Internal methods
|
|
static uint64_t hash_key(const char *key);
|
|
static size_t map_insert_index(const map_t *map, const char *key);
|
|
static size_t map_find_index(const map_t *map, const char *key);
|
|
static map_result_t map_resize(map_t *map);
|
|
|
|
/**
|
|
* hash_key
|
|
* @key: The input string for the hash function
|
|
*
|
|
* Returns the digest of @key using the Fowler-Noll-Vo hashing algorithm
|
|
*/
|
|
uint64_t hash_key(const char *key) {
|
|
uint64_t hash = FNV_OFFSET_BASIS_64;
|
|
|
|
while (*key) {
|
|
hash ^= (uint64_t)*(key++);
|
|
hash *= FNV_PRIME_64;
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
/**
|
|
* map_new
|
|
*
|
|
* Returns a map_result_t data type containing a new hash map
|
|
*/
|
|
map_result_t map_new() {
|
|
map_result_t result = {0};
|
|
|
|
map_t *map = malloc(sizeof(map_t));
|
|
if (map == NULL) {
|
|
result.status = MAP_ERR_ALLOCATE;
|
|
SET_MSG(result, "Failed to allocate memory for map");
|
|
|
|
return result;
|
|
}
|
|
|
|
map->elements = calloc(INITIAL_CAP, sizeof(map_element_t));
|
|
if (map->elements == NULL) {
|
|
free(map);
|
|
result.status = MAP_ERR_ALLOCATE;
|
|
SET_MSG(result, "Failed to allocate memory for map elements");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Initialize map
|
|
map->capacity = INITIAL_CAP;
|
|
map->size = 0;
|
|
map->tombstone_count = 0;
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Map successfully created");
|
|
result.value.map = map;
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_insert_index
|
|
* @map: a non-null map
|
|
* @key: a string representing the key to find
|
|
*
|
|
* Finds next available slot for insertion
|
|
*
|
|
* Returns the index of available slot
|
|
*/
|
|
size_t map_insert_index(const map_t *map, const char *key) {
|
|
const uint64_t key_digest = hash_key(key);
|
|
size_t idx = key_digest % map->capacity;
|
|
|
|
while (map->elements[idx].state == ENTRY_OCCUPIED) {
|
|
if (strcmp(map->elements[idx].key, key) == 0) {
|
|
// In this case the key already exists, thus we replace it
|
|
return idx;
|
|
}
|
|
|
|
idx = (idx + 1) % map->capacity;
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
/**
|
|
* @map: a non-null map
|
|
*
|
|
* Increases the size of @map
|
|
*
|
|
* Returns a a map_result_t data type containing the status
|
|
*/
|
|
map_result_t map_resize(map_t *map) {
|
|
map_result_t result = {0};
|
|
|
|
const size_t old_capacity = map->capacity;
|
|
map_element_t *old_elements = map->elements;
|
|
|
|
map->capacity *= 2;
|
|
map->elements = calloc(map->capacity, sizeof(map_element_t));
|
|
if (map->elements == NULL) {
|
|
// Restore old parameters if resize failed
|
|
map->capacity = old_capacity;
|
|
map->elements = old_elements;
|
|
|
|
result.status = MAP_ERR_ALLOCATE;
|
|
SET_MSG(result, "Failed to reallocate memory for map");
|
|
|
|
return result;
|
|
}
|
|
|
|
map->size = 0;
|
|
map->tombstone_count = 0;
|
|
|
|
// Rehash all existing elements
|
|
for (size_t idx = 0; idx < old_capacity; idx++) {
|
|
if (old_elements[idx].state == ENTRY_OCCUPIED) {
|
|
size_t new_idx = map_insert_index(map, old_elements[idx].key);
|
|
map->elements[new_idx] = old_elements[idx];
|
|
map->size++;
|
|
} else if (old_elements[idx].state == ENTRY_DELETED) {
|
|
free(old_elements[idx].key);
|
|
}
|
|
}
|
|
|
|
free(old_elements);
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Map successfully resized");
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_add
|
|
* @map: a non-null map
|
|
* @key: a string representing the index key
|
|
* @value: a generic value to add to the map
|
|
*
|
|
* Adds (@key, @value) to @map
|
|
*
|
|
* Returns a map_result_t data type containing the status
|
|
*/
|
|
map_result_t map_add(map_t *map, const char *key, void *value) {
|
|
map_result_t result = {0};
|
|
|
|
if (map == NULL || key == NULL) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Invalid map or key");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Check whether there's enough space available
|
|
const double load_factor = (double)(map->size + map->tombstone_count) / map->capacity;
|
|
if (load_factor > LOAD_FACTOR_THRESHOLD) {
|
|
result = map_resize(map);
|
|
if (result.status != MAP_OK) {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Find next available slot for insertion
|
|
const size_t idx = map_insert_index(map, key);
|
|
|
|
// If slot is occupied, it means that the key already exists.
|
|
// Therefore we can update it
|
|
if (map->elements[idx].state == ENTRY_OCCUPIED) {
|
|
map->elements[idx].value = value;
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Element successfully updated");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Otherwise, the key doesn't exist. Therefore we need to allocate a new key
|
|
map->elements[idx].key = malloc(strlen(key) + 1);
|
|
if (map->elements[idx].key == NULL) {
|
|
result.status = MAP_ERR_ALLOCATE;
|
|
SET_MSG(result, "Failed to allocate memory for map key");
|
|
|
|
return result;
|
|
}
|
|
|
|
strcpy(map->elements[idx].key, key);
|
|
map->elements[idx].value = value;
|
|
map->elements[idx].state = ENTRY_OCCUPIED;
|
|
map->size++;
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Element successfully added");
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_find_index
|
|
* @map: a non-null map
|
|
* @key: a string representing the index key to find
|
|
*
|
|
* Finds the index where a key is located using linear probing to handle collisions
|
|
*
|
|
* Returns the index of the key if it is found
|
|
*/
|
|
size_t map_find_index(const map_t *map, const char *key) {
|
|
const uint64_t key_digest = hash_key(key);
|
|
size_t idx = key_digest % map->capacity;
|
|
|
|
while (map->elements[idx].state != ENTRY_EMPTY) {
|
|
if ((map->elements[idx].state == ENTRY_OCCUPIED) &&
|
|
(strcmp(map->elements[idx].key, key) == 0)) {
|
|
return idx;
|
|
}
|
|
idx = (idx + 1) % map->capacity;
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
/**
|
|
* map_get
|
|
* @map: a non-null map
|
|
* @key: a string representing the index key
|
|
*
|
|
* Returns a map_result_t data type containing the element indexed by @key if available
|
|
*/
|
|
map_result_t map_get(const map_t *map, const char *key) {
|
|
map_result_t result = {0};
|
|
|
|
if (map == NULL || key == NULL) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Invalid map or key");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Retrieve key index
|
|
const size_t idx = map_find_index(map, key);
|
|
|
|
// If slot status is 'occupied' then the key exists
|
|
if (map->elements[idx].state == ENTRY_OCCUPIED) {
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Value successfully retrieved");
|
|
result.value.element = map->elements[idx].value;
|
|
|
|
return result;
|
|
}
|
|
|
|
result.status = MAP_ERR_NOT_FOUND;
|
|
SET_MSG(result, "Element not found");
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_remove
|
|
* @map: a non-null map
|
|
* @key: a string representing the index key
|
|
*
|
|
* Removes an element indexed by @key from @map
|
|
*
|
|
* Returns a map_result_t data type
|
|
*/
|
|
map_result_t map_remove(map_t *map, const char *key) {
|
|
map_result_t result = {0};
|
|
|
|
if (map == NULL) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Invalid map");
|
|
|
|
return result;
|
|
}
|
|
|
|
const size_t idx = map_find_index(map, key);
|
|
|
|
if (map->elements[idx].state != ENTRY_OCCUPIED) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Cannot delete this element");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Remove element key
|
|
free(map->elements[idx].key);
|
|
|
|
// Remove element properties
|
|
map->elements[idx].key = NULL;
|
|
map->elements[idx].value = NULL;
|
|
map->elements[idx].state = ENTRY_DELETED;
|
|
|
|
// Decrease map size and increase its tombstone count
|
|
map->size--;
|
|
map->tombstone_count++;
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Key successfully deleted");
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_clear
|
|
* @map: a non-null map
|
|
*
|
|
* Resets the map to an empty state
|
|
*
|
|
* Returns a map_result_t data type
|
|
*/
|
|
map_result_t map_clear(map_t *map) {
|
|
map_result_t result = {0};
|
|
|
|
if (map == NULL) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Invalid map");
|
|
|
|
return result;
|
|
}
|
|
|
|
for (size_t idx = 0; idx < map->capacity; idx++) {
|
|
if (map->elements[idx].state == ENTRY_OCCUPIED ||
|
|
map->elements[idx].state == ENTRY_DELETED) {
|
|
free(map->elements[idx].key);
|
|
map->elements[idx].key = NULL;
|
|
map->elements[idx].value = NULL;
|
|
}
|
|
|
|
map->elements[idx].state = ENTRY_EMPTY;
|
|
}
|
|
|
|
// Resets map size and tombstone count
|
|
map->size = 0;
|
|
map->tombstone_count = 0;
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Map successfully cleared");
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* map_destroy
|
|
* @map: a non-null map
|
|
*
|
|
* Deletes the map and all its elements from the memory
|
|
*
|
|
* Returns a map_result_t data type
|
|
*/
|
|
map_result_t map_destroy(map_t *map) {
|
|
map_result_t result = {0};
|
|
|
|
if (map == NULL) {
|
|
result.status = MAP_ERR_INVALID;
|
|
SET_MSG(result, "Invalid map");
|
|
|
|
return result;
|
|
}
|
|
|
|
for (size_t idx = 0; idx < map->capacity; idx++) {
|
|
if (map->elements[idx].state == ENTRY_OCCUPIED ||
|
|
map->elements[idx].state == ENTRY_DELETED) {
|
|
free(map->elements[idx].key);
|
|
}
|
|
}
|
|
|
|
free(map->elements);
|
|
free(map);
|
|
|
|
result.status = MAP_OK;
|
|
SET_MSG(result, "Map successfully deleted");
|
|
|
|
return result;
|
|
}
|