int zone_tree_remove(zone_tree_t *tree,
const knot_dname_t *owner,
zone_node_t **removed)
{
if (owner == NULL) {
return KNOT_EINVAL;
}
if (zone_tree_is_empty(tree)) {
return KNOT_ENONODE;
}
uint8_t lf[KNOT_DNAME_MAXLEN];
knot_dname_lf(lf, owner, NULL);
value_t *rval = hattrie_tryget(tree, (char*)lf+1, *lf);
if (rval == NULL) {
return KNOT_ENOENT;
} else {
*removed = (zone_node_t *)(*rval);
}
hattrie_del(tree, (char*)lf+1, *lf);
return KNOT_EOK;
}
long AlnIndex::get(const char* key)
{
value_t* val = hattrie_tryget(t, key, strlen(key));
if (val == NULL) return -1;
else {
return *val - 1;;
}
}
void test_trie_non_ascii()
{
fprintf(stderr, "checking non-ascii... \n");
value_t* u;
hattrie_t* T = hattrie_create();
char* txt = "\x81\x70";
u = hattrie_get(T, txt, strlen(txt));
*u = 10;
u = hattrie_tryget(T, txt, strlen(txt));
if (*u != 10) {
fprintf(stderr, "can't store non-ascii strings\n");
}
hattrie_free(T);
fprintf(stderr, "done.\n");
}
int knot_zone_tree_get(knot_zone_tree_t *tree, const knot_dname_t *owner,
knot_node_t **found)
{
if (tree == NULL || owner == NULL) {
return KNOT_EINVAL;
}
char lf[DNAME_LFT_MAXLEN];
dname_lf(lf, owner, sizeof(lf));
value_t *val = hattrie_tryget(tree, lf+1, *lf);
if (val == NULL) {
*found = NULL;
} else {
*found = (knot_node_t*)(*val);
}
return KNOT_EOK;
}
void test_hattrie_insert()
{
fprintf(stderr, "inserting %zu keys ... \n", k);
size_t i, j;
value_t* u;
value_t v;
for (j = 0; j < k; ++j) {
i = rand() % n;
v = 1 + str_map_get(M, xs[i], strlen(xs[i]));
str_map_set(M, xs[i], strlen(xs[i]), v);
u = hattrie_get(T, xs[i], strlen(xs[i]));
*u += 1;
if (*u != v) {
fprintf(stderr, "[error] tally mismatch (reported: %lu, correct: %lu)\n",
*u, v);
}
}
fprintf(stderr, "sizeof: %zu\n", hattrie_sizeof(T));
fprintf(stderr, "deleting %zu keys ... \n", d);
for (j = 0; j < d; ++j) {
str_map_del(M, ds[j], strlen(ds[j]));
hattrie_del(T, ds[j], strlen(ds[j]));
u = hattrie_tryget(T, ds[j], strlen(ds[j]));
if (u) {
fprintf(stderr, "[error] item %zu still found in trie after delete\n",
j);
}
}
fprintf(stderr, "done.\n");
}
int zone_tree_get(zone_tree_t *tree, const knot_dname_t *owner,
zone_node_t **found)
{
if (owner == NULL) {
return KNOT_EINVAL;
}
if (zone_tree_is_empty(tree)) {
return KNOT_ENONODE;
}
uint8_t lf[KNOT_DNAME_MAXLEN];
knot_dname_lf(lf, owner, NULL);
value_t *val = hattrie_tryget(tree, (char*)lf+1, *lf);
if (val == NULL) {
*found = NULL;
} else {
*found = (zone_node_t*)(*val);
}
return KNOT_EOK;
}
int main(int argc, char *argv[])
{
plan_lazy();
/* Random keys. */
srand(time(NULL));
unsigned key_count = 100000;
char **keys = malloc(sizeof(char*) * key_count);
for (unsigned i = 0; i < key_count; ++i) {
keys[i] = str_key_rand(KEY_MAXLEN);
}
/* Sort random keys. */
str_key_sort(keys, key_count);
/* Create trie */
value_t *val = NULL;
hattrie_t *trie = hattrie_create();
ok(trie != NULL, "hattrie: create");
/* Insert keys */
bool passed = true;
size_t inserted = 0;
for (unsigned i = 0; i < key_count; ++i) {
val = hattrie_get(trie, keys[i], strlen(keys[i]) + 1);
if (!val) {
passed = false;
break;
}
if (*val == NULL) {
*val = keys[i];
++inserted;
}
}
ok(passed, "hattrie: insert");
/* Check total insertions against trie weight. */
is_int(hattrie_weight(trie), inserted, "hattrie: trie weight matches insertions");
/* Build order-index. */
hattrie_build_index(trie);
/* Lookup all keys */
passed = true;
for (unsigned i = 0; i < key_count; ++i) {
val = hattrie_tryget(trie, keys[i], strlen(keys[i]) + 1);
if (val && (*val == keys[i] || strcmp(*val, keys[i]) == 0)) {
continue;
} else {
diag("hattrie: mismatch on element '%u'", i);
passed = false;
break;
}
}
ok(passed, "hattrie: lookup all keys");
/* Lesser or equal lookup. */
passed = true;
for (unsigned i = 0; i < key_count; ++i) {
if (!str_key_find_leq(trie, keys, i, key_count)) {
passed = false;
for (int off = -10; off < 10; ++off) {
int k = (int)i + off;
if (k < 0 || k >= key_count) {
continue;
}
diag("[%u/%d]: %s%s", i, off, off == 0?">":"",keys[k]);
}
break;
}
}
ok(passed, "hattrie: find lesser or equal for all keys");
/* Next lookup. */
passed = true;
for (unsigned i = 0; i < key_count - 1 && passed; ++i) {
value_t *val;
hattrie_find_next(trie, keys[i], strlen(keys[i]), &val);
passed = val && *val == (void *)keys[(i + 1)];
}
ok(passed, "hattrie: find next for all keys");
/* Unsorted iteration */
size_t iterated = 0;
hattrie_iter_t *it = hattrie_iter_begin(trie, false);
while (!hattrie_iter_finished(it)) {
++iterated;
hattrie_iter_next(it);
}
is_int(inserted, iterated, "hattrie: unsorted iteration");
hattrie_iter_free(it);
/* Sorted iteration. */
char key_buf[KEY_MAXLEN] = {'\0'};
iterated = 0;
it = hattrie_iter_begin(trie, true);
while (!hattrie_iter_finished(it)) {
size_t cur_key_len = 0;
const char *cur_key = hattrie_iter_key(it, &cur_key_len);
if (iterated > 0) { /* Only if previous exists. */
if (strcmp(key_buf, cur_key) > 0) {
diag("'%s' <= '%s' FAIL\n", key_buf, cur_key);
break;
}
}
++iterated;
memcpy(key_buf, cur_key, cur_key_len);
hattrie_iter_next(it);
}
is_int(inserted, iterated, "hattrie: sorted iteration");
hattrie_iter_free(it);
/* Cleanup */
for (unsigned i = 0; i < key_count; ++i) {
free(keys[i]);
}
free(keys);
hattrie_free(trie);
return 0;
}
