2022-07-23 00:19:12 +00:00
|
|
|
#include <HashMap.h>
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2022-07-25 19:18:35 +00:00
|
|
|
typedef struct HashMapBucket
|
|
|
|
{
|
2022-07-23 00:19:12 +00:00
|
|
|
uint32_t hash;
|
2022-07-25 20:26:30 +00:00
|
|
|
char *key;
|
2022-07-23 00:19:12 +00:00
|
|
|
void *value;
|
|
|
|
} HashMapBucket;
|
|
|
|
|
2022-07-25 19:18:35 +00:00
|
|
|
struct HashMap
|
|
|
|
{
|
2022-07-23 00:19:12 +00:00
|
|
|
size_t count;
|
|
|
|
size_t capacity;
|
|
|
|
HashMapBucket **entries;
|
|
|
|
|
|
|
|
float maxLoad;
|
2022-07-26 01:31:09 +00:00
|
|
|
size_t iterator;
|
2022-07-23 00:19:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static uint32_t
|
|
|
|
HashMapHashKey(const char *key)
|
|
|
|
{
|
|
|
|
uint32_t hash = 2166136261u;
|
|
|
|
size_t i = 0;
|
|
|
|
|
|
|
|
while (key[i])
|
|
|
|
{
|
|
|
|
hash ^= (uint8_t) key[i];
|
|
|
|
hash *= 16777619;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2022-07-25 19:18:35 +00:00
|
|
|
HashMapGrow(HashMap * map)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
size_t oldCapacity;
|
|
|
|
size_t i;
|
|
|
|
HashMapBucket **newEntries;
|
|
|
|
|
|
|
|
if (!map)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
oldCapacity = map->capacity;
|
|
|
|
map->capacity *= 2;
|
|
|
|
|
|
|
|
newEntries = calloc(map->capacity, sizeof(HashMapBucket *));
|
|
|
|
if (!newEntries)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < oldCapacity; i++)
|
|
|
|
{
|
|
|
|
/* If there is a value here, and it isn't a tombstone */
|
|
|
|
if (map->entries[i] && map->entries[i]->hash)
|
|
|
|
{
|
|
|
|
/* Copy it to the new entries array */
|
|
|
|
size_t index = map->entries[i]->hash % map->capacity;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
if (newEntries[index])
|
|
|
|
{
|
|
|
|
if (!newEntries[index]->hash)
|
|
|
|
{
|
|
|
|
free(newEntries[index]);
|
|
|
|
newEntries[index] = map->entries[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
newEntries[index] = map->entries[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = (index + 1) % map->capacity;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Either NULL or a tombstone */
|
|
|
|
free(map->entries[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(map->entries);
|
|
|
|
map->entries = newEntries;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
HashMap *
|
|
|
|
HashMapCreate(void)
|
|
|
|
{
|
|
|
|
HashMap *map = malloc(sizeof(HashMap));
|
2022-07-25 19:18:35 +00:00
|
|
|
|
2022-07-23 00:19:12 +00:00
|
|
|
if (!map)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
map->maxLoad = 0.75;
|
|
|
|
map->count = 0;
|
|
|
|
map->capacity = 16;
|
2022-07-26 01:31:09 +00:00
|
|
|
map->iterator = 0;
|
2022-07-23 00:19:12 +00:00
|
|
|
|
|
|
|
map->entries = calloc(map->capacity, sizeof(HashMapBucket *));
|
|
|
|
if (!map->entries)
|
|
|
|
{
|
|
|
|
free(map);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
2022-07-25 19:18:35 +00:00
|
|
|
HashMapDelete(HashMap * map, const char *key)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
uint32_t hash;
|
|
|
|
size_t index;
|
|
|
|
|
|
|
|
if (!map || !key)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
hash = HashMapHashKey(key);
|
|
|
|
index = hash % map->capacity;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
HashMapBucket *bucket = map->entries[index];
|
|
|
|
|
|
|
|
if (!bucket)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bucket->hash == hash)
|
|
|
|
{
|
|
|
|
bucket->hash = 0;
|
|
|
|
return bucket->value;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = (index + 1) % map->capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-07-25 19:18:35 +00:00
|
|
|
HashMapFree(HashMap * map)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
if (map)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < map->capacity; i++)
|
|
|
|
{
|
|
|
|
if (map->entries[i])
|
|
|
|
{
|
|
|
|
free(map->entries[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(map);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
2022-07-25 19:18:35 +00:00
|
|
|
HashMapGet(HashMap * map, const char *key)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
uint32_t hash;
|
|
|
|
size_t index;
|
|
|
|
|
|
|
|
if (!map || !key)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
hash = HashMapHashKey(key);
|
|
|
|
index = hash % map->capacity;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
HashMapBucket *bucket = map->entries[index];
|
|
|
|
|
|
|
|
if (!bucket)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bucket->hash == hash)
|
|
|
|
{
|
|
|
|
return bucket->value;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = (index + 1) % map->capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-07-26 01:31:09 +00:00
|
|
|
int
|
|
|
|
HashMapIterate(HashMap * map, char **key, void **value)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
if (!map)
|
|
|
|
{
|
2022-07-26 01:31:09 +00:00
|
|
|
return 0;
|
2022-07-23 00:19:12 +00:00
|
|
|
}
|
|
|
|
|
2022-07-26 01:31:09 +00:00
|
|
|
if (map->iterator >= map->capacity)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
2022-07-26 01:31:09 +00:00
|
|
|
map->iterator = 0;
|
|
|
|
*key = NULL;
|
|
|
|
*value = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (map->iterator < map->capacity)
|
|
|
|
{
|
|
|
|
HashMapBucket *bucket = map->entries[map->iterator];
|
|
|
|
|
|
|
|
map->iterator++;
|
2022-07-23 00:19:12 +00:00
|
|
|
|
|
|
|
if (bucket)
|
|
|
|
{
|
2022-07-26 01:31:09 +00:00
|
|
|
*key = bucket->key;
|
|
|
|
*value = bucket->value;
|
|
|
|
return 1;
|
2022-07-23 00:19:12 +00:00
|
|
|
}
|
|
|
|
}
|
2022-07-26 01:31:09 +00:00
|
|
|
|
2022-07-26 02:55:22 +00:00
|
|
|
map->iterator = 0;
|
2022-07-26 01:31:09 +00:00
|
|
|
return 0;
|
2022-07-23 00:19:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-07-25 19:18:35 +00:00
|
|
|
HashMapMaxLoadSet(HashMap * map, float load)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
if (!map)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
map->maxLoad = load;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void *
|
2022-07-25 20:26:30 +00:00
|
|
|
HashMapSet(HashMap * map, char *key, void *value)
|
2022-07-23 00:19:12 +00:00
|
|
|
{
|
|
|
|
uint32_t hash;
|
|
|
|
size_t index;
|
|
|
|
|
|
|
|
if (!map || !key || !value)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (map->count + 1 > map->capacity * map->maxLoad)
|
|
|
|
{
|
|
|
|
HashMapGrow(map);
|
|
|
|
}
|
|
|
|
|
|
|
|
hash = HashMapHashKey(key);
|
|
|
|
index = hash % map->capacity;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
HashMapBucket *bucket = map->entries[index];
|
|
|
|
|
|
|
|
if (!bucket)
|
|
|
|
{
|
|
|
|
bucket = malloc(sizeof(HashMapBucket));
|
|
|
|
if (!bucket)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bucket->hash = hash;
|
2022-07-25 20:26:30 +00:00
|
|
|
bucket->key = key;
|
2022-07-23 00:19:12 +00:00
|
|
|
bucket->value = value;
|
|
|
|
map->entries[index] = bucket;
|
|
|
|
map->count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bucket->hash)
|
|
|
|
{
|
|
|
|
bucket->hash = hash;
|
2022-07-25 20:26:30 +00:00
|
|
|
bucket->key = key;
|
2022-07-23 00:19:12 +00:00
|
|
|
bucket->value = value;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bucket->hash == hash)
|
|
|
|
{
|
|
|
|
void *oldValue = bucket->value;
|
2022-07-25 19:18:35 +00:00
|
|
|
|
2022-07-23 00:19:12 +00:00
|
|
|
bucket->value = value;
|
|
|
|
return oldValue;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = (index + 1) % map->capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2022-07-26 01:31:09 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
HashMapIterateFree(char *key, void *value)
|
|
|
|
{
|
|
|
|
if (key)
|
|
|
|
{
|
|
|
|
free(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value)
|
|
|
|
{
|
|
|
|
free(value);
|
|
|
|
}
|
|
|
|
}
|