void removePlayer(Player *player)
{
pthread_mutex_lock(player->players->lock);
fprintf(stderr,"%s will be removed\nPlayers count: %d\n", player->nick, arraylist_size(player->players));
int index = findPlayerIndex(player);
assert(index >= 0);
disposePlayer(player);
arraylist_remove(player->players, index);
fprintf(stderr,"Players count: %d\n", arraylist_size(player->players));
pthread_mutex_unlock(player->players->lock);
}
void *arraylist_pop(struct arraylist *array)
{
check(array->end - 1 >= 0, "Attempt to pop from empty array.");
void *el = arraylist_remove(array, array->end - 1);
array->end--;
if (arraylist_end(array) > (int) array->expand_rate && arraylist_end(array) % array->expand_rate)
arraylist_contract(array);
return el;
error:
return NULL;
}
int main() {
ARRAYLIST myArrayList = arraylist_init();
myArrayList->Array = malloc(10*sizeof(int));
int j,k,l,m,n;
j = 1;
k = 2;
l = 5;
n = 3;
m = 4;
arraylist_prepend(myArrayList, &j);
printArr(myArrayList);
arraylist_append(myArrayList, &k);
arraylist_append(myArrayList, &l);
arraylist_append(myArrayList, &j);
arraylist_append(myArrayList, &n);
printArr(myArrayList);
arraylist_insert(myArrayList, &m, 1);//insert 4 to index 1
printArr(myArrayList);
int u = 8;
arraylist_set(myArrayList, &u, 3);// set index 3 as 8
printArr(myArrayList);
int *a = arraylist_get(myArrayList, 3);//get address of index 3
printf("get %d\n", *a);
arraylist_insert(myArrayList, &m, 10);//insert 4 to index of 10 which does not exist
printArr(myArrayList);
arraylist_insert(myArrayList, &k, 15);//insert 2 to index of 15 which does not exist
printArr(myArrayList);
arraylist_set(myArrayList, &k, 7);//set index 7 as 2
printArr(myArrayList);
arraylist_remove(myArrayList, 1);//remove index of 9
printArr(myArrayList);
arraylist_removeall(myArrayList);//remove everything
printArr(myArrayList);
arraylist_free(myArrayList);
return 1;
}
void *arraylist_pop(arraylist_t *a, unsigned int *l)
{
return arraylist_remove(a, l, 0);
}
ArrayListValue seqstack_pop(ArrayList *seqstack) {
ArrayListValue result = seqstack->data[seqstack->length-1];
arraylist_remove(seqstack, seqstack->length-1);
return result;
}
void
test_arraylist (int initial_size, int sorted, int allow_duplicates)
{
struct t_arraylist *arraylist;
int i, index, index_insert;
void *pointer;
const char *item_aaa = "aaa";
const char *item_abc = "abc";
const char *item_DEF = "DEF";
const char *item_Def = "Def";
const char *item_def = "def";
const char *item_xxx = "xxx";
const char *item_zzz = "zzz";
/* create arraylist */
arraylist = arraylist_new (initial_size,
sorted,
allow_duplicates,
&test_cmp_cb, NULL,
NULL, NULL);
/* check values after creation */
CHECK(arraylist);
LONGS_EQUAL(0, arraylist->size);
LONGS_EQUAL(initial_size, arraylist->size_alloc);
LONGS_EQUAL(initial_size, arraylist->size_alloc_min);
if (initial_size > 0)
{
CHECK(arraylist->data);
for (i = 0; i < initial_size; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
POINTERS_EQUAL(NULL, arraylist->data);
}
LONGS_EQUAL(sorted, arraylist->sorted);
LONGS_EQUAL(allow_duplicates, arraylist->allow_duplicates);
/* check size */
LONGS_EQUAL(0, arraylist_size (arraylist));
/* get element (this should always fail, the list is empty!) */
POINTERS_EQUAL(NULL, arraylist_get (NULL, -1));
POINTERS_EQUAL(NULL, arraylist_get (NULL, 0));
POINTERS_EQUAL(NULL, arraylist_get (NULL, 1));
POINTERS_EQUAL(NULL, arraylist_get (arraylist, -1));
POINTERS_EQUAL(NULL, arraylist_get (arraylist, 0));
POINTERS_EQUAL(NULL, arraylist_get (arraylist, 1));
/* search element (this should always fail, the list is empty!) */
POINTERS_EQUAL(NULL, arraylist_search (NULL, NULL, NULL, NULL));
POINTERS_EQUAL(NULL, arraylist_search (arraylist, NULL, NULL, NULL));
POINTERS_EQUAL(NULL,
arraylist_search (NULL, (void *)item_abc, NULL, NULL));
POINTERS_EQUAL(NULL,
arraylist_search (arraylist, (void *)item_abc, NULL, NULL));
/* invalid add of element */
LONGS_EQUAL(-1, arraylist_add (NULL, NULL));
/* add some elements */
if (sorted)
{
TEST_ARRAYLIST_ADD(0, item_zzz);
TEST_ARRAYLIST_ADD(0, item_xxx);
TEST_ARRAYLIST_ADD(0, NULL);
TEST_ARRAYLIST_ADD(1, item_DEF);
TEST_ARRAYLIST_ADD((allow_duplicates) ? 2 : 1, item_def);
TEST_ARRAYLIST_ADD((allow_duplicates) ? 3 : 1, item_Def);
TEST_ARRAYLIST_ADD(1, item_abc);
}
else
{
TEST_ARRAYLIST_ADD(0, item_zzz);
TEST_ARRAYLIST_ADD(1, item_xxx);
TEST_ARRAYLIST_ADD(2, NULL);
TEST_ARRAYLIST_ADD(3, item_DEF);
TEST_ARRAYLIST_ADD((allow_duplicates) ? 4 : 3, item_def);
TEST_ARRAYLIST_ADD((allow_duplicates) ? 5 : 3, item_Def);
TEST_ARRAYLIST_ADD((allow_duplicates) ? 6 : 4, item_abc);
}
/*
* arraylist is now:
* sorted:
* dup : [NULL, "abc", "DEF", "def", "Def", "xxx", "zzz"] + 2 NULL
* no dup: [NULL, "abc", "Def", "xxx", "zzz"] + 1 NULL
* not sorted:
* dup : ["zzz", "xxx", NULL, "DEF", "def", "Def", "abc"] + 2 NULL
* no dup: ["zzz", "xxx", NULL, "Def", "abc"] + 1 NULL
*/
/* check size after adds */
LONGS_EQUAL((allow_duplicates) ? 7 : 5, arraylist->size);
LONGS_EQUAL((allow_duplicates) ? 7 : 5, arraylist_size (arraylist));
LONGS_EQUAL((allow_duplicates) ? 9 : 6, arraylist->size_alloc);
/* check content after adds */
if (sorted)
{
if (allow_duplicates)
{
POINTERS_EQUAL(NULL, arraylist->data[0]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_DEF, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_def, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[4]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[5]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[6]);
for (i = 7; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
POINTERS_EQUAL(NULL, arraylist->data[0]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[4]);
for (i = 5; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
else
{
if (allow_duplicates)
{
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[1]);
POINTERS_EQUAL(NULL, arraylist->data[2]);
STRCMP_EQUAL(item_DEF, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_def, (const char *)arraylist->data[4]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[5]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[6]);
for (i = 7; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[1]);
POINTERS_EQUAL(NULL, arraylist->data[2]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[4]);
for (i = 5; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
/* search elements */
if (sorted)
{
if (allow_duplicates)
{
TEST_ARRAYLIST_SEARCH(NULL, 0, 1, NULL);
TEST_ARRAYLIST_SEARCH(item_abc, 1, 2, item_abc);
TEST_ARRAYLIST_SEARCH(item_DEF, 2, 5, item_DEF);
TEST_ARRAYLIST_SEARCH(item_DEF, 2, 5, item_def);
TEST_ARRAYLIST_SEARCH(item_DEF, 2, 5, item_Def);
TEST_ARRAYLIST_SEARCH(item_xxx, 5, 6, item_xxx);
TEST_ARRAYLIST_SEARCH(item_zzz, 6, 7, item_zzz);
}
else
{
TEST_ARRAYLIST_SEARCH(NULL, 0, 1, NULL);
TEST_ARRAYLIST_SEARCH(item_abc, 1, 2, item_abc);
TEST_ARRAYLIST_SEARCH(item_Def, 2, 3, item_DEF);
TEST_ARRAYLIST_SEARCH(item_Def, 2, 3, item_def);
TEST_ARRAYLIST_SEARCH(item_Def, 2, 3, item_Def);
TEST_ARRAYLIST_SEARCH(item_xxx, 3, 4, item_xxx);
TEST_ARRAYLIST_SEARCH(item_zzz, 4, 5, item_zzz);
}
/* search non-existing element */
TEST_ARRAYLIST_SEARCH(NULL, -1, 1, item_aaa);
}
else
{
if (allow_duplicates)
{
TEST_ARRAYLIST_SEARCH(item_zzz, 0, -1, item_zzz);
TEST_ARRAYLIST_SEARCH(item_xxx, 1, -1, item_xxx);
TEST_ARRAYLIST_SEARCH(NULL, 2, -1, NULL);
TEST_ARRAYLIST_SEARCH(item_DEF, 3, -1, item_DEF);
TEST_ARRAYLIST_SEARCH(item_DEF, 3, -1, item_def);
TEST_ARRAYLIST_SEARCH(item_DEF, 3, -1, item_Def);
TEST_ARRAYLIST_SEARCH(item_abc, 6, -1, item_abc);
}
else
{
TEST_ARRAYLIST_SEARCH(item_zzz, 0, -1, item_zzz);
TEST_ARRAYLIST_SEARCH(item_xxx, 1, -1, item_xxx);
TEST_ARRAYLIST_SEARCH(NULL, 2, -1, NULL);
TEST_ARRAYLIST_SEARCH(item_Def, 3, -1, item_DEF);
TEST_ARRAYLIST_SEARCH(item_Def, 3, -1, item_def);
TEST_ARRAYLIST_SEARCH(item_Def, 3, -1, item_Def);
TEST_ARRAYLIST_SEARCH(item_abc, 4, -1, item_abc);
}
/* search non-existing element */
TEST_ARRAYLIST_SEARCH(NULL, -1, -1, item_aaa);
}
/* invalid remove of elements */
LONGS_EQUAL(-1, arraylist_remove (NULL, -1));
LONGS_EQUAL(-1, arraylist_remove (arraylist, -1));
LONGS_EQUAL(-1, arraylist_remove (NULL, 0));
/* remove the 3 first elements and check size after each remove */
LONGS_EQUAL(0, arraylist_remove (arraylist, 0));
LONGS_EQUAL((allow_duplicates) ? 6 : 4, arraylist->size);
LONGS_EQUAL((allow_duplicates) ? 6 : 4, arraylist_size (arraylist));
LONGS_EQUAL((allow_duplicates) ? 9 : 6, arraylist->size_alloc);
LONGS_EQUAL(0, arraylist_remove (arraylist, 0));
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist->size);
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist_size (arraylist));
LONGS_EQUAL((allow_duplicates) ? 9 : 6, arraylist->size_alloc);
LONGS_EQUAL(0, arraylist_remove (arraylist, 0));
LONGS_EQUAL((allow_duplicates) ? 4 : 2, arraylist->size);
LONGS_EQUAL((allow_duplicates) ? 4 : 2, arraylist_size (arraylist));
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist->size_alloc);
/*
* arraylist is now:
* sorted:
* dup : ["def", "Def", "xxx", "zzz"] + 1 NULL
* no dup: ["xxx", "zzz"] + 1 NULL
* not sorted:
* dup : ["DEF", "def", "Def", "abc"] + 1 NULL
* no dup: ["Def", "abc"] + 1 NULL
*/
/* check content after the 3 deletions */
if (sorted)
{
if (allow_duplicates)
{
STRCMP_EQUAL(item_def, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[3]);
for (i = 4; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[1]);
for (i = 2; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
else
{
if (allow_duplicates)
{
STRCMP_EQUAL(item_DEF, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_def, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[3]);
for (i = 4; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[1]);
for (i = 2; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
/* invalid insert of element */
LONGS_EQUAL(-1, arraylist_insert (NULL, 0, NULL));
/* insert of one element */
LONGS_EQUAL(0, arraylist_insert (arraylist, 0, (void *)item_aaa));
/*
* arraylist is now:
* sorted:
* dup : ["aaa", "def", "Def", "xxx", "zzz"]
* no dup: ["aaa", "xxx", "zzz"]
* not sorted:
* dup : ["aaa", "DEF", "def", "Def", "abc"]
* no dup: ["aaa", "Def", "abc"]
*/
/* check size after insert */
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist->size);
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist_size (arraylist));
LONGS_EQUAL((allow_duplicates) ? 5 : 3, arraylist->size_alloc);
/* check content after the insert */
if (sorted)
{
if (allow_duplicates)
{
STRCMP_EQUAL(item_aaa, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_def, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[4]);
for (i = 5; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
STRCMP_EQUAL(item_aaa, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_xxx, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_zzz, (const char *)arraylist->data[2]);
for (i = 3; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
else
{
if (allow_duplicates)
{
STRCMP_EQUAL(item_aaa, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_DEF, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_def, (const char *)arraylist->data[2]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[3]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[4]);
for (i = 5; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
STRCMP_EQUAL(item_aaa, (const char *)arraylist->data[0]);
STRCMP_EQUAL(item_Def, (const char *)arraylist->data[1]);
STRCMP_EQUAL(item_abc, (const char *)arraylist->data[2]);
for (i = 3; i < arraylist->size_alloc; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
}
/* clear arraylist */
LONGS_EQUAL(0, arraylist_clear (NULL));
LONGS_EQUAL(1, arraylist_clear (arraylist));
/* check size and data after clear */
LONGS_EQUAL(0, arraylist->size);
LONGS_EQUAL(0, arraylist_size (arraylist));
LONGS_EQUAL(initial_size, arraylist->size_alloc);
if (initial_size > 0)
{
CHECK(arraylist->data);
for (i = 0; i < initial_size; i++)
{
POINTERS_EQUAL(NULL, arraylist->data[i]);
}
}
else
{
POINTERS_EQUAL(NULL, arraylist->data);
}
/* free arraylist */
arraylist_free (arraylist);
}
/*
* removes the item at the end and returns a pointer to it.
* the pointer is malloc'd and should be freed.
* removing from the end takes constant time.
*/
void* arraylist_removeEnd(arraylist *list){
return arraylist_remove(list,list->size-1);
}
