/* Perform one split operation on the given node with the given parent. */ static void node_split(hattrie_t* T, node_ptr parent, node_ptr node) { /* only buckets may be split */ assert(*node.flag & NODE_TYPE_PURE_BUCKET || *node.flag & NODE_TYPE_HYBRID_BUCKET); assert(*parent.flag & NODE_TYPE_TRIE); if (*node.flag & NODE_TYPE_PURE_BUCKET) { /* turn the pure bucket into a hybrid bucket */ parent.t->xs[node.b->c0].t = alloc_trie_node(T, node); /* if the bucket had an empty key, move it to the new trie node */ value_t* val = hhash_find(node.b, NULL, 0); if (val) { parent.t->xs[node.b->c0].t->val = *val; parent.t->xs[node.b->c0].t->flag |= NODE_HAS_VAL; *val = 0; hhash_del(node.b, NULL, 0); } node.b->c0 = 0x00; node.b->c1 = TRIE_MAXCHAR; node.b->flag = NODE_TYPE_HYBRID_BUCKET; return; } /* This is a hybrid bucket. Perform a proper split. */ hashnode_split(T, parent, node); }
int hattrie_del(hattrie_t* T, const char* key, size_t len) { node_ptr parent = T->root; assert(*parent.flag & NODE_TYPE_TRIE); /* find node for deletion */ node_ptr node = hattrie_find(&parent, &key, &len); if (node.flag == NULL) { return -1; } /* if consumed on a trie node, clear the value */ if (*node.flag & NODE_TYPE_TRIE) { return hattrie_clrval(T, node); } /* remove from bucket */ size_t m_old = node.b->weight; int ret = hhash_del(node.b, key, len); T->m -= (m_old - node.b->weight); /* merge empty buckets */ /*! \todo */ return ret; }
int main(int argc, char *argv[]) { plan(11); /* Create memory pool context. */ struct mempool *pool = mp_new(64 * 1024); knot_mm_t mm; mm.ctx = pool; mm.alloc = (knot_mm_alloc_t)mp_alloc; mm.free = NULL; /* Create hashtable */ int ret = KNOT_EOK; uint16_t len = 0; const char *key = "mykey", *cur = NULL, *prev = NULL; value_t val = (void*)0xdeadbeef, *rval = NULL; hhash_iter_t it; hhash_t *tbl = hhash_create_mm(ELEM_COUNT, &mm); ok(tbl != NULL, "hhash: create"); if (tbl == NULL) { return KNOT_ERROR; /* No point in testing further on. */ } /* Generate random keys. */ char *keys[ELEM_COUNT]; unsigned nfilled = 0; for (unsigned i = 0; i < ELEM_COUNT; ++i) { keys[i] = test_randstr_mm(&mm); } /* Insert single element. */ ret = hhash_insert(tbl, key, KEY_LEN(key), val); ok(ret == KNOT_EOK, "hhash: insert single element"); /* Retrieve nonexistent element. */ cur = "nokey"; rval = hhash_find(tbl, cur, KEY_LEN(cur)); ok(rval == NULL, "hhash: find non-existent element"); /* Retrieve single element. */ rval = hhash_find(tbl, key, KEY_LEN(key)); ok(rval != NULL, "hhash: find existing element"); /* Fill the table. */ for (unsigned i = 0; i < ELEM_COUNT; ++i) { ret = hhash_insert(tbl, keys[i], KEY_LEN(keys[i]), keys[i]); if (ret != KNOT_EOK) { nfilled = i; break; } } /* Check all keys integrity. */ unsigned nfound = 0; for (unsigned i = 0; i < nfilled; ++i) { rval = hhash_find(tbl, keys[i], KEY_LEN(keys[i])); if (!rval || memcmp(*rval, keys[i], KEY_LEN(keys[i])) != 0) { break; /* Mismatch */ } ++nfound; } is_int(nfilled, nfound, "hhash: found all inserted keys"); /* Test keys order index. */ hhash_build_index(tbl); hhash_iter_begin(tbl, &it, true); while (!hhash_iter_finished(&it)) { cur = hhash_iter_key(&it, &len); if (!str_check_sort(prev, cur)) { break; } prev = cur; int strl = strlen(cur); assert(strl + 1 == len); hhash_iter_next(&it); } ok(hhash_iter_finished(&it), "hhash: passed order index checks"); /* Retrieve all keys. */ nfound = 0; hhash_iter_begin(tbl, &it, false); while (!hhash_iter_finished(&it)) { cur = hhash_iter_key(&it, &len); if (hhash_find(tbl, cur, len) == NULL) { break; } else { ++nfound; } hhash_iter_next(&it); } ok(hhash_iter_finished(&it), "hhash: found all iterated keys"); is_int(tbl->weight, nfound, "hhash: all iterated keys found"); /* Test find less or equal. */ prev = "mykey0"; /* mykey should precede it */ hhash_find_leq(tbl, prev, KEY_LEN(prev), &rval); ok(rval && *rval == val, "hhash: find less or equal"); /* Delete key and retrieve it. */ ret = hhash_del(tbl, key, KEY_LEN(key)); ok(ret == KNOT_EOK, "hhash: remove key"); rval = hhash_find(tbl, key, KEY_LEN(key)); ok(rval == NULL, "hhash: find removed element"); /* Free all memory. */ mp_delete(mm.ctx); return KNOT_EOK; }