void Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if(map)
{
if(map->buckets)
{
for(i = 0; i < DArray_count(map->buckets); i++)
{
DArray *bucket = DArray_get(map->buckets, i);
if(bucket)
{
for(j = 0; j < DArray_count(bucket); j++)
{
free(DArray_get(bucket,j));
}
DArray_destroy(bucket);
}
}
DArray_destroy(map->buckets);
}
free(map);
}
}
void Hashmap_destroy(Hashmap *map, Hashmap_destroy_func destroy_f)
{
int i = 0;
int j = 0;
if (map) {
if (map->buckets) {
for (i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if (!bucket) continue;
for (j = 0; j < DArray_count(bucket); j++) {
void *val = DArray_get(bucket, j);
HashmapNode *node = val;
bdestroy(node->key);
if (destroy_f != NULL) {
destroy_f(node->data);
}
free(val);
}
DArray_destroy(bucket);
}
DArray_destroy(map->buckets);
}
free(map);
}
}
void Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if (map) {
if (map->buckets) {
for (i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if (bucket) {
for (j = 0; j < DArray_count(bucket); j++) {
HashmapNode *node = DArray_get(bucket, j);
if (node != NULL) {
free(node->data);
map->free_key(node->key);
}
}
DArray_clear_destroy(bucket);
DArray_remove(map->buckets, i);
}
}
DArray_clear_destroy(map->buckets);
}
free(map);
}
}
DArray* _merge_sort(DArray* array, DArray_compare cmp)
{
DArray_check(array);
if(array->end <= 1)
return array;
DArray* left = DArray_create(array->element_size, array->max);
check_mem(left);
DArray* right = DArray_create(array->element_size, array->max);
check_mem(right);
int middle = array->end/2;
int i = 0;
for(i = 0; i < array->end; i++) {
if(i < middle) {
DArray_push(left, DArray_get(array, i));
} else {
DArray_push(right, DArray_get(array, i));
}
}
DArray* sort_left = _merge_sort(left, cmp);
check(left != NULL, "Error in left merge sort");
DArray* sort_right = _merge_sort(right, cmp);
check(right != NULL, "Error in right merge sort");
if(sort_left != left) DArray_destroy(left);
if(sort_right != right) DArray_destroy(right);
return _merge_array(sort_left, sort_right, cmp);
error:
return NULL;
}
void
Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if(!map){
return;
}
if(!map->buckets){
return;
}
for(i = 0; i < DArray_count(map->buckets); i++){
//用DArray作桶,但桶里的每个元素也是DArray
//用DArray代替链表避免hash碰撞
//最后一层的DArray里放的才是HashmapNode
DArray *bucket = DArray_get(map->buckets, i);
if(!bucket){
continue;
}
for(j = 0; j < DArray_count(bucket); j++){
free(DArray_get(bucket,j));
}
DArray_destroy(bucket);
}
}
char *test_get()
{
mu_assert(DArray_get(array, 0) == val1, "Wrong first value.");
mu_assert(DArray_get(array, 1) == val2, "Wrong second value.");
return NULL;
}
void sift_down(DArray *array, int start, int end, DArray_compare cmp)
{
int root = start;
int child;
int swp;
while (root * 2 + 1 <= end) {
child = root * 2 + 1;
swp = root;
if (cmp(DArray_get(array, swp), DArray_get(array, child)) < 0) {
swp = child;
}
if (child + 1 <= end &&
(cmp(DArray_get(array, swp), DArray_get(array, child + 1))) < 0) {
swp = child + 1;
}
if (swp == root) {
return;
} else {
swap(array, root, swp);
root = swp;
}
}
}
int is_sorted(DArray *array)
{
int i = 0;
for (i = 0; i < DArray_count(array) - 1; i++) {
if (strcmp(DArray_get(array, i), DArray_get(array, i+1)) > 0) {
return 0;
}
}
return 1;
}
char *test_remove() {
int *val_check = DArray_remove(array, 0);
mu_assert(val_check != NULL, "Should not get NULL");
mu_assert(*val_check == *val1, "Should get the first value");
mu_assert(DArray_get(array,0) == NULL, "Should be gone.");
DArray_free(val_check);
val_check = DArray_remove(array, 1);
mu_assert(val_check != NULL, "Should not get NULL");
mu_assert(*val_check == *val2, "Should get the second value");
mu_assert(DArray_get(array,1) == NULL, "Should be gone.");
DArray_free(val_check);
return NULL;
}
DArray *
CloseNodes_GetNodes(CloseNodes *close)
{
assert(close != NULL && "NULL CloseNodes pointer");
DArray *nodes = DArray_create(sizeof(Node *),
DArray_max(close->close_nodes));
check(nodes != NULL, "DArray_create failed");
int i = 0;
for (i = 0; i < DArray_count(close->close_nodes); i++)
{
struct CloseNode *close_node = DArray_get(close->close_nodes, i);
check(close_node != NULL, "NULL CloseNodes entry");
check(close_node->node != NULL, "NULL Node pointer in CloseNodes entry");
int rc = DArray_push(nodes, close_node->node);
check(rc == 0, "DArray_push failed");
}
return nodes;
error:
DArray_destroy(nodes);
return NULL;
}
static inline DArray *Hashmap_find_bucket(Hashmap * map, void *key,
int create,
uint32_t * hash_out)
{
uint32_t hash = map->hash(key);
int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
check(bucket_n >= 0, "Invalid bucket found: %d", bucket_n);
// store it for the return so the caller can use it
*hash_out = hash;
DArray *bucket = DArray_get(map->buckets, bucket_n);
if (!bucket && create) {
// new bucket, set it up
bucket = DArray_create(
sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
check_mem(bucket);
DArray_set(map->buckets, bucket_n, bucket);
}
return bucket;
error:
return NULL;
}
DArray DArray_group_by(DArray array, DArray_group_by_fn *group_by_fn)
{
if (DArray_is_empty(array) || !group_by_fn) return NULL;
DArray groups = DArray_create(sizeof(DArray), 10);
DArray group;
int idx;
void *el;
size_t count = (size_t) DArray_count(array);
for (size_t i = 0; i < count; i++) {
el = DArray_remove(array, i);
if (!el) continue;
idx = group_by_fn(el);
if (idx == -1) continue;
group = DArray_get(groups, idx);
if (!group) {
group = DArray_create(array->element_size, DArray_count(array) + 1);
DArray_ensure_capacity(groups, idx + 1);
DArray_set(groups, idx, group);
}
DArray_push(group, el);
}
return groups;
}
void *Hashmap_delete(Hashmap *map, void *key)
{
uint32_t hash = 0;
DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash);
if(!bucket) {
return NULL;
}
int i = Hashmap_get_node(map, hash, bucket, key);
if(i == -1) {
return NULL;
}
HashmapNode *node = DArray_get(bucket, i);
void *data = node->data;
free(node);
HashmapNode *ending = DArray_pop(bucket);
if(ending != node) {
// alright looks like it's not the last one, swap it.
DArray_set(bucket, i, ending);
}
return data;
}
char *test_copy() {
DArray *orig = DArray_create(sizeof(int), 11);
DArray *dest = DArray_create(sizeof(int), 11);
int i = 0;
for(i = 0; i < 10; i++) {
int *el_to_add = DArray_new(orig);
*el_to_add = i;
mu_assert(DArray_push(orig, el_to_add) == 0, "Pushing to DArray failed.");
}
int rc = DArray_copy(orig, dest);
mu_assert(rc == 0, "Copy failed.")
mu_assert(orig->max == dest->max, "max did not copy properly.");
mu_assert(orig->end == dest->end, "end did not copy properly.");
mu_assert(orig->element_size == dest->element_size,
"element_size did not copy properly.");
mu_assert(orig->expand_rate == dest->expand_rate,
"expand_rate did not copy properly.");
for(i = 0; i < 10; i++) {
int *val = DArray_get(dest, i);
mu_assert(val != NULL, "Got NULL from copy.");
mu_assert(*val == i,
"Failed to copy contents correctly.");
}
return NULL;
}
char *test_push_pop()
{
DArray *array = DArray_create(sizeof(intptr_t), 5);
DArray_push(array, (void *) (intptr_t) 30);
DArray_push(array, (void *) (intptr_t) 20);
DArray_push(array, (void *) (intptr_t) 10);
intptr_t value = (intptr_t) DArray_pop(array);
assert(value == 10 && "pop'ed wrong value from array.");
value = (intptr_t) DArray_pop(array);
assert(value == 20 && "pop'ed wrong value from array.");
value = (intptr_t) DArray_pop(array);
assert(value == 30 && "pop'ed wrong value from array.");
DArray_push(array, (void *) (intptr_t) 60);
value = (intptr_t) DArray_get(array, 0);
assert(value == 60 && "Getting value by index after pop'ing all values from array failed.");
DArray_destroy(array);
return NULL;
}
void print_DArray_IDinfo ( DArray *array)
{
int i = 0;
if(array->element_size > 0) {
PrintVisitor* pV = print_visitor_new();
for(i = 0; i < DArray_end(array); i++) {
HashmapNode* node = (HashmapNode*) DArray_get(array,i);
ID_info* idi = (ID_info*)node->data;
if(idi) {
char* type = string_from_ID_info(idi);
if(type)
{
switch (idi->type){
case 0:
debug("Const %10s ID: %20s : Remove %d isTrigger %d isPrint %d Value %d\n\n", type, idi->id, idi->k_remove, idi->isTrigger, idi->isPrint, *(int*) idi->value);
break;
case 1:
debug("Input %10s ID: %20s : Remove %d isTrigger %d isPrint %d\n\n", type, idi->id, idi->k_remove, idi->isTrigger, idi->isPrint);
break;
case 2:{
debug("Output %10s ID: %20s : Remove %d isTrigger %d isPrint %d Value:\n\n", type, idi->id, idi->k_remove, idi->isTrigger, idi->isPrint);
ast* value = (ast*) idi->value;
value->accept(value, pV->visitor);
debug("\n");
break;
}
case 3:{
debug("Template %10s ID: %20s : Remove -1 isTrigger -1 isPrint -1 Value:\n", type, idi->id);
debug(" Parameter: ");
list_t* iter = idi->parameter;
do{
PARA_info* pI = (PARA_info*) iter->data;
if(pI->valuetype == 0)
debug("%s: bool, ", pI->id );
else{
if(pI->valuetype == 1)
debug("%s: int, ", pI->id );
else
debug("%s: double, ", pI->id);
}
iter = iter->succ;
} while (iter != idi->parameter);
debug("\n");
ast* value = (ast*) idi->value;
value->accept(value, pV->visitor);
debug("\n\n");
break;
}
default:
debug("error: 0-3 but was: %d\n\n", idi->type);
exit(1);
}
}
}
}
pV->destroy(pV);
}
}
void destroy_keys(DArray *keys) {
int i = 0;
for(i = 0; i < NUM_KEYS; i++) {
bdestroy(DArray_get(keys, i));
}
DArray_destroy(keys);
}
void fill_distribution(int *stats, DArray *keys, Hashmap_hash hash_func) {
int i = 0;
uint32_t hash = 0;
for(i = 0; i < DArray_count(keys); i++) {
hash = hash_func(DArray_get(keys, i));
stats[hash % BUCKETS] += 1;
}
}
int Hashmap_traverse(Hashmap* map, Hashmap_traverse_cb traverse_cb) {
int i = 0;
int j = 0;
int rc = 0;
for(i = 0; i < DArray_count(map->buckets); i++) {
DArray* bucket = DArray_get(map->buckets, i);
if(bucket) {
for(j = 0; j < DArray_count(bucket); j++) {
HashmapNode* node = DArray_get(bucket, j);
rc = traverse_cb(node);
if(rc != 0) return rc;
}
}
}
return 0;
}
int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb traverse_cb)
{//walks every bucket if bucket has any values then traverse_cb on each value scans whole hash map for its values
int i = 0;
int j = 0;
int rc = 0;
for(i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if(bucket) {
for(j = 0; j < DArray_count(bucket); j++) {
HashmapNode *node = DArray_get(bucket, j);
rc = traverse_cb(node);
if(rc != 0) return rc;
}
}
}
return 0;
}
void fill_distribution(int *stats, DArray *keys, Hashmap_hash hash_func)//keys from gen keys to fill stats array
{ //goes through all keys does the hash then finds its bucket same as hashmap
int i = 0;
uint32_t hash = 0;
for(i = 0; i < DArray_count(keys); i++) {
hash = hash_func(DArray_get(keys, i));
stats[hash % BUCKETS] += 1;
}
}
int qs_partition(DArray *array, DArray_compare cmp, int low, int hi)
{
void *pivot = DArray_get(array, low);
int i = low - 1;
int j = hi + 1;
while (1) {
do {
j--;
} while (cmp(DArray_get(array, j), pivot) > 0);
do {
i++;
} while(cmp(DArray_get(array, i), pivot) < 0);
if (i < j) {
swap(array, i, j);
} else {
return j;
}
}
}
char *test_get_set_undefinedIndex()
{
DArray *array = DArray_create(sizeof(intptr_t), 100);
void *value_at_undefined_index = DArray_get(array, 1);
assert(value_at_undefined_index == NULL && "Getting value at undefined index is not NULL.");
DArray_destroy(array);
return NULL;
}
char *test_get_set()
{
DArray *array = DArray_create(sizeof(intptr_t), 5);
intptr_t value;
DArray_set(array, 1, (void *) (intptr_t) 15);
value = (intptr_t) DArray_get(array, 1);
assert(value == 15 && "Did not get expected value at index 1.");
assert(array->size == 1 && "Unexpected array size after adding one element at index 1.");
DArray_set(array, 4, (void *) (intptr_t) 9789);
value = (intptr_t) DArray_get(array, 4);
assert(value == 9789 && "Did not get expected value at index 4.");
assert(array->size == 2 && "Unexpected array size after adding one element at index 4.");
DArray_destroy(array);
return NULL;
}
NodeAddress *getFSFromServicePool() {
NodeAddress *fsAddress = NULL;
if (DArray_count(fsList) > 0) {
fsAddress = DArray_get(fsList, fsPosition++);
if (fsPosition == DArray_count(fsList))
fsPosition = 0;
}
return fsAddress;
}
static inline int Hashmap_get_node(Hashmap* map, uint32_t hash, DArray* bucket, void* key) {
int i = 0;
for(i = 0; i < DArray_end(bucket); i++) {
debug("TRY: %d", i);
HashmapNode* node = DArray_get(bucket, i);
if(node->hash == hash && map->compare(node->key, key) == 0) {
return i;
}
}
return -1;
}
void parse_and_dump(PerceptronModel mdl, FILE *fp, CoNLLCorpus corpus) {
for (int si = 0; si < DArray_count(corpus->sentences); si++) {
FeaturedSentence sent = DArray_get(corpus->sentences, si);
build_adjacency_matrix(corpus, si, mdl->embedding_w, NULL);
int *model = parse(sent);
for (int j = 1; j < sent->length; j++) {
Word w = (Word) DArray_get(sent->words, j);
int p = w->parent;
char *form = w->form;
char *postag = w->postag;
fprintf(fp, "%d\t%s\t%s\t%d\t%d\n", j, form, postag, p, model[j]);
}
fprintf(fp, "\n");
}
}
char *test_expand_setUndefinedIndexExpandsArray()
{
int initial_capacity = 2;
DArray *array = DArray_create(sizeof(intptr_t), initial_capacity);
DArray_set(array, 0, (void *) (intptr_t) 9789);
DArray_set(array, 1, (void *) (intptr_t) 747);
assert(array->size == 2 && "Unexpected array size after adding 2 elements");
assert(array->capacity == initial_capacity && "Unexpected array capacity - should match initial capacity.");
DArray_set(array, 2, (void *) (intptr_t) 8776);
assert(array->size == 3 && "Unexpected array size - after adding one more element.");
assert(array->capacity == (initial_capacity + DARRAY_DEFAULT_EXPAND_RATE) && "Unexpected array capacity after expanding.");
intptr_t value = (intptr_t) DArray_get(array, 0);
assert(value == 9789 && "Did not get expected value at index 0.");
value = (intptr_t) DArray_get(array, 1);
assert(value == 747 && "Did not get expected value at index 1.");
value = (intptr_t) DArray_get(array, 2);
assert(value == 8776 && "Did not get expected value at index 2.");
// index 0 1 2 are set, all others should be NULL
for (int i = initial_capacity + 1;
i < initial_capacity + DARRAY_DEFAULT_EXPAND_RATE;
i++) {
void *null_value = DArray_get(array, i);
assert(null_value == NULL && "Expected remaining indexes to be NULL");
}
DArray_destroy(array);
return NULL;
}
char * test_get_name()
{
DArray * array = DB_get_name("select db");
int count = DArray_count(array);
int i;
for(i=0;i<count;i++)
{
snippet_print(DArray_get(array,i),stdout);
}
DArray_clear_destroy(array,snippet_destroy);
return NULL;
}
int DArray_mergesort(DArray *array, DArray_compare cmp)
{
int count = array->end;
if (count > 1) {
int pivot = count / 2;
int after_pivot = count - pivot;
DArray *left = DArray_create(array->element_size, pivot);
DArray *right = DArray_create(array->element_size, after_pivot);
for (int i = 0; i < pivot; i++) {
DArray_push(left, DArray_get(array, i));
}
for (int i = pivot; i < count; i++) {
DArray_push(right, DArray_get(array, i));
}
DArray_mergesort(left, cmp);
DArray_mergesort(left, cmp);
int i = 0;
int l_ptr = 0;
int r_ptr = 0;
for (i = 0; i < count; i++) {
if (l_ptr >= pivot) {
DArray_set(array, i, DArray_get(right, r_ptr));
r_ptr++;
} else if (r_ptr >= after_pivot) {
DArray_set(array, i, DArray_get(left, l_ptr));
l_ptr++;
} else if (cmp(DArray_get(left, l_ptr), DArray_get(right, r_ptr)) < 0) {
DArray_set(array, i, DArray_get(left, l_ptr));
l_ptr++;
} else {
DArray_set(array, i, DArray_get(right, r_ptr));
r_ptr++;
}
}
DArray_destroy(left);
DArray_destroy(right);
}
return 0;
}
