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; }