dlist_t *dlist_search_all(dlist_t *thiz, void *key, dlist_cmp_t cmp) { int i; node_t *t; if (NULL != thiz->indxs) dlist_destroy(thiz->indxs); thiz->indxs = dlist_create(sizeof(int), NULL); if (NULL == thiz->indxs) goto err0; for (i = 0, t = thiz->head; i < thiz->count; i++, t = t->next) { if (!cmp(key, t->data)) { if (0 != dlist_append(thiz->indxs, &i)) goto err1; } } return thiz->indxs; err1: dlist_destroy(thiz->indxs); return NULL; err0: return NULL; }
/** * sysfs_close_class: close the given class * @cls: sysfs_class to close */ void sysfs_close_class(struct sysfs_class *cls) { if (cls) { if (cls->devices) dlist_destroy(cls->devices); if (cls->attrlist) dlist_destroy(cls->attrlist); free(cls); } }
/** * sysfs_close_bus: close single bus * @bus: bus structure */ void sysfs_close_bus(struct sysfs_bus *bus) { if (bus) { if (bus->attrlist) dlist_destroy(bus->attrlist); if (bus->devices) dlist_destroy(bus->devices); if (bus->drivers) dlist_destroy(bus->drivers); free(bus); } }
/** * sysfs_close_driver: closes driver and deletes device lists too * @driver: driver to close */ void sysfs_close_driver(struct sysfs_driver *driver) { if (driver) { if (driver->devices) dlist_destroy(driver->devices); if (driver->attrlist) dlist_destroy(driver->attrlist); if (driver->module) sysfs_close_module(driver->module); free(driver); } }
/** * sysfs_close_directory: closes directory, cleans up attributes and links * @sysdir: sysfs_directory to close */ void sysfs_close_directory(struct sysfs_directory *sysdir) { if (sysdir != NULL) { if (sysdir->subdirs != NULL) dlist_destroy(sysdir->subdirs); if (sysdir->links != NULL) dlist_destroy(sysdir->links); if (sysdir->attributes != NULL) dlist_destroy(sysdir->attributes); free(sysdir); sysdir = NULL; } }
static int dlist_int_test() { printf("double list test ... MAX=%d\n", MAX); int arr[MAX]; int i; int sum = 0; int max = INT_MIN; printf("MAX = %d\n", MAX); struct dlist *list = dlist_init(); if (list) { /* * init arr */ for (i = 0; i < MAX; i++) { arr[i] = i; } /* * dlist_add/dlist_length test */ for (i = 0; i < MAX; i++) { dlist_add(list, arr + i); assert(dlist_length(list) == i + 1); } /* * dlist_serch test */ for (i = 0; i < MAX; i++) { assert(dlist_search(list, arr + i) == DLIST_RET_OK); } /* * dlist_printf test */ assert(dlist_printf(list, user_printf) == DLIST_RET_OK); assert(dlist_foreach(list, sum_cb, &sum) == DLIST_RET_OK); assert(dlist_foreach(list, max_cb, &max) == DLIST_RET_OK); /* * dlist_delete test */ for (i = MAX - 1; i >= 0; i--) { assert(dlist_length(list) == i + 1); assert(dlist_delete(list, arr + i) == DLIST_RET_OK); assert(dlist_length(list) == i); } /* * dlist_destroy test */ assert(dlist_destroy(list) == DLIST_RET_OK); } printf("sum = %d\n", sum); printf("max = %d\n", max); return 0; }
void hashtable_destroy(HASHTABLE *t) { size_t i, j; j = array_size(&t->table); for (i = 0; i != j; ++i) { dlist_destroy((DLIST*)array_at(&t->table, i)); } array_destroy(&t->table); }
static void linear_container_dlist_destroy(LinearContainer* thiz) { PrivInfo* priv = (PrivInfo*)thiz->priv; dlist_destroy(priv->dlist); free(thiz); return; }
int main(void) { struct dlist *dlist = (struct dlist *)malloc(sizeof(*dlist)); assert(dlist != NULL); dlist_init(dlist); struct data_info s[]= { {"jack", 13}, {"mary", 18}, {"candy", 20}, }; int i = 0; for (; i < sizeof(s) / sizeof(s[0]); i++) { dlist->add(dlist, s + i, sizeof(s[0])); } printf("顺向遍历:\n"); dlist->for_each(dlist, print_node); printf("逆向遍历:\n"); dlist->for_each_rev(dlist, print_node); struct node *node = NULL; #if 1 printf("按姓名查找\n"); node = dlist->find(dlist, "jack", cmp_name); if (node == NULL) { printf("没有找到\n"); } else { struct data_info *info = (struct data_info *)node->data; printf("%s: %d\n", info->name, info->age); printf("删除该节点\n"); dlist->del(node); } #endif #if 0 printf("按年龄查找\n"); while(1) { node = dlist->find(dlist, (int *)19, cmp_age); if (node == NULL) { break; } else { struct data_info *info = (struct data_info *)node->data; printf("%s: %d\n", info->name, info->age); } } #endif printf("顺向遍历:\n"); dlist->for_each(dlist, print_node); dlist_destroy(dlist); return 0; }
static void test_int_dlist(void) { int i = 0; int n = 100; int data = 0; DList* dlist = dlist_create(NULL, NULL, NULL); for(i = 0; i < n; i++) { assert(dlist_append(dlist, (void*)i) == RET_OK); assert(dlist_length(dlist) == (i + 1)); assert(dlist_get_by_index(dlist, i, (void**)&data) == RET_OK); assert(data == i); assert(dlist_set_by_index(dlist, i, (void*)(2*i)) == RET_OK); assert(dlist_get_by_index(dlist, i, (void**)&data) == RET_OK); assert(data == 2*i); assert(dlist_set_by_index(dlist, i, (void*)i) == RET_OK); assert(dlist_find(dlist, cmp_int, (void*)i) == i); } for(i = 0; i < n; i++) { assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK); assert(data == (i)); assert(dlist_length(dlist) == (n-i)); assert(dlist_delete(dlist, 0) == RET_OK); assert(dlist_length(dlist) == (n-i-1)); if((i + 1) < n) { assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK); assert((int)data == (i+1)); } } assert(dlist_length(dlist) == 0); for(i = 0; i < n; i++) { assert(dlist_prepend(dlist, (void*)i) == RET_OK); assert(dlist_length(dlist) == (i + 1)); assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK); assert(data == i); assert(dlist_set_by_index(dlist, 0, (void*)(2*i)) == RET_OK); assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK); assert(data == 2*i); assert(dlist_set_by_index(dlist, 0, (void*)i) == RET_OK); } i = n - 1; assert(dlist_foreach(dlist, check_and_dec_int, &i) == RET_OK); dlist_destroy(dlist); return; }
static void usbip_imported_device_delete(void *device) { struct usbip_imported_device *idev = (struct usbip_imported_device *) device; if(idev->cdev_list) dlist_destroy(idev->cdev_list); free(idev); }
void spellcast_htable_destroy(sp_hash_table *ht) { int i; for (i = 0; i < ht->buckets; i++) { dlist_destroy(&ht->table[i]); } free(ht->table); }
real_t convexhull_compute_min_perimeter_rectangle(polygon_t *minrect, polygon_t *chull) { real_t perimeter, temp; dlist_t *circumrects; polygon_t *rect; point_t *p, *q, *r; dlink_t *a, *b; assert(minrect); // assert(minrect->count == 4); assert(chull); assert(chull->count >= 3); circumrects = dlist_new(); convexhull_create_circumference_rectangles(circumrects, chull); b = NULL; for (a = circumrects->tail->next; a != circumrects->head; a = a->next) { rect = (polygon_t *)a->object; p = polygon_glimpse(0, rect); q = polygon_glimpse(1, rect); r = polygon_glimpse(2, rect); temp = 2 * (get_distance_of_p2p(p, q) + get_distance_of_p2p(q, r)); if ((b == NULL) || (temp < perimeter)) { b = a; perimeter = temp; } } /* dlink_cutoff(b); circumrects->count--; minrect = (polygon_t *)b->object; minrect->reference--; dlink_destroy(b); */ /* polygon_insert(point_new(), minrect); polygon_insert(point_new(), minrect); polygon_insert(point_new(), minrect); polygon_insert(point_new(), minrect); polygon_copy(minrect, (polygon_t *)b->object); */ polygon_insert(polygon_glimpse(0, (polygon_t *)b->object), minrect); polygon_insert(polygon_glimpse(1, (polygon_t *)b->object), minrect); polygon_insert(polygon_glimpse(2, (polygon_t *)b->object), minrect); polygon_insert(polygon_glimpse(3, (polygon_t *)b->object), minrect); convexhull_delete_circumference_rectangles(circumrects); dlist_destroy(circumrects); return perimeter; }
void queue_destroy(Queue* thiz) { if(thiz != NULL) { dlist_destroy(thiz->dlist); thiz->dlist = NULL; free(thiz); } return; }
/** * sysfs_close_class_device: closes a single class device. * @dev: class device to close. */ void sysfs_close_class_device(struct sysfs_class_device *dev) { if (dev) { if (dev->parent) sysfs_close_class_device(dev->parent); if (dev->sysdevice) sysfs_close_device(dev->sysdevice); if (dev->attrlist) dlist_destroy(dev->attrlist); free(dev); } }
void usbip_stub_driver_close(void) { if (!stub_driver) return; if (stub_driver->edev_list) dlist_destroy(stub_driver->edev_list); if (stub_driver->sysfs_driver) sysfs_close_driver(stub_driver->sysfs_driver); free(stub_driver); stub_driver = NULL; }
static struct usbip_imported_device *usbip_imported_device_new(struct usbip_vhci_driver *driver, char *busid) { struct usbip_imported_device *idev = NULL; struct sysfs_device *sudev; idev = (struct usbip_imported_device *) calloc(1, sizeof(*idev)); if(!idev) return NULL; /* * The members of idev->cdev_list are also linked from * driver->cdev_list. They are freed by destroy of driver->cdev_list. * */ idev->cdev_list = dlist_new(sizeof(struct class_device)); if(!idev->cdev_list) goto err; sudev = sysfs_open_device("usb", busid); if(!sudev) { err("sysfs_open_device %s", busid); goto err; } read_usb_device(sudev, &idev->udev); sysfs_close_device(sudev); /* add class devices of this imported device */ struct class_device *cdev; dlist_for_each_data(driver->cdev_list, cdev, struct class_device) { if(!strncmp(cdev->devpath, idev->udev.path, strlen(idev->udev.path))) { struct class_device *new_cdev; new_cdev = calloc(1, sizeof(*new_cdev)); if(!new_cdev) goto err; memcpy(new_cdev, cdev, sizeof(*new_cdev)); dlist_unshift(idev->cdev_list, (void*) new_cdev); } } return idev; err: if(idev->cdev_list) dlist_destroy(idev->cdev_list); if(idev) free(idev); return NULL; }
inline void input_history_clear(struct input *input) { dlist_destroy(input->history, NULL, input_free); input->history = NULL; input->history_end = NULL; input->history_cur = NULL; input->history_len = 0; input->input_buf[0] = '\0'; input->cur = input->prompt_len; input->begin_completion = input->cur; input->len = 0; input->dirty = 1; }
static void multi_thread_test(void) { pthread_t consumer_tid = 0; pthread_t producer_tid = 0; Locker* locker = locker_pthread_create(); Locker* nest_locker = locker_nest_create(locker, (TaskSelfFunc)pthread_self); DList* dlist = dlist_create(NULL, NULL, nest_locker); pthread_create(&producer_tid, NULL, producer, dlist); pthread_create(&consumer_tid, NULL, consumer, dlist); pthread_join(consumer_tid, NULL); pthread_join(producer_tid, NULL); dlist_destroy(dlist); return; }
/* void line_list_delete(line_list_t *list) { dlink_t *link; line_t *line; assert(list); for (link = list->tail->next; link != list->head; link = link->next) { line = (line_t *)link->object; line_(line); } } */ void line_list_destroy(line_list_t *list) { dlink_t *link; assert(list); if (line_list_get_ref(list) <= 0) { while (line_list_get_count(list) > 0) { link = dlist_pop((dlist_t *)list); line_destroy((line_t *)link->object); dlink_destroy(link); } dlist_destroy((dlist_t *)list); } else { line_list_dec_ref(list); } }
void point_list_destroy(point_list_t *list) { dlink_t *link; assert(list); if (point_list_get_ref(list) <= 0) { while (point_list_get_count(list) > 0) { link = dlist_pop((dlist_t *)list); point_destroy((point_t *)link->object); dlink_destroy(link); } dlist_destroy((dlist_t *)list); } else { list->reference--; } }
int main(int argc, char *argv[]) { struct bitree *tree; int cnt; tree = build(DEFAULT_TREE_SIZE); if (!tree) { fprintf(stderr, "build tree error\n"); exit(EXIT_FAILURE); } traverse_dump(tree, TRAVE_PREORDER); traverse_dump(tree, TRAVE_INORDER); traverse_dump(tree, TRAVE_POSTORDER); traverse_dump(tree, TRAVE_LEVELORDER); fprintf(stdout, "\nmirroring the tree\n"); mirror(tree->root); traverse_dump(tree, TRAVE_LEVELORDER); mirror(tree->root); /* reverse */ fprintf(stdout, "\ndoubling the tree\n"); double_tree(tree); traverse_dump(tree, TRAVE_LEVELORDER); traverse_dump(tree, TRAVE_INORDER); traverse_dump(tree, TRAVE_PREORDER); cnt = print_paths(tree->root); fprintf(stdout, "total %d paths\n", cnt); exit: if (visit_list) dlist_destroy(visit_list); free(bitree_root(tree)->data); bitree_destroy(tree); free(tree); exit(EXIT_SUCCESS); }
void packet_transfer_destroy(PacketTransfer *thiz) { if (thiz != NULL) { if (thiz->uploader_socket != -1) { close(thiz->uploader_socket); } int i; for (i = 0; i < NODE_NUM; i++) { dlist_destroy(thiz->command_set[i]); } thiz->gather_board = NULL; free(thiz); } }
int usbip_stub_driver_open(void) { int ret; stub_driver = (struct usbip_stub_driver *) calloc(1, sizeof(*stub_driver)); if (!stub_driver) { err("alloc stub_driver"); return -1; } stub_driver->ndevs = 0; stub_driver->edev_list = dlist_new_with_delete(sizeof(struct usbip_exported_device), usbip_exported_device_delete); if (!stub_driver->edev_list) { err("alloc dlist"); goto err; } stub_driver->sysfs_driver = open_sysfs_stub_driver(); if (!stub_driver->sysfs_driver) goto err; ret = refresh_exported_devices(); if (ret < 0) goto err; return 0; err: if (stub_driver->sysfs_driver) sysfs_close_driver(stub_driver->sysfs_driver); if (stub_driver->edev_list) dlist_destroy(stub_driver->edev_list); free(stub_driver); stub_driver = NULL; return -1; }
void hash_table_destroy(HashTable* thiz) { size_t i = 0; if(thiz != NULL) { for(i = 0; i < thiz->slot_nr; i++) { if(thiz->slots[i] != NULL) { dlist_destroy(thiz->slots[i]); thiz->slots[i] = NULL; } } free(thiz->slots); free(thiz); } return; }
int main(int argc, char* argv[]) { int i = 0; int n = 100; DList* dlist = dlist_create(); /*for(i = 0; i < n; i++) { assert(dlist_append(dlist, (void*)i) == DLIST_RET_OK); }*/ for(i = 0; i < n; i++) { assert(dlist_prepend(dlist, (void*)i) == DLIST_RET_OK); } dlist_print(dlist, print_int); dlist_destroy(dlist); return 0; }
void dlist_destroy(dlist_t *thiz) { int i; node_t *tail, *save; if (NULL != thiz->indxs) dlist_destroy(thiz->indxs); for(i = 0, tail = thiz->head; i < thiz->count; i++, tail = save) { save = tail->next; if (NULL != thiz->dstr) thiz->dstr(tail->data); free(tail->data); free(tail); } }
static int dlist_char_test() { char str[] = "dlist"; char str2[] = "thinking"; struct dlist *list = dlist_init(); assert(list != NULL); return_val_if_fail(dlist_length(list) == 0, -1); char *pstr = NULL; dlist_add(list, str); return_val_if_fail(dlist_length(list) == 1, -1); dlist_add(list, str2); dlist_add(list, pstr = strdup("test")); dlist_foreach(list, string_toupper_cb, NULL); dlist_printf(list, string_printf); dlist_destroy(list); list = NULL; free(pstr); return 0; }
int main(int argc, char* argv[]) { int i = 0; int num = 10; dlist* head = dlist_creat(); #ifdef TEST //#ifdef DLIST_CREAT_ARRAY //dlist_creat_array(); //#endif /*DLIST_CREAT_ARRAY*/ for (i = 0; i < num; i++) { /*dlist_ret ret = dlist_append(head, (void*)i); assert(ret == DLIST_RET_OK);*/ assert(dlist_append(head, (void*)i) == DLIST_RET_OK); /*dlist_append(head, (void*)i);*/ } /*for () { assert(dlist_prepend() == DLIST_RET_OK); } */ //dlist_insert(); // dlist_delete(); dlist_delete(head, 2); dlist_insert(head, 2 ,(void*)11); dlist_print(head, print_int); dlist_destroy(head); #endif /*TEST*/ }
static void multi_thread_test(void) { pthread_t consumer_tid = 0; pthread_t producer_tid = 0; pthread_t reader_tid = 0; Locker* rw_locker = locker_pthread_create(); Locker* rd_locker = locker_pthread_create(); DList* dlist = dlist_create(NULL, NULL, rw_locker_create(rw_locker, rd_locker)); pthread_create(&producer_tid, NULL, producer, dlist); pthread_create(&consumer_tid, NULL, consumer, dlist); pthread_create(&reader_tid, NULL, reader, dlist); pthread_join(consumer_tid, NULL); pthread_join(producer_tid, NULL); pthread_join(reader_tid, NULL); printf("length=%d\n", dlist_length(dlist)); dlist_destroy(dlist); return; }