212 lines
5.2 KiB
C
212 lines
5.2 KiB
C
// Copyright 2022 Darwin Schuppan <darwin@nobrain.org>
|
|
// SPDX license identifier: MIT
|
|
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
|
|
#include <ds/error.h>
|
|
#include <ds/fmt.h>
|
|
#include <ds/string.h>
|
|
|
|
/* Example Usage:
|
|
|
|
// something.h:
|
|
#define GENERIC_TYPE int // Value type
|
|
#define GENERIC_NAME StringIntMap // Name of the resulting map type
|
|
#define GENERIC_PREFIX string_int_map // Prefix for functions
|
|
#include "smap.h"
|
|
|
|
// something.c:
|
|
#define GENERIC_IMPL // We want something.c to define the actual function implementations
|
|
#include "something.h"
|
|
|
|
*/
|
|
|
|
#define GENERIC_REQUIRE_TYPE
|
|
#include "../internal/generic/begin.h"
|
|
#define ITEM_TYPE GENERIC_CONCAT(NAME, Item)
|
|
#define TOMBSTONE ((char*)UINTPTR_MAX)
|
|
|
|
typedef struct ITEM_TYPE {
|
|
char *key;
|
|
TYPE val;
|
|
} ITEM_TYPE;
|
|
|
|
typedef struct NAME {
|
|
ITEM_TYPE *data;
|
|
size_t cap, len;
|
|
} NAME;
|
|
|
|
VARDECL(const char *, __val_fmt);
|
|
|
|
FUNCDECL(NAME, )();
|
|
FUNCDECL(void, _term)(NAME m);
|
|
FUNCDECL(void, _fmt_register)(const char *val_fmt);
|
|
FUNCDECL(TYPE *, _get)(NAME m, const char *key);
|
|
FUNCDECL(Error, _set)(NAME *m, const char *key, TYPE val);
|
|
FUNCDECL(bool, _del)(NAME m, const char *key);
|
|
FUNCDECL(Error, _rehash)(NAME *m, size_t new_minimum_cap);
|
|
FUNCDECL(bool, _it_next)(NAME m, ITEM_TYPE **it);
|
|
|
|
#ifdef GENERIC_IMPL
|
|
VARDEF(const char *, __val_fmt) = NULL;
|
|
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifndef _GENERIC_MAP_IMPL_ONCE
|
|
#define _GENERIC_MAP_IMPL_ONCE
|
|
static size_t _pow_of_2_from_minimum(size_t n) {
|
|
n--; /* we want to handle the case of n already being a power of 2 */
|
|
/* We use the leftmost bit set to 1 to also set any bits to its right
|
|
* to 1. Then we just increment to carry and get our desired power of 2. */
|
|
n |= n >> 1;
|
|
n |= n >> 2;
|
|
n |= n >> 4;
|
|
n |= n >> 8;
|
|
n |= n >> 16;
|
|
#if INTPTR_MAX == INT64_MAX /* only do the last shift on 64-bit systems */
|
|
n |= n >> 32;
|
|
#endif
|
|
return n + 1;
|
|
}
|
|
|
|
static uint32_t _fnv1a32(const void *data, size_t n) {
|
|
uint32_t res = 2166136261u;
|
|
for (size_t i = 0; i < n; i++) {
|
|
res ^= ((uint8_t*)data)[i];
|
|
res *= 16777619u;
|
|
}
|
|
return res;
|
|
}
|
|
#endif
|
|
|
|
static FUNCDEF(FmtPrintFuncRet, __print_func)(FmtContext *restrict ctx, FmtAttrs *restrict attrs, va_list v) {
|
|
if (attrs != NULL) {
|
|
if (attrs->len != 0)
|
|
return FMT_PRINT_FUNC_RET_INVALID_ATTR(0);
|
|
}
|
|
NAME m = va_arg(v, NAME);
|
|
ctx->putc_func(ctx, '{');
|
|
ITEM_TYPE *it = NULL;
|
|
bool first = true;
|
|
while (FUNC(_it_next)(m, &it)) {
|
|
if (!first)
|
|
fmtc(ctx, ", ");
|
|
fmtc(ctx, "\"%s\": ", it->key);
|
|
fmtc(ctx, VAR(__val_fmt), it->val);
|
|
first = false;
|
|
}
|
|
ctx->putc_func(ctx, '}');
|
|
return FMT_PRINT_FUNC_RET_OK();
|
|
}
|
|
|
|
FUNCDEF(NAME, )() {
|
|
return (NAME){0};
|
|
}
|
|
|
|
FUNCDEF(void, _term)(NAME m) {
|
|
for (size_t i = 0; i < m.cap; i++) {
|
|
if (m.data[i].key && m.data[i].key != TOMBSTONE)
|
|
free(m.data[i].key);
|
|
}
|
|
free(m.data);
|
|
}
|
|
|
|
FUNCDEF(void, _fmt_register)(const char *val_fmt) {
|
|
VAR(__val_fmt) = val_fmt;
|
|
fmt_register(NAME_STR, FUNC(__print_func));
|
|
}
|
|
|
|
FUNCDEF(TYPE *, _get)(NAME m, const char *key) {
|
|
size_t i = _fnv1a32(key, strlen(key)) & (m.cap - 1);
|
|
while (m.data[i].key) {
|
|
if (m.data[i].key != TOMBSTONE && strcmp(m.data[i].key, key) == 0)
|
|
return &m.data[i].val;
|
|
i = (i + 1) % m.cap;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
FUNCDEF(Error, _set)(NAME *m, const char *key, TYPE val) {
|
|
if (m->cap == 0 || (float)m->len / (float)m->cap > 0.7f)
|
|
TRY(FUNC(_rehash)(m, m->cap == 0 ? 8 : m->cap * 2), );
|
|
|
|
size_t i = _fnv1a32(key, strlen(key)) & (m->cap - 1);
|
|
while (m->data[i].key) {
|
|
if (m->data[i].key == TOMBSTONE) {
|
|
char *new_key = strdup(key);
|
|
if (new_key == NULL)
|
|
return ERROR_OUT_OF_MEMORY();
|
|
m->data[i].key = new_key;
|
|
m->data[i].val = val;
|
|
return OK();
|
|
} else if (strcmp(m->data[i].key, key) == 0) {
|
|
m->data[i].val = val;
|
|
return OK();
|
|
}
|
|
i = (i + 1) % m->cap;
|
|
}
|
|
char *new_key = strdup(key);
|
|
if (new_key == NULL)
|
|
return ERROR_OUT_OF_MEMORY();
|
|
m->data[i].key = new_key;
|
|
m->data[i].val = val;
|
|
m->len++;
|
|
return OK();
|
|
}
|
|
|
|
FUNCDEF(bool, _del)(NAME m, const char *key) {
|
|
size_t i = _fnv1a32(key, strlen(key)) & (m.cap - 1);
|
|
while (m.data[i].key) {
|
|
if (m.data[i].key != TOMBSTONE && strcmp(m.data[i].key, key) == 0) {
|
|
free(m.data[i].key);
|
|
m.data[i].key = TOMBSTONE;
|
|
return true;
|
|
}
|
|
i = (i + 1) % m.cap;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FUNCDEF(Error, _rehash)(NAME *m, size_t new_minimum_cap) {
|
|
size_t new_cap = _pow_of_2_from_minimum(new_minimum_cap > m->len ? new_minimum_cap : m->len);
|
|
NAME new_m = {
|
|
.data = malloc(sizeof(ITEM_TYPE) * new_cap),
|
|
.cap = new_cap,
|
|
.len = 0,
|
|
};
|
|
if (new_m.data == NULL)
|
|
return ERROR_OUT_OF_MEMORY();
|
|
for (size_t i = 0; i < new_m.cap; i++)
|
|
new_m.data[i].key = NULL;
|
|
|
|
for (size_t i = 0; i < m->cap; i++) {
|
|
if (m->data[i].key && m->data[i].key != TOMBSTONE) {
|
|
size_t j = _fnv1a32(m->data[i].key, strlen(m->data[i].key)) & (new_m.cap - 1);
|
|
while (new_m.data[j].key) { j = (j + 1) % new_m.cap; }
|
|
new_m.data[j].key = m->data[i].key;
|
|
new_m.data[j].val = m->data[i].val;
|
|
new_m.len++;
|
|
}
|
|
}
|
|
|
|
free(m->data);
|
|
*m = new_m;
|
|
return OK();
|
|
}
|
|
|
|
FUNCDEF(bool, _it_next)(NAME m, ITEM_TYPE **it) {
|
|
*it == NULL ? *it = m.data : (*it)++;
|
|
while (*it < m.data + m.cap && (!(*it)->key || (*it)->key == TOMBSTONE)) { (*it)++; }
|
|
return *it < m.data + m.cap;
|
|
}
|
|
#endif
|
|
|
|
#undef ITEM_TYPE
|
|
#undef TOMBSTONE
|
|
|
|
#include "../internal/generic/end.h"
|