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