自学教程：C++ DArray_get函数代码示例

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

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