void test_dlist_remove_data_from_existing_until_empty(void)
{
unsigned long *val;
unsigned long i;
val = NULL;
i = dlist_size(test_dlist);
while(i > 0) {
val = dlist_index(test_dlist, --i);
assert_true(val != NULL);
assert_true(dlist_remove_data(test_dlist, val) == 0);
assert_true(i == dlist_size(test_dlist));
}
assert_true(dlist_is_empty(test_dlist));
}
void print_list(const DList *list) {
DListElmt *element;
int *data,
i;
/*****************************************************************************
* *
* Display the doubly-linked list. *
* *
*****************************************************************************/
fprintf(stdout, "List size is %d\n", dlist_size(list));
i = 0;
element = dlist_head(list);
while (1) {
data = dlist_data(element);
fprintf(stdout, "list[%03d]=%03d\n", i, *data);
i++;
if (dlist_is_tail(element))
break;
else
element = dlist_next(element);
}
return;
}
/* dlist_remove */
int dlist_remove(DList *list, DListElmt *element, void **data)
{
/* Do not allow a NULL element or removal from an empty list. */
if (element == NULL || dlist_size(list) == 0)
return -1;
/* Remove the element from the list. */
*data = element->data;
if (element == list->head)
{
/* Handle removal from the head of the list. */
list->head = element->next;
if (list->head == NULL)
list->tail = NULL;
else
element->next->prev = NULL;
}
else
{
/* Handle removal from other than the head of the list. */
element->prev->next = element->next;
if (element->next == NULL)
list->tail = element->prev;
else
element->next->prev = element->prev;
}
/* Free the storage allocated by the abstract datatype. */
list->size--;
return 0;
}
void _hashtable_rehash(HASHTABLE *t, size_t newsize)
{
ARRAY table;
DLIST *bucket;
size_t i, j, hash;
DLIST_ITER it, end;
array_init(&table, sizeof(DLIST));
array_resize(&table, newsize);
for (i = 0; i != newsize; ++i) {
dlist_init((DLIST*)array_at(&table, i), t->element_size);
}
j = array_size(&t->table);
for (i = 0; i != j; ++i) {
bucket = (DLIST*)array_at(&t->table, i);
if (dlist_size(bucket)) {
end = dlist_end(bucket);
for (it = dlist_begin(bucket); it != end; it = dlist_next(it)) {
hash = _hashtable_hash(t, dlist_at(it)) % newsize;
dlist_push((DLIST*)array_at(&table, hash), dlist_at(it));
}
}
}
array_destroy(&t->table);
memcpy(&t->table, &table, sizeof(ARRAY));
}
int dlist_remove(DList *list, DListNode *element, void **data)
{
if (dlist_size(list) == 0 || element == NULL) {
printf("dlist_remove error for dlist_size(list) = 0 || element = NULL");
return -1;
}
*data = element->data;
if (dlist_head(list) == element) {
list->head = element->next;
if (list->head == NULL)
list->tail = NULL;
else
element->next->prev = list->head;
} else {
element->prev->next = element->next;
if (element->next == NULL)
list->tail = element->prev;
else
element->next->prev = element->prev;
}
free(element);
list->size--;
return 0;
}
boolean dlist_remove_front( lc_dlist_t* p_list ) /* O(1) */
{
lc_dlist_node_t* p_node;
boolean result = TRUE;
assert( p_list );
assert( dlist_size(p_list) >= 1 );
p_node = p_list->head->next;
if( p_node )
{
p_node->prev = NULL;
if( p_node->next == NULL )
{
p_list->tail = p_node;
}
}
else
{
p_list->tail = NULL;
}
DESTROY_CHECK(
result = p_list->destroy( p_list->head->data );
);
int dlist_remove(Dlist *dlist,DlistElmt *element,void **data)
{
if(element == NULL || dlist_size(dlist)=0)
return -1;
*data=element->data;
if(element==dlist->head)
{
dlist->head=element->next;
if(dlist->head == NULL)
dlist->tail=NULL;
else
element->next->prev=NULL;
}
else
{
element->prev->next=element->next;
if(element->next == NULL)
dlist->tail=element->prev;
else
element->next->prev=element->prev;
}
free(element);
dlist->size--;
return 0;
}
int dlist_remove(dlist_t *list, dlist_elem_t *element, void **data)
{
if (element == NULL || dlist_size(list) == 0)
return -1;
*data = element->data;
if (element == list->head)
{
list->head =element->next;
if (list->head == NULL)
list->tail = NULL;
else
element->next->prev = NULL;
}
else
{
element->prev->next = element->next;
if (element->next == NULL)
list->tail = element->prev;
else
element->next->prev = element->prev;
}
free(element);
list->size--;
return 0;
}
int dlist_remove(DList *list, listElement *element, void **data)
{
//NULL gali buti tik kai sarasas tuscias
if (element == NULL && dlist_size(list) != 0)
return(-1);
*data = element->data;
if (element == list->head){
//pasalinam is pradzios
list->head = element->next;
if (list->head != NULL)
element->next->prev = NULL;
}
else {
//pasalinam ne is pradzios
element->prev->next = element->next;
if (element->next == NULL)
list->tail = element->prev;
else
element->next->prev = element->prev;
}
//atlaisvinam atminti reikalinga saraso elementui
free(element);
list->size--;
return(0);
}
void test_dlist_mergesort_existing(void)
{
unsigned long old_size;
/* DListIterator *it; */
assert_true(test_dlist != NULL);
assert_false(dlist_is_empty(test_dlist));
old_size = dlist_size(test_dlist);
assert_true(dlist_mergesort(test_dlist, (CompareFn)ulong_compare) == 0);
/* Verify */
assert_true(dlist_is_sorted(test_dlist, (CompareFn)ulong_compare));
assert_true(dlist_size(test_dlist) == old_size);
}
void test_dlist_prepend_to_empty(void)
{
unsigned long *val = NULL;
assert_true(test_dlist == NULL);
test_dlist = dlist_create();
assert_true(test_dlist != NULL);
assert_true(dlist_is_empty(test_dlist));
val = make_ulong_ptr(9999);
assert_true(val != NULL);
assert_true(dlist_prepend(test_dlist, val) == 0);
/* Verify */
val = NULL;
val = dlist_index(test_dlist, 0);
assert_true(val != NULL);
assert_ulong_equal(9999, *val);
assert_true(dlist_size(test_dlist) == 1);
dlist_free_all(test_dlist, NULL);
test_dlist = NULL;
}
// remove an element from the list and set the pointer to data in that element
int dlist_remove (DList *list, DListElmt *element, void **data)
{
if (dlist_size(list) == 0 || element == NULL) {
// removing from empty list is not allowed
// cannot remove a null element
return -1;
}
*data = element->data;
if (element == list->head) {
// removing from the head of the list
list->head = element->next;
if (list->head == NULL) {
list->tail = NULL;
} else {
list->head->prev = NULL;
}
} else {
// removing from other part of the list
element->prev->next = element->next;
if (element->next == NULL) {
list->tail = element->prev;
} else {
element->next->prev = element->prev;
}
}
free (element);
list->size--;
return 0;
}
void*
spellcast_hash_iterator_next(hash_iterator *h_iter)
{
int bucket, i;
listElement *element;
while (h_iter->index != h_iter->htable->buckets) {
bucket = hash_key(h_iter->htable, h_iter->index);
while (dlist_size(&h_iter->htable->table[bucket]) != h_iter->inner_index) {
element = dlist_head(&h_iter->htable->table[bucket]);
for (i = 0; i < h_iter->inner_index; i++) {
element = dlist_next(element);
}
h_iter->inner_index++;
return dlist_data(element);
}
h_iter->inner_index = 0;
h_iter->index++;
}
h_iter->index = 0;
return NULL;
}
int dlist_insert(DList *list, const void *data)
{
listElement *new_element;
//issiskiriam vietos naujam elementui
if ((new_element = (listElement*) malloc(sizeof(listElement))) == NULL)
return(-1);
new_element->data = (void*)data;
if (dlist_size(list) == 0){
//iterpimas i tuscia sarasa
list->head = new_element;
list->tail = new_element;
new_element->prev = NULL;
new_element->next = NULL;
}
else {
//iterpimas i netuscia sarasa
//iterpiame i saraso pabaiga
new_element->next = NULL;
new_element->prev = list->tail;
list->tail->next = new_element;
list->tail = new_element;
}
//Atnaujinam saraso dydi
list->size++;
return(0);
}
int dlist_ins_prev(DList *list, DListElmt *element, const void *data)
{
DListElmt *new_element;
/*
* Only allow element to be NULL if the list is empty
*/
if (element == NULL && dlist_size(list) != 0)
return -1;
/*
* Allocate storage for element and set payload
*/
if ((new_element = (DListElmt *)malloc(sizeof(DListElmt))) == NULL)
return -1;
new_element->data = (void *) data;
/*
* Insert element into list
*/
if (dlist_size(list) == 0) { /* Case 1: List is empty */
new_element->next = NULL;
new_element->prev = NULL;
list->head = new_element;
list->tail = new_element;
}
else { /* Case 2: List is not empty */
/* Hook up new_element */
new_element->prev = element->prev;
new_element->next = element;
/* Hook up element */
element->prev = new_element;
/* Hook up next element and update head if necessary*/
if (dlist_is_head(list, element))
list->head = new_element;
else
new_element->prev->next = new_element;
}
return 0;
}
//删除所有节点，利用init函数的destroy函数来清理内存
void dlist_destroy(DList* list)
{
void *data;
while((dlist_size(list))>0){
if(dlist_remove(list,dlist_tail(list),(void **)&data)==0
&& list->destroy != NULL){
list->destroy(data);
}
}
}
char *rant_op_size(bot_t * bot, dlist_t ** dl)
{
char *str = NULL;
if (!bot || !dl)
return NULL;
str = str_unite("%i", dlist_size(*dl));
return str;
}
void dlist_destroy(DList *list)
{
void *data;
while (dlist_size(list) > 0){
if (dlist_remove(list, dlist_tail(list), (void**)&data) == 0 && list->destroy != NULL){
//saukiam vartotojo nustatyta funkcija destroy dinaminei atminciai atlaisvinti
list->destroy(data);
}
}
}
void dlist_destroy(dlist_t *list)
{
void *data;
while (dlist_size(list) > 0)
{
if (dlist_remove(list, dlist_tail(list), (void **)&data) == 0 && list->destroy != NULL)
list->destroy(data);
}
memset(list, 0, sizeof(dlist_t));
}
// insert a data into list after the given element
//
// case 1 : list is not empty && element is null : -1
// case 2 : new element allocation fail : -1
// case 3 : list is empty : insert the data, update size
// case 4 : list is not empty :
// case 4.1 :
// case 4.2 :
//
int dlist_ins_next (DList *list, DListElmt *element, const void *data)
{
if (element == NULL && dlist_size(list) != 0) {
// case 1 : not invalid element of a non-empty list
return -1;
}
// allocate memory for new element
DListElmt *new_element;
if ((new_element = (DListElmt *)malloc(sizeof(DListElmt)) == NULL)) {
// case 2 : could not allocate memory for new element
return -1;
}
new_element->data = (void *)data;
if (dlist_size(list) == 0) {
// case 3 : empty list
list->head = new_element;
list->tail = new_element;
list->head->prev = NULL;
list->head->next = NULL;
} else {
// case 4 : non-empty list
new_element->next = element->next;
new_element->prev = element;
if (element->next == NULL) {
// case 4.1 : given element is the last element in list
list->tail = new_element;
} else {
// case 4.2 : given element is not the last element
element->next->prev = new_element;
}
element->next = new_element;
}
list->size++;
return 0;
}
/* *********************************************** */
static listElement* get_element(DList *list, int n)
{
if (n < 0 || n > dlist_size(list)-1)
return (NULL);
int i = 0;
listElement *temp = list->head;
for (; i < n ; i++)
temp = temp->next;
return(temp);
}
void dlist_destroy(Dlist *dlist)
{
void *data;
while(dlist_size(dlist)>0)
{
if(dlist_remove(dlist,dlist_head(dlist),(void **)&data)==0 && dlist->destroy != NULL)
dlist->destroy(data);
}
memset(dlist,0,sizeof(Dlist));
return ;
}
void test_dlist_create(void)
{
test_dlist = dlist_create();
assert_true(test_dlist != NULL);
assert_true(dlist_size(test_dlist) == 0);
assert_true(dlist_is_empty(test_dlist));
dlist_free(test_dlist);
test_dlist = NULL;
}
void test_dlist_reverse_existing(void)
{
unsigned long old_size, val_check;
unsigned long *val;
DListIterator *it;
old_size = dlist_size(test_dlist);
assert_true(dlist_reverse(test_dlist) == 0);
/* Verify */
val = NULL;
assert_true(old_size == dlist_size(test_dlist));
for(it = dlist_begin(test_dlist), val_check = 999;
it != NULL; it = dlist_next(it), val_check--) {
val = (unsigned long *)dlist_get_data(it);
assert_ulong_equal(val_check, *val);
}
}
/* dlist_ins_prev */
int dlist_ins_prev(DList *list, DListElmt *element, const void *data)
{
DListElmt *new_element;
/* Do not allow a NULL element unless the list is empty. */
if (element == NULL && dlist_size(list) != 0)
return -1;
/* Allocate storage to be managed by the abstract datatype. */
if ((new_element = (DListElmt *)malloc(sizeof(DListElmt))) == NULL)
return -1;
/* Insert the new element into the list. */
new_element->data = (void *)data;
if (dlist_size(list) == 0)
{
/* Handle insertion when the list is empty. */
list->head = new_element;
list->head->prev = NULL;
list->head->next = NULL;
list->tail = new_element;
}
else
{
/* Handle insertion when the list is not empty. */
new_element->next = element;
new_element->prev = element->prev;
if (element->prev == NULL)
list->head = new_element;
else
element->prev->next = new_element;
element->prev = new_element;
}
/* Adjust the size od the list to account for the inserted element. */
list->size++;
return 0;
}
int dlist_ins_next(DList *list, DListElmt *element, const void *data)
{
DListElmt *new_element;
if (element == NULL && dlist_size(list) != 0)
{
return -1;
}
if ((new_element = (DListElmt*)malloc(sizeof(DListElmt))) == NULL)
{
return -1;
}
new_element->data = (void*)data;
if (dlist_size(list) == 0)
{
list->head = new_element;
list->head->prev = NULL;
list->head->next = NULL;
list->tail = new_element;
}
else
{
new_element->next = element->next;
new_element->prev = element;
if (element->next == NULL)
{
list->tail = new_element;
}
else
{
element->next->prev = new_element;
}
element->next = new_element;
}
list->size++;
return 0;
}
// destroy a list by removing all the elements
void dlist_destroy (DList *list)
{
void *data;
while (dlist_size(list) > 0) {
if ((dlist_remove(list, dlist_tail(list), (void **)&data)) == 0 && list-destroy != NULL) {
list->destroy (data);
}
}
memset (list, 0, sizeof(DList));
return;
}
static inline int
dlist_attach(Dlist *dl, Dlist_data *inserted, Dlist_data *inserted_n)
{
Dlist_data *inserted_p = dlist_prev(inserted_n);
dlist_next(inserted_p) = inserted;
dlist_prev(inserted) = inserted_p;
dlist_next(inserted) = inserted_n;
dlist_prev(inserted_n) = inserted;
dlist_size(dl)++;
return 1;
}
void dlist_destroy(DList *list)
{
/* Destroy the double list */
void *data;
while(dlist_size(list) != 0) {
if (dlist_remove(list, dlist_tail(list), (void **)&data) == 0 &&
list->destroy != NULL) {
list->destroy(data);
}
}
memset(list, 0, sizeof(DList));
return;
}
/* dlist_destroy */
void dlist_destroy(Dlist *list) {
void *data;
/* Remove each element. */
while(dlist_size(list) > 0) {
if(dlist_remove(list, dlist_tail(list), (void **)&data) == 0 && list->destroy != NULL) {
/* call a user-defined function to free dynamically allocated data. */
list->destroy(data);
}
}
/* no operations are allowed now, but clear the structure as a precaution. */
memset(list, 0, sizeof(DList));
return;
}