ccore/include/core/HashMap.h

#ifndef CORE_HASHMAP_H
#define CORE_HASHMAP_H

#include "core/Types.h"

struct CoreHashMap;
typedef struct CoreHashMap CoreHashMap;

typedef size_t (*CoreHasher)(const void* key, size_t n);
typedef bool (*CoreEqual)(const void* keyA, const void* keyB, size_t n);
typedef void* (*CoreSearchValue)(const CoreHashMap* m, const void* key);

struct CoreHashMap {
    void* keys;
    void* values;
    size_t keySize;
    size_t valueSize;
    size_t capacity;
    size_t entries;
    CoreHasher hasher;
    CoreEqual equal;
    CoreSearchValue search;
};

CoreHashMap coreInitHashMap(size_t keySize, size_t valueSize, CoreHasher hasher,
                            CoreEqual equal);
#define CORE_HASH_MAP(keySize, valueSize, hasher, equal)                       \
    coreInitHashMap(keySize, valueSize, hasher, equal)
void coreDestroyHashMap(CoreHashMap* m);
void coreRehashHashMap(CoreHashMap* m, size_t minCapacity);
void* coreHashMapPutPointer(CoreHashMap* m, const void* key, const void* value);
#define coreHashMapPut(m, kType, key, vType, ...)                              \
    coreHashMapPutPointer(m, &(kType){key}, &(vType){__VA_ARGS__})
void* coreHashMapSearchPointer(CoreHashMap* m, const void* key);
#define coreHashMapSearch(m, kType, key, vType)                                \
    ((vType*)coreHashMapSearchPointer(m, &(kType){key}))
const void* coreHashMapSearchPointerC(const CoreHashMap* m, const void* key);
#define coreHashMapSearchC(m, kType, key, vType)                               \
    ((const vType*)coreHashMapSearchPointerC(m, &(kType){key}))
bool coreHashMapContainsPointer(const CoreHashMap* m, const void* key);
#define coreHashMapContains(m, kType, key)                                     \
    coreHashMapContainsPointer(m, &(kType){key})
void coreClearHashMap(CoreHashMap* m);
bool coreHashMapRemovePointer(CoreHashMap* m, const void* key);
#define coreHashMapRemove(m, kType, key)                                       \
    coreHashMapRemovePointer(m, &(kType){key})
size_t coreToStringHashMap(const CoreHashMap* m, char* buffer, size_t n,
                           CoreToString keyString, CoreToString valueString);
void coreSwapHashMap(CoreHashMap* a, CoreHashMap* b);

size_t coreHashString(const void* key, size_t n);
size_t coreHash(const void* key, size_t n);
bool coreEqual(const void* keyA, const void* keyB, size_t n);

typedef struct {
    const void* key;
    void* value;
} CoreHashMapNode;

typedef struct {
    const CoreHashMap* map;
    size_t index;
    CoreHashMapNode node;
} CoreHashMapIterator;

#define CORE_HASH_MAP_ITERATOR(map)                                            \
    ((CoreHashMapIterator){map, (size_t)-1, {0}})
CoreHashMapNode* coreHashMapNext(CoreHashMapIterator* mi);
#define coreHashMapKeyPointer(node, type) ((const type*)node->key)
#define coreHashMapKey(node, type) (*coreHashMapKeyPointer(node, type))
#define coreHashMapValuePointer(node, type) ((const type*)node->value)
#define coreHashMapValue(node, type) (*coreHashMapValuePointer(node, type))

#endif