celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1417320 [7/7] - in /incubator/celix/trunk: dependency_manager/private/src/ dependency_manager/public/include/ deployment_admin/private/include/ deployment_admin/private/src/ device_access/device_access/private/include/ device_access/device...
Date Wed, 05 Dec 2012 09:06:34 GMT
Modified: incubator/celix/trunk/utils/private/src/array_list.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/array_list.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/src/array_list.c (original)
+++ incubator/celix/trunk/utils/private/src/array_list.c Wed Dec  5 09:05:46 2012
@@ -30,12 +30,19 @@
 #include "array_list.h"
 #include "array_list_private.h"
 
-celix_status_t arrayList_create(apr_pool_t *pool, ARRAY_LIST *list) {
+static celix_status_t arrayList_elementEquals(void *a, void *b, bool *equals);
+
+celix_status_t arrayList_create(apr_pool_t *pool, array_list_t *list) {
+	return arrayList_createWithEquals(pool, arrayList_elementEquals, list);
+}
+
+ celix_status_t arrayList_createWithEquals(apr_pool_t *pool, arrayListElementEqualsFunction equals, array_list_t *list) {
 	apr_pool_t *mypool;
 	apr_pool_create(&mypool, pool);
-//	*list = (ARRAY_LIST) apr_palloc(mypool, sizeof(**list));
-	*list = (ARRAY_LIST) malloc(sizeof(**list));
+//	*list = (array_list_t) apr_palloc(mypool, sizeof(**list));
+	*list = (array_list_t) malloc(sizeof(**list));
 
+	(*list)->equals = equals;
 	(*list)->size = 0;
 	(*list)->capacity = 10;
 	(*list)->modCount = 0;
@@ -44,7 +51,7 @@ celix_status_t arrayList_create(apr_pool
 	return CELIX_SUCCESS;
 }
 
-void arrayList_destroy(ARRAY_LIST list) {
+void arrayList_destroy(array_list_t list) {
 	list->size = 0;
 	free(list->elementData);
 	list->elementData = NULL;
@@ -52,7 +59,12 @@ void arrayList_destroy(ARRAY_LIST list) 
 	list = NULL;
 }
 
-void arrayList_trimToSize(ARRAY_LIST list) {
+static celix_status_t arrayList_elementEquals(void *a, void *b, bool *equals) {
+	*equals = (a == b);
+	return CELIX_SUCCESS;
+}
+
+void arrayList_trimToSize(array_list_t list) {
 	unsigned int oldCapacity;
 	list->modCount++;
 	oldCapacity = list->capacity;
@@ -63,7 +75,7 @@ void arrayList_trimToSize(ARRAY_LIST lis
 	}
 }
 
-void arrayList_ensureCapacity(ARRAY_LIST list, int capacity) {
+void arrayList_ensureCapacity(array_list_t list, int capacity) {
 	void ** newList;
 	int oldCapacity;
 	list->modCount++;
@@ -79,20 +91,20 @@ void arrayList_ensureCapacity(ARRAY_LIST
 	}
 }
 
-unsigned int arrayList_size(ARRAY_LIST list) {
+unsigned int arrayList_size(array_list_t list) {
 	return list->size;
 }
 
-bool arrayList_isEmpty(ARRAY_LIST list) {
+bool arrayList_isEmpty(array_list_t list) {
 	return list->size == 0;
 }
 
-bool arrayList_contains(ARRAY_LIST list, void * element) {
+bool arrayList_contains(array_list_t list, void * element) {
 	int index = arrayList_indexOf(list, element);
 	return index >= 0;
 }
 
-int arrayList_indexOf(ARRAY_LIST list, void * element) {
+int arrayList_indexOf(array_list_t list, void * element) {
 	if (element == NULL) {
 		unsigned int i = 0;
 		for (i = 0; i < list->size; i++) {
@@ -103,7 +115,9 @@ int arrayList_indexOf(ARRAY_LIST list, v
 	} else {
 		unsigned int i = 0;
 		for (i = 0; i < list->size; i++) {
-			if (list->elementData[i] == element) { //equalsFunction?
+			bool equals = false;
+			list->equals(element, list->elementData[i], &equals);
+			if (equals) {
 				return i;
 			}
 		}
@@ -111,7 +125,7 @@ int arrayList_indexOf(ARRAY_LIST list, v
 	return -1;
 }
 
-int arrayList_lastIndexOf(ARRAY_LIST list, void * element) {
+int arrayList_lastIndexOf(array_list_t list, void * element) {
 	if (element == NULL) {
 		int i = 0;
 		for (i = list->size - 1; i >= 0; i--) {
@@ -122,7 +136,9 @@ int arrayList_lastIndexOf(ARRAY_LIST lis
 	} else {
 		int i = 0;
 		for (i = list->size - 1; i >= 0; i--) {
-			if (list->elementData[i] == element) { //equalsFunction?
+			bool equals = false;
+			list->equals(element, list->elementData[i], &equals);
+			if (equals) {
 				return i;
 			}
 		}
@@ -130,7 +146,7 @@ int arrayList_lastIndexOf(ARRAY_LIST lis
 	return -1;
 }
 
-void * arrayList_get(ARRAY_LIST list, unsigned int index) {
+void * arrayList_get(array_list_t list, unsigned int index) {
 	if (index >= list->size) {
 		return NULL;
 	}
@@ -138,7 +154,7 @@ void * arrayList_get(ARRAY_LIST list, un
 	return list->elementData[index];
 }
 
-void * arrayList_set(ARRAY_LIST list, unsigned int index, void * element) {
+void * arrayList_set(array_list_t list, unsigned int index, void * element) {
 	void * oldElement;
 	if (index >= list->size) {
 		return NULL;
@@ -149,13 +165,13 @@ void * arrayList_set(ARRAY_LIST list, un
 	return oldElement;
 }
 
-bool arrayList_add(ARRAY_LIST list, void * element) {
+bool arrayList_add(array_list_t list, void * element) {
 	arrayList_ensureCapacity(list, list->size + 1);
 	list->elementData[list->size++] = element;
 	return true;
 }
 
-int arrayList_addIndex(ARRAY_LIST list, unsigned int index, void * element) {
+int arrayList_addIndex(array_list_t list, unsigned int index, void * element) {
 	unsigned int numMoved;
 	if (index > list->size || index < 0) {
 		return -1;
@@ -169,7 +185,7 @@ int arrayList_addIndex(ARRAY_LIST list, 
 	return 0;
 }
 
-void * arrayList_remove(ARRAY_LIST list, unsigned int index) {
+void * arrayList_remove(array_list_t list, unsigned int index) {
 	void * oldElement;
 	unsigned int numMoved;
 	if (index >= list->size) {
@@ -185,7 +201,7 @@ void * arrayList_remove(ARRAY_LIST list,
 	return oldElement;
 }
 
-void arrayList_fastRemove(ARRAY_LIST list, unsigned int index) {
+void arrayList_fastRemove(array_list_t list, unsigned int index) {
 	unsigned int numMoved;
 	list->modCount++;
 
@@ -194,7 +210,7 @@ void arrayList_fastRemove(ARRAY_LIST lis
 	list->elementData[--list->size] = NULL;
 }
 
-bool arrayList_removeElement(ARRAY_LIST list, void * element) {
+bool arrayList_removeElement(array_list_t list, void * element) {
 	if (element == NULL) {
 		unsigned int i = 0;
 		for (i = 0; i < list->size; i++) {
@@ -206,7 +222,9 @@ bool arrayList_removeElement(ARRAY_LIST 
 	} else {
 		unsigned int i = 0;
 		for (i = 0; i < list->size; i++) {
-			if (list->elementData[i] == element) { //equalsFunction?
+			bool equals = false;
+			list->equals(element, list->elementData[i], &equals);
+			if (equals) {
 				arrayList_fastRemove(list, i);
 				return true;
 			}
@@ -215,7 +233,7 @@ bool arrayList_removeElement(ARRAY_LIST 
 	return false;
 }
 
-void arrayList_clear(ARRAY_LIST list) {
+void arrayList_clear(array_list_t list) {
 	unsigned int i;
 	list->modCount++;
 
@@ -226,7 +244,7 @@ void arrayList_clear(ARRAY_LIST list) {
 	list->size = 0;
 }
 
-bool arrayList_addAll(ARRAY_LIST list, ARRAY_LIST toAdd) {
+bool arrayList_addAll(array_list_t list, array_list_t toAdd) {
     unsigned int i;
     unsigned int size = arrayList_size(toAdd);
     arrayList_ensureCapacity(list, list->size + size);
@@ -238,9 +256,9 @@ bool arrayList_addAll(ARRAY_LIST list, A
     return size != 0;
 }
 
-ARRAY_LIST arrayList_clone(apr_pool_t *pool, ARRAY_LIST list) {
+array_list_t arrayList_clone(apr_pool_t *pool, array_list_t list) {
 	unsigned int i;
-	ARRAY_LIST new = NULL;
+	array_list_t new = NULL;
 	arrayList_create(pool, &new);
 //	arrayList_ensureCapacity(new, list->size);
 //	memcpy(new->elementData, list->elementData, list->size);
@@ -253,8 +271,8 @@ ARRAY_LIST arrayList_clone(apr_pool_t *p
 	return new;
 }
 
-ARRAY_LIST_ITERATOR arrayListIterator_create(ARRAY_LIST list) {
-	ARRAY_LIST_ITERATOR iterator = (ARRAY_LIST_ITERATOR) malloc(sizeof(*iterator));
+array_list_iterator_t arrayListIterator_create(array_list_t list) {
+	array_list_iterator_t iterator = (array_list_iterator_t) malloc(sizeof(*iterator));
 
 	iterator->lastReturned = -1;
 	iterator->cursor = 0;
@@ -264,7 +282,7 @@ ARRAY_LIST_ITERATOR arrayListIterator_cr
 	return iterator;
 }
 
-void arrayListIterator_destroy(ARRAY_LIST_ITERATOR iterator) {
+void arrayListIterator_destroy(array_list_iterator_t iterator) {
 	iterator->lastReturned = -1;
 	iterator->cursor = 0;
 	iterator->expectedModificationCount = 0;
@@ -273,11 +291,11 @@ void arrayListIterator_destroy(ARRAY_LIS
 	iterator = NULL;
 }
 
-bool arrayListIterator_hasNext(ARRAY_LIST_ITERATOR iterator) {
+bool arrayListIterator_hasNext(array_list_iterator_t iterator) {
 	return iterator->cursor != iterator->list->size;
 }
 
-void * arrayListIterator_next(ARRAY_LIST_ITERATOR iterator) {
+void * arrayListIterator_next(array_list_iterator_t iterator) {
 	void * next;
 	if (iterator->expectedModificationCount != iterator->list->modCount) {
 		return NULL;
@@ -287,11 +305,11 @@ void * arrayListIterator_next(ARRAY_LIST
 	return next;
 }
 
-bool arrayListIterator_hasPrevious(ARRAY_LIST_ITERATOR iterator) {
+bool arrayListIterator_hasPrevious(array_list_iterator_t iterator) {
 	return iterator->cursor != 0;
 }
 
-void * arrayListIterator_previous(ARRAY_LIST_ITERATOR iterator) {
+void * arrayListIterator_previous(array_list_iterator_t iterator) {
 	int i;
 	void * previous;
 	if (iterator->expectedModificationCount != iterator->list->modCount) {
@@ -303,7 +321,7 @@ void * arrayListIterator_previous(ARRAY_
 	return previous;
 }
 
-void arrayListIterator_remove(ARRAY_LIST_ITERATOR iterator) {
+void arrayListIterator_remove(array_list_iterator_t iterator) {
 	if (iterator->lastReturned == -1) {
 		return;
 	}

Modified: incubator/celix/trunk/utils/private/src/hash_map.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/hash_map.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/src/hash_map.c (original)
+++ incubator/celix/trunk/utils/private/src/hash_map.c Wed Dec  5 09:05:46 2012
@@ -46,7 +46,7 @@ int hashMap_equals(void * toCompare, voi
 	return toCompare == compare;
 }
 
-int hashMap_entryEquals(HASH_MAP map, HASH_MAP_ENTRY entry, HASH_MAP_ENTRY compare) {
+int hashMap_entryEquals(hash_map_t map, hash_map_entry_t entry, hash_map_entry_t compare) {
 	if (entry->key == compare->key || map->equalsKey(entry->key, compare->key)) {
 		if (entry->value == compare->value || map->equalsValue(entry->value, compare->value)) {
 			return true;
@@ -67,11 +67,11 @@ static unsigned int hashMap_indexFor(uns
 	return h & (length - 1);
 }
 
-HASH_MAP hashMap_create(unsigned int (*keyHash)(void *), unsigned int (*valueHash)(void *),
+hash_map_t hashMap_create(unsigned int (*keyHash)(void *), unsigned int (*valueHash)(void *),
 		int (*keyEquals)(void *, void *), int (*valueEquals)(void *, void *)) {
-	HASH_MAP map = (HASH_MAP) malloc(sizeof(*map));
+	hash_map_t map = (hash_map_t) malloc(sizeof(*map));
 	map->treshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
-	map->table = (HASH_MAP_ENTRY *) calloc(DEFAULT_INITIAL_CAPACITY, sizeof(HASH_MAP_ENTRY));
+	map->table = (hash_map_entry_t *) calloc(DEFAULT_INITIAL_CAPACITY, sizeof(hash_map_entry_t));
 	map->size = 0;
 	map->modificationCount = 0;
 	map->tablelength = DEFAULT_INITIAL_CAPACITY;
@@ -96,26 +96,26 @@ HASH_MAP hashMap_create(unsigned int (*k
 	return map;
 }
 
-void hashMap_destroy(HASH_MAP map, bool freeKeys, bool freeValues) {
+void hashMap_destroy(hash_map_t map, bool freeKeys, bool freeValues) {
 	hashMap_clear(map, freeKeys, freeValues);
 	free(map->table);
 	free(map);
 	map = NULL;
 }
 
-int hashMap_size(HASH_MAP map) {
+int hashMap_size(hash_map_t map) {
 	return map->size;
 }
 
-bool hashMap_isEmpty(HASH_MAP map) {
+bool hashMap_isEmpty(hash_map_t map) {
 	return hashMap_size(map) == 0;
 }
 
-void * hashMap_get(HASH_MAP map, void * key) {
+void * hashMap_get(hash_map_t map, void * key) {
 	unsigned int hash;
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	if (key == NULL) {
-		HASH_MAP_ENTRY entry = map->table[0];
+		hash_map_entry_t entry = map->table[0];
 		for (entry = map->table[0]; entry != NULL; entry = entry->next) {
 			if (entry->key == NULL) {
 				return entry->value;
@@ -134,13 +134,13 @@ void * hashMap_get(HASH_MAP map, void * 
 	return NULL;
 }
 
-bool hashMap_containsKey(HASH_MAP map, void * key) {
+bool hashMap_containsKey(hash_map_t map, void * key) {
 	return hashMap_getEntry(map, key) != NULL;
 }
 
-HASH_MAP_ENTRY hashMap_getEntry(HASH_MAP map, void * key) {
+hash_map_entry_t hashMap_getEntry(hash_map_t map, void * key) {
 	unsigned int hash = (key == NULL) ? 0 : hashMap_hash(map->hashKey(key));
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	int index = hashMap_indexFor(hash, map->tablelength);
 	for (entry = map->table[index]; entry != NULL; entry = entry->next) {
 		if (entry->hash == hash && (entry->key == key || map->equalsKey(key, entry->key))) {
@@ -150,12 +150,12 @@ HASH_MAP_ENTRY hashMap_getEntry(HASH_MAP
 	return NULL;
 }
 
-void * hashMap_put(HASH_MAP map, void * key, void * value) {
+void * hashMap_put(hash_map_t map, void * key, void * value) {
 	unsigned int hash;
 	int i;
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	if (key == NULL) {
-		HASH_MAP_ENTRY entry;
+		hash_map_entry_t entry;
 		for (entry = map->table[0]; entry != NULL; entry = entry->next) {
 			if (entry->key == NULL) {
 				void * oldValue = entry->value;
@@ -182,21 +182,21 @@ void * hashMap_put(HASH_MAP map, void * 
 	return NULL;
 }
 
-void hashMap_resize(HASH_MAP map, int newCapacity) {
-	HASH_MAP_ENTRY * newTable;
+void hashMap_resize(hash_map_t map, int newCapacity) {
+	hash_map_entry_t * newTable;
 	unsigned int j;
 	if (map->tablelength == MAXIMUM_CAPACITY) {
 		return;
 	}
 
-	newTable = (HASH_MAP_ENTRY *) calloc(newCapacity, sizeof(HASH_MAP_ENTRY));
+	newTable = (hash_map_entry_t *) calloc(newCapacity, sizeof(hash_map_entry_t));
 
 	for (j = 0; j < map->tablelength; j++) {
-		HASH_MAP_ENTRY entry = map->table[j];
+		hash_map_entry_t entry = map->table[j];
 		if (entry != NULL) {
 			map->table[j] = NULL;
 			do {
-				HASH_MAP_ENTRY next = entry->next;
+				hash_map_entry_t next = entry->next;
 				int i = hashMap_indexFor(entry->hash, newCapacity);
 				entry->next = newTable[i];
 				newTable[i] = entry;
@@ -210,8 +210,8 @@ void hashMap_resize(HASH_MAP map, int ne
 	map->treshold = (unsigned int) ceil(newCapacity * DEFAULT_LOAD_FACTOR);
 }
 
-void * hashMap_remove(HASH_MAP map, void * key) {
-	HASH_MAP_ENTRY entry = hashMap_removeEntryForKey(map, key);
+void * hashMap_remove(hash_map_t map, void * key) {
+	hash_map_entry_t entry = hashMap_removeEntryForKey(map, key);
 	void * value = (entry == NULL ? NULL : entry->value);
 	if (entry != NULL) {
 		entry->key = NULL;
@@ -222,14 +222,14 @@ void * hashMap_remove(HASH_MAP map, void
 	return value;
 }
 
-void * hashMap_removeEntryForKey(HASH_MAP map, void * key) {
+void * hashMap_removeEntryForKey(hash_map_t map, void * key) {
 	unsigned int hash = (key == NULL) ? 0 : hashMap_hash(map->hashKey(key));
 	int i = hashMap_indexFor(hash, map->tablelength);
-	HASH_MAP_ENTRY prev = map->table[i];
-	HASH_MAP_ENTRY entry = prev;
+	hash_map_entry_t prev = map->table[i];
+	hash_map_entry_t entry = prev;
 
 	while (entry != NULL) {
-		HASH_MAP_ENTRY next = entry->next;
+		hash_map_entry_t next = entry->next;
 		if (entry->hash == hash && (entry->key == key || (key != NULL && map->equalsKey(key, entry->key)))) {
 			map->modificationCount++;
 			map->size--;
@@ -247,10 +247,10 @@ void * hashMap_removeEntryForKey(HASH_MA
 	return entry;
 }
 
-HASH_MAP_ENTRY hashMap_removeMapping(HASH_MAP map, HASH_MAP_ENTRY entry) {
+hash_map_entry_t hashMap_removeMapping(hash_map_t map, hash_map_entry_t entry) {
 	unsigned int hash;
-	HASH_MAP_ENTRY prev;
-	HASH_MAP_ENTRY e;
+	hash_map_entry_t prev;
+	hash_map_entry_t e;
     int i;
 	if (entry == NULL) {
 		return NULL;
@@ -261,7 +261,7 @@ HASH_MAP_ENTRY hashMap_removeMapping(HAS
 	e = prev;
 
 	while (e != NULL) {
-		HASH_MAP_ENTRY next = e->next;
+		hash_map_entry_t next = e->next;
 		if (e->hash == hash && hashMap_entryEquals(map, e, entry)) {
 			map->modificationCount++;
 			map->size--;
@@ -279,16 +279,16 @@ HASH_MAP_ENTRY hashMap_removeMapping(HAS
 	return e;
 }
 
-void hashMap_clear(HASH_MAP map, bool freeKey, bool freeValue) {
+void hashMap_clear(hash_map_t map, bool freeKey, bool freeValue) {
 	unsigned int i;
-	HASH_MAP_ENTRY * table;
+	hash_map_entry_t * table;
 	map->modificationCount++;
 	table = map->table;
 
 	for (i = 0; i < map->tablelength; i++) {
-		HASH_MAP_ENTRY entry = table[i];
+		hash_map_entry_t entry = table[i];
 		while (entry != NULL) {
-			HASH_MAP_ENTRY f = entry;
+			hash_map_entry_t f = entry;
 			entry = entry->next;
 			if (freeKey && f->key != NULL)
 				free(f->key);
@@ -301,11 +301,11 @@ void hashMap_clear(HASH_MAP map, bool fr
 	map->size = 0;
 }
 
-bool hashMap_containsValue(HASH_MAP map, void * value) {
+bool hashMap_containsValue(hash_map_t map, void * value) {
 	unsigned int i;
 	if (value == NULL) {
 		for (i = 0; i < map->tablelength; i++) {
-			HASH_MAP_ENTRY entry;
+			hash_map_entry_t entry;
 			for (entry = map->table[i]; entry != NULL; entry = entry->next) {
 				if (entry->value == NULL) {
 					return true;
@@ -315,7 +315,7 @@ bool hashMap_containsValue(HASH_MAP map,
 		return false;
 	}
 	for (i = 0; i < map->tablelength; i++) {
-		HASH_MAP_ENTRY entry;
+		hash_map_entry_t entry;
 		for (entry = map->table[i]; entry != NULL; entry = entry->next) {
 			if (entry->value == value || map->equalsValue(entry->value, value)) {
 				return true;
@@ -325,9 +325,9 @@ bool hashMap_containsValue(HASH_MAP map,
 	return false;
 }
 
-void hashMap_addEntry(HASH_MAP map, int hash, void * key, void * value, int bucketIndex) {
-	HASH_MAP_ENTRY entry = map->table[bucketIndex];
-	HASH_MAP_ENTRY new = (HASH_MAP_ENTRY) malloc(sizeof(*new));
+void hashMap_addEntry(hash_map_t map, int hash, void * key, void * value, int bucketIndex) {
+	hash_map_entry_t entry = map->table[bucketIndex];
+	hash_map_entry_t new = (hash_map_entry_t) malloc(sizeof(*new));
 	new->hash = hash;
 	new->key = key;
 	new->value = value;
@@ -338,8 +338,8 @@ void hashMap_addEntry(HASH_MAP map, int 
 	}
 }
 
-HASH_MAP_ITERATOR hashMapIterator_create(HASH_MAP map) {
-	HASH_MAP_ITERATOR iterator = (HASH_MAP_ITERATOR) malloc(sizeof(*iterator));
+hash_map_iterator_t hashMapIterator_create(hash_map_t map) {
+	hash_map_iterator_t iterator = (hash_map_iterator_t) malloc(sizeof(*iterator));
 	iterator->map = map;
 	iterator->expectedModCount = map->modificationCount;
 	iterator->index = 0;
@@ -352,7 +352,7 @@ HASH_MAP_ITERATOR hashMapIterator_create
 	return iterator;
 }
 
-void hashMapIterator_destroy(HASH_MAP_ITERATOR iterator) {
+void hashMapIterator_destroy(hash_map_iterator_t iterator) {
 	iterator->current = NULL;
 	iterator->expectedModCount = 0;
 	iterator->index = 0;
@@ -362,13 +362,13 @@ void hashMapIterator_destroy(HASH_MAP_IT
 	iterator = NULL;
 }
 
-bool hashMapIterator_hasNext(HASH_MAP_ITERATOR iterator) {
+bool hashMapIterator_hasNext(hash_map_iterator_t iterator) {
 	return iterator->next != NULL;
 }
 
-void hashMapIterator_remove(HASH_MAP_ITERATOR iterator) {
+void hashMapIterator_remove(hash_map_iterator_t iterator) {
 	void * key;
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	if (iterator->current == NULL) {
 		return;
 	}
@@ -382,8 +382,8 @@ void hashMapIterator_remove(HASH_MAP_ITE
 	iterator->expectedModCount = iterator->map->modificationCount;
 }
 
-void * hashMapIterator_nextValue(HASH_MAP_ITERATOR iterator) {
-	HASH_MAP_ENTRY entry;
+void * hashMapIterator_nextValue(hash_map_iterator_t iterator) {
+	hash_map_entry_t entry;
 	if (iterator->expectedModCount != iterator->map->modificationCount) {
 		return NULL;
 	}
@@ -399,8 +399,8 @@ void * hashMapIterator_nextValue(HASH_MA
 	return entry->value;
 }
 
-void * hashMapIterator_nextKey(HASH_MAP_ITERATOR iterator) {
-	HASH_MAP_ENTRY entry;
+void * hashMapIterator_nextKey(hash_map_iterator_t iterator) {
+	hash_map_entry_t entry;
 	if (iterator->expectedModCount != iterator->map->modificationCount) {
 		return NULL;
 	}
@@ -416,8 +416,8 @@ void * hashMapIterator_nextKey(HASH_MAP_
 	return entry->key;
 }
 
-HASH_MAP_ENTRY hashMapIterator_nextEntry(HASH_MAP_ITERATOR iterator) {
-	HASH_MAP_ENTRY entry;
+hash_map_entry_t hashMapIterator_nextEntry(hash_map_iterator_t iterator) {
+	hash_map_entry_t entry;
 	if (iterator->expectedModCount != iterator->map->modificationCount) {
 		return NULL;
 	}
@@ -433,63 +433,63 @@ HASH_MAP_ENTRY hashMapIterator_nextEntry
 	return entry;
 }
 
-HASH_MAP_KEY_SET hashMapKeySet_create(HASH_MAP map) {
-	HASH_MAP_KEY_SET keySet = (HASH_MAP_KEY_SET) malloc(sizeof(*keySet));
+hash_map_key_set_t hashMapKeySet_create(hash_map_t map) {
+	hash_map_key_set_t keySet = (hash_map_key_set_t) malloc(sizeof(*keySet));
 	keySet->map = map;
 
 	return keySet;
 }
 
-int hashMapKeySet_size(HASH_MAP_KEY_SET keySet) {
+int hashMapKeySet_size(hash_map_key_set_t keySet) {
 	return keySet->map->size;
 }
 
-bool hashMapKeySet_contains(HASH_MAP_KEY_SET keySet, void * key) {
+bool hashMapKeySet_contains(hash_map_key_set_t keySet, void * key) {
 	return hashMap_containsKey(keySet->map, key);
 }
 
-bool hashMapKeySet_remove(HASH_MAP_KEY_SET keySet, void * key) {
-	HASH_MAP_ENTRY entry = hashMap_removeEntryForKey(keySet->map, key);
+bool hashMapKeySet_remove(hash_map_key_set_t keySet, void * key) {
+	hash_map_entry_t entry = hashMap_removeEntryForKey(keySet->map, key);
 	bool removed = entry != NULL;
 	free(entry);
 	return removed;
 }
 
-void hashMapKeySet_clear(HASH_MAP_KEY_SET keySet) {
+void hashMapKeySet_clear(hash_map_key_set_t keySet) {
 	hashMap_clear(keySet->map, false, false);
 }
 
-bool hashMapKeySet_isEmpty(HASH_MAP_KEY_SET keySet) {
+bool hashMapKeySet_isEmpty(hash_map_key_set_t keySet) {
 	return hashMapKeySet_size(keySet) == 0;
 }
 
-HASH_MAP_VALUES hashMapValues_create(HASH_MAP map) {
-	HASH_MAP_VALUES values = (HASH_MAP_VALUES) malloc(sizeof(*values));
+hash_map_values_t hashMapValues_create(hash_map_t map) {
+	hash_map_values_t values = (hash_map_values_t) malloc(sizeof(*values));
 	values->map = map;
 
 	return values;
 }
 
-void hashMapValues_destroy(HASH_MAP_VALUES values) {
+void hashMapValues_destroy(hash_map_values_t values) {
 	values->map = NULL;
 	free(values);
 	values = NULL;
 }
 
-HASH_MAP_ITERATOR hashMapValues_iterator(HASH_MAP_VALUES values) {
+hash_map_iterator_t hashMapValues_iterator(hash_map_values_t values) {
 	return hashMapIterator_create(values->map);
 }
 
-int hashMapValues_size(HASH_MAP_VALUES values) {
+int hashMapValues_size(hash_map_values_t values) {
 	return values->map->size;
 }
 
-bool hashMapValues_contains(HASH_MAP_VALUES values, void * value) {
+bool hashMapValues_contains(hash_map_values_t values, void * value) {
 	return hashMap_containsValue(values->map, value);
 }
 
-void hashMapValues_toArray(HASH_MAP_VALUES values, void* *array[], unsigned int *size) {
-	HASH_MAP_ITERATOR it;
+void hashMapValues_toArray(hash_map_values_t values, void* *array[], unsigned int *size) {
+	hash_map_iterator_t it;
 	int i;
     int vsize = hashMapValues_size(values);
     *size = vsize;
@@ -505,8 +505,8 @@ void hashMapValues_toArray(HASH_MAP_VALU
     hashMapIterator_destroy(it);
 }
 
-bool hashMapValues_remove(HASH_MAP_VALUES values, void * value) {
-	HASH_MAP_ITERATOR iterator = hashMapValues_iterator(values);
+bool hashMapValues_remove(hash_map_values_t values, void * value) {
+	hash_map_iterator_t iterator = hashMapValues_iterator(values);
 	if (value == NULL) {
 		while (hashMapIterator_hasNext(iterator)) {
 			if (hashMapIterator_nextValue(iterator) == NULL) {
@@ -525,46 +525,46 @@ bool hashMapValues_remove(HASH_MAP_VALUE
 	return false;
 }
 
-void hashMapValues_clear(HASH_MAP_VALUES values) {
+void hashMapValues_clear(hash_map_values_t values) {
 	hashMap_clear(values->map, false, false);
 }
 
-bool hashMapValues_isEmpty(HASH_MAP_VALUES values) {
+bool hashMapValues_isEmpty(hash_map_values_t values) {
 	return hashMapValues_size(values) == 0;
 }
 
-HASH_MAP_ENTRY_SET hashMapEntrySet_create(HASH_MAP map) {
-	HASH_MAP_ENTRY_SET entrySet = (HASH_MAP_ENTRY_SET) malloc(sizeof(*entrySet));
+hash_map_entry_set_t hashMapEntrySet_create(hash_map_t map) {
+	hash_map_entry_set_t entrySet = (hash_map_entry_set_t) malloc(sizeof(*entrySet));
 	entrySet->map = map;
 
 	return entrySet;
 }
 
-int hashMapEntrySet_size(HASH_MAP_ENTRY_SET entrySet) {
+int hashMapEntrySet_size(hash_map_entry_set_t entrySet) {
 	return entrySet->map->size;
 }
 
-bool hashMapEntrySet_contains(HASH_MAP_ENTRY_SET entrySet, HASH_MAP_ENTRY entry) {
+bool hashMapEntrySet_contains(hash_map_entry_set_t entrySet, hash_map_entry_t entry) {
 	return hashMap_containsValue(entrySet->map, entry);
 }
 
-bool hashMapEntrySet_remove(HASH_MAP_VALUES entrySet, HASH_MAP_ENTRY entry) {
+bool hashMapEntrySet_remove(hash_map_values_t entrySet, hash_map_entry_t entry) {
 	return hashMap_removeMapping(entrySet->map, entry) != NULL;
 }
 
-void hashMapEntrySet_clear(HASH_MAP_ENTRY_SET entrySet) {
+void hashMapEntrySet_clear(hash_map_entry_set_t entrySet) {
 	hashMap_clear(entrySet->map, false, false);
 }
 
-bool hashMapEntrySet_isEmpty(HASH_MAP_ENTRY_SET entrySet) {
+bool hashMapEntrySet_isEmpty(hash_map_entry_set_t entrySet) {
 	return hashMapEntrySet_size(entrySet) == 0;
 }
 
-void * hashMapEntry_getKey(HASH_MAP_ENTRY entry) {
+void * hashMapEntry_getKey(hash_map_entry_t entry) {
 	return entry->key;
 }
 
-void * hashMapEntry_getValue(HASH_MAP_ENTRY entry) {
+void * hashMapEntry_getValue(hash_map_entry_t entry) {
 	return entry->value;
 }
 

Modified: incubator/celix/trunk/utils/private/src/linked_list_iterator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/linked_list_iterator.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/src/linked_list_iterator.c (original)
+++ incubator/celix/trunk/utils/private/src/linked_list_iterator.c Wed Dec  5 09:05:46 2012
@@ -30,19 +30,19 @@
 #include "linked_list_private.h"
 
 struct linkedListIterator {
-	LINKED_LIST_ENTRY lastReturned;
-	LINKED_LIST_ENTRY next;
+	linked_list_entry_t lastReturned;
+	linked_list_entry_t next;
 	int nextIndex;
-	LINKED_LIST list;
+	linked_list_t list;
 	int expectedModificationCount;
 };
 
-LINKED_LIST_ITERATOR linkedListIterator_create(LINKED_LIST list, unsigned int index) {
-	LINKED_LIST_ITERATOR iterator;
+linked_list_iterator_t linkedListIterator_create(linked_list_t list, unsigned int index) {
+	linked_list_iterator_t iterator;
 	if (index < 0 || index > list->size) {
 		return NULL;
 	}
-	iterator = (LINKED_LIST_ITERATOR) malloc(sizeof(*iterator));
+	iterator = (linked_list_iterator_t) malloc(sizeof(*iterator));
 	iterator->lastReturned = list->header;
 	iterator->list = list;
 	iterator->expectedModificationCount = list->modificationCount;
@@ -60,7 +60,7 @@ LINKED_LIST_ITERATOR linkedListIterator_
 	return iterator;
 }
 
-void linkedListIterator_destroy(LINKED_LIST_ITERATOR iterator) {
+void linkedListIterator_destroy(linked_list_iterator_t iterator) {
 	iterator->expectedModificationCount = 0;
 	iterator->lastReturned = NULL;
 	iterator->list = NULL;
@@ -69,11 +69,11 @@ void linkedListIterator_destroy(LINKED_L
 	free(iterator);
 }
 
-bool linkedListIterator_hasNext(LINKED_LIST_ITERATOR iterator) {
+bool linkedListIterator_hasNext(linked_list_iterator_t iterator) {
 	return iterator->nextIndex != iterator->list->size;
 }
 
-void * linkedListIterator_next(LINKED_LIST_ITERATOR iterator) {
+void * linkedListIterator_next(linked_list_iterator_t iterator) {
 	if (iterator->list->modificationCount != iterator->expectedModificationCount) {
 		return NULL;
 	}
@@ -86,11 +86,11 @@ void * linkedListIterator_next(LINKED_LI
 	return iterator->lastReturned->element;
 }
 
-bool linkedListIterator_hasPrevious(LINKED_LIST_ITERATOR iterator) {
+bool linkedListIterator_hasPrevious(linked_list_iterator_t iterator) {
 	return iterator->nextIndex != 0;
 }
 
-void * linkedListIterator_previous(LINKED_LIST_ITERATOR iterator) {
+void * linkedListIterator_previous(linked_list_iterator_t iterator) {
 	if (iterator->nextIndex == 0) {
 		return NULL;
 	}
@@ -105,16 +105,16 @@ void * linkedListIterator_previous(LINKE
 	return iterator->lastReturned->element;
 }
 
-int linkedListIterator_nextIndex(LINKED_LIST_ITERATOR iterator) {
+int linkedListIterator_nextIndex(linked_list_iterator_t iterator) {
 	return iterator->nextIndex;
 }
 
-int linkedListIterator_previousIndex(LINKED_LIST_ITERATOR iterator) {
+int linkedListIterator_previousIndex(linked_list_iterator_t iterator) {
 	return iterator->nextIndex-1;
 }
 
-void linkedListIterator_remove(LINKED_LIST_ITERATOR iterator) {
-	LINKED_LIST_ENTRY lastNext;
+void linkedListIterator_remove(linked_list_iterator_t iterator) {
+	linked_list_entry_t lastNext;
 	if (iterator->list->modificationCount != iterator->expectedModificationCount) {
 		return;
 	}
@@ -131,7 +131,7 @@ void linkedListIterator_remove(LINKED_LI
 	iterator->expectedModificationCount++;
 }
 
-void linkedListIterator_set(LINKED_LIST_ITERATOR iterator, void * element) {
+void linkedListIterator_set(linked_list_iterator_t iterator, void * element) {
 	if (iterator->lastReturned == iterator->list->header) {
 		return;
 	}
@@ -141,7 +141,7 @@ void linkedListIterator_set(LINKED_LIST_
 	iterator->lastReturned->element = element;
 }
 
-void linkedListIterator_add(LINKED_LIST_ITERATOR iterator, void * element) {
+void linkedListIterator_add(linked_list_iterator_t iterator, void * element) {
 	if (iterator->list->modificationCount != iterator->expectedModificationCount) {
 		return;
 	}

Modified: incubator/celix/trunk/utils/private/src/linkedlist.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/linkedlist.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/src/linkedlist.c (original)
+++ incubator/celix/trunk/utils/private/src/linkedlist.c Wed Dec  5 09:05:46 2012
@@ -30,10 +30,10 @@
 #include "linkedlist.h"
 #include "linked_list_private.h"
 
-celix_status_t linkedList_create(apr_pool_t *pool, LINKED_LIST *list) {
-	LINKED_LIST linked_list = (LINKED_LIST) apr_pcalloc(pool, sizeof(*linked_list));
+celix_status_t linkedList_create(apr_pool_t *pool, linked_list_t *list) {
+	linked_list_t linked_list = (linked_list_t) apr_pcalloc(pool, sizeof(*linked_list));
 	if (linked_list) {
-        linked_list->header = (LINKED_LIST_ENTRY) apr_pcalloc(pool, sizeof(*(linked_list->header)));
+        linked_list->header = (linked_list_entry_t) apr_pcalloc(pool, sizeof(*(linked_list->header)));
         if (linked_list->header) {
             linked_list->header->element = NULL;
             linked_list->header->next = linked_list->header;
@@ -51,7 +51,7 @@ celix_status_t linkedList_create(apr_poo
 	return CELIX_ENOMEM;
 }
 
-celix_status_t linkedList_clone(LINKED_LIST list, apr_pool_t *pool, LINKED_LIST *clone) {
+celix_status_t linkedList_clone(linked_list_t list, apr_pool_t *pool, linked_list_t *clone) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = linkedList_create(pool, clone);
@@ -65,56 +65,56 @@ celix_status_t linkedList_clone(LINKED_L
 	return status;
 }
 
-void * linkedList_getFirst(LINKED_LIST list) {
+void * linkedList_getFirst(linked_list_t list) {
 	if (list->size == 0) {
 		return NULL;
 	}
 	return list->header->next->element;
 }
 
-void * linkedList_getLast(LINKED_LIST list) {
+void * linkedList_getLast(linked_list_t list) {
 	if (list->size == 0) {
 		return NULL;
 	}
 	return list->header->previous->element;
 }
 
-void * linkedList_removeFirst(LINKED_LIST list) {
+void * linkedList_removeFirst(linked_list_t list) {
 	return linkedList_removeEntry(list, list->header->next);
 }
 
-void * linkedList_removeLast(LINKED_LIST list) {
+void * linkedList_removeLast(linked_list_t list) {
 	return linkedList_removeEntry(list, list->header->previous);
 }
 
-void linkedList_addFirst(LINKED_LIST list, void * element) {
+void linkedList_addFirst(linked_list_t list, void * element) {
 	linkedList_addBefore(list, element, list->header->next);
 }
 
-void linkedList_addLast(LINKED_LIST list, void * element) {
+void linkedList_addLast(linked_list_t list, void * element) {
 	linkedList_addBefore(list, element, list->header);
 }
 
-bool linkedList_contains(LINKED_LIST list, void * element) {
+bool linkedList_contains(linked_list_t list, void * element) {
 	return linkedList_indexOf(list, element) != 0;
 }
 
-int linkedList_size(LINKED_LIST list) {
+int linkedList_size(linked_list_t list) {
 	return list->size;
 }
 
-bool linkedList_isEmpty(LINKED_LIST list) {
+bool linkedList_isEmpty(linked_list_t list) {
 	return linkedList_size(list) == 0;
 }
 
-bool linkedList_addElement(LINKED_LIST list, void * element) {
+bool linkedList_addElement(linked_list_t list, void * element) {
 	linkedList_addBefore(list, element, list->header);
 	return true;
 }
 
-bool linkedList_removeElement(LINKED_LIST list, void * element) {
+bool linkedList_removeElement(linked_list_t list, void * element) {
 	if (element == NULL) {
-		LINKED_LIST_ENTRY entry;
+		linked_list_entry_t entry;
 		for (entry = list->header->next; entry != list->header; entry = entry->next) {
 			if (entry->element == NULL) {
 				linkedList_removeEntry(list, entry);
@@ -122,7 +122,7 @@ bool linkedList_removeElement(LINKED_LIS
 			}
 		}
 	} else {
-		LINKED_LIST_ENTRY entry;
+		linked_list_entry_t entry;
 		for (entry = list->header->next; entry != list->header; entry = entry->next) {
 			if (element == entry->element) {
 				linkedList_removeEntry(list, entry);
@@ -133,10 +133,10 @@ bool linkedList_removeElement(LINKED_LIS
 	return false;
 }
 
-void linkedList_clear(LINKED_LIST list) {
-	LINKED_LIST_ENTRY entry = list->header->next;
+void linkedList_clear(linked_list_t list) {
+	linked_list_entry_t entry = list->header->next;
 	while (entry != list->header) {
-		LINKED_LIST_ENTRY next = entry->next;
+		linked_list_entry_t next = entry->next;
 		entry->next = entry->previous = NULL;
 		// free(entry->element);
 		entry->element = NULL;
@@ -148,26 +148,26 @@ void linkedList_clear(LINKED_LIST list) 
 	list->modificationCount++;
 }
 
-void * linkedList_get(LINKED_LIST list, int index) {
+void * linkedList_get(linked_list_t list, int index) {
 	return linkedList_entry(list, index)->element;
 }
-void * linkedList_set(LINKED_LIST list, int index, void * element) {
-	LINKED_LIST_ENTRY entry = linkedList_entry(list, index);
+void * linkedList_set(linked_list_t list, int index, void * element) {
+	linked_list_entry_t entry = linkedList_entry(list, index);
 	void * old = entry->element;
 	entry->element = element;
 	return old;
 }
 
-void linkedList_addIndex(LINKED_LIST list, int index, void * element) {
+void linkedList_addIndex(linked_list_t list, int index, void * element) {
 	linkedList_addBefore(list, element, (index == list->size ? list->header : linkedList_entry(list, index)));
 }
 
-void * linkedList_removeIndex(LINKED_LIST list, int index) {
+void * linkedList_removeIndex(linked_list_t list, int index) {
 	return linkedList_removeEntry(list, linkedList_entry(list, index));
 }
 
-LINKED_LIST_ENTRY linkedList_entry(LINKED_LIST list, int index) {
-	LINKED_LIST_ENTRY entry;
+linked_list_entry_t linkedList_entry(linked_list_t list, int index) {
+	linked_list_entry_t entry;
 	int i;
 	if (index < 0 || index >= list->size) {
 		return NULL;
@@ -186,10 +186,10 @@ LINKED_LIST_ENTRY linkedList_entry(LINKE
 	return entry;
 }
 
-int linkedList_indexOf(LINKED_LIST list, void * element) {
+int linkedList_indexOf(linked_list_t list, void * element) {
 	int index = 0;
 	if (element == NULL) {
-		LINKED_LIST_ENTRY entry;
+		linked_list_entry_t entry;
 		for (entry = list->header->next; entry != list->header; entry = entry->next) {
 			if (entry->element == NULL) {
 				return index;
@@ -197,7 +197,7 @@ int linkedList_indexOf(LINKED_LIST list,
 			index++;
 		}
 	} else {
-		LINKED_LIST_ENTRY entry;
+		linked_list_entry_t entry;
 		for (entry = list->header->next; entry != list->header; entry = entry->next) {
 			if (element == entry->element) {
 				return index;
@@ -208,12 +208,12 @@ int linkedList_indexOf(LINKED_LIST list,
 	return -1;
 }
 
-LINKED_LIST_ENTRY linkedList_addBefore(LINKED_LIST list, void * element, LINKED_LIST_ENTRY entry) {
-    LINKED_LIST_ENTRY new = NULL;
+linked_list_entry_t linkedList_addBefore(linked_list_t list, void * element, linked_list_entry_t entry) {
+    linked_list_entry_t new = NULL;
     apr_pool_t *sub_pool = NULL;
 
     if (apr_pool_create(&sub_pool, list->memory_pool) == APR_SUCCESS) {
-        new = (LINKED_LIST_ENTRY) apr_palloc(sub_pool, sizeof(*new));
+        new = (linked_list_entry_t) apr_palloc(sub_pool, sizeof(*new));
         new->memory_pool = sub_pool;
         new->element = element;
         new->next = entry;
@@ -229,7 +229,7 @@ LINKED_LIST_ENTRY linkedList_addBefore(L
 	return new;
 }
 
-void * linkedList_removeEntry(LINKED_LIST list, LINKED_LIST_ENTRY entry) {
+void * linkedList_removeEntry(linked_list_t list, linked_list_entry_t entry) {
     void * result;
 	if (entry == list->header) {
 		return NULL;

Modified: incubator/celix/trunk/utils/private/test/array_list_test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/test/array_list_test.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/test/array_list_test.c (original)
+++ incubator/celix/trunk/utils/private/test/array_list_test.c Wed Dec  5 09:05:46 2012
@@ -35,7 +35,7 @@
 #include "array_list_private.h"
 
 apr_pool_t *memory_pool;
-ARRAY_LIST list;
+array_list_t list;
 
 int setup(void) {
 	apr_initialize();
@@ -222,12 +222,12 @@ void test_arrayList_addAll(void) {
     char * entry2 = "entry2";
     char * entry3 = "entry3"; 
     char * get;
-	ARRAY_LIST toAdd;
+	array_list_t toAdd;
 	bool changed;
 	
 	arrayList_clear(list);
 
-	arrayList_create(memory_pool, &list);
+	arrayList_create(memory_pool, &toAdd);
     arrayList_add(toAdd, entry);
     arrayList_add(toAdd, entry2);
 

Modified: incubator/celix/trunk/utils/private/test/hash_map_test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/test/hash_map_test.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/test/hash_map_test.c (original)
+++ incubator/celix/trunk/utils/private/test/hash_map_test.c Wed Dec  5 09:05:46 2012
@@ -32,7 +32,7 @@
 #include "hash_map.h"
 #include "hash_map_private.h"
 
-HASH_MAP map;
+hash_map_t map;
 
 int setup(void) {
 	printf("test\n");
@@ -172,7 +172,7 @@ void test_hashMap_getEntry(void) {
 	char * neKey = "notExisting";
 	char * key3 = NULL;
 	char * value3 = "value3";
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	
 	hashMap_clear(map, false, false);
 
@@ -322,9 +322,9 @@ void test_hashMap_removeMapping(void) {
 	char * value = "value";
 	char * key2 = NULL;
 	char * value2 = "value2";
-	HASH_MAP_ENTRY entry1;
-	HASH_MAP_ENTRY entry2;
-	HASH_MAP_ENTRY removed;
+	hash_map_entry_t entry1;
+	hash_map_entry_t entry2;
+	hash_map_entry_t removed;
 
 	hashMap_clear(map, false, false);
 
@@ -416,7 +416,7 @@ void test_hashMapValues_toArray(void) {
     char * value2 = "value2";
     char **array;
     int size;
-	HASH_MAP_VALUES values;
+	hash_map_values_t values;
 
 	hashMap_clear(map, false, false);
 

Modified: incubator/celix/trunk/utils/private/test/hash_map_test_hash.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/test/hash_map_test_hash.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/test/hash_map_test_hash.c (original)
+++ incubator/celix/trunk/utils/private/test/hash_map_test_hash.c Wed Dec  5 09:05:46 2012
@@ -32,7 +32,7 @@
 #include "hash_map.h"
 #include "hash_map_private.h"
 
-HASH_MAP map;
+hash_map_t map;
 
 unsigned int test_hashKeyChar(void * k) {
 	char * str = (char *) k;
@@ -155,7 +155,7 @@ void test_hashMap_getEntry(void) {
 	char * getEntryKey;
 	char * key3 = NULL;
 	char * value3 = "value3";	
-	HASH_MAP_ENTRY entry;
+	hash_map_entry_t entry;
 	
 	hashMap_clear(map, false, false);
 

Modified: incubator/celix/trunk/utils/private/test/linked_list_test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/test/linked_list_test.c?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/test/linked_list_test.c (original)
+++ incubator/celix/trunk/utils/private/test/linked_list_test.c Wed Dec  5 09:05:46 2012
@@ -31,7 +31,7 @@
 #include "linkedlist.h"
 
 apr_pool_t *memory_pool;
-LINKED_LIST list;
+linked_list_t list;
 
 int setup(void) {
     apr_initialize();

Modified: incubator/celix/trunk/utils/public/include/array_list.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/public/include/array_list.h?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/public/include/array_list.h (original)
+++ incubator/celix/trunk/utils/public/include/array_list.h Wed Dec  5 09:05:46 2012
@@ -33,35 +33,39 @@
 #include "exports.h"
 #include "celix_errno.h"
 
-typedef struct arrayList * ARRAY_LIST;
+typedef struct arrayList * array_list_t;
 
-typedef struct arrayListIterator * ARRAY_LIST_ITERATOR;
+typedef struct arrayListIterator * array_list_iterator_t;
 
-UTILS_EXPORT celix_status_t arrayList_create(apr_pool_t *pool, ARRAY_LIST *list);
-UTILS_EXPORT void arrayList_destroy(ARRAY_LIST list);
-UTILS_EXPORT void arrayList_trimToSize(ARRAY_LIST list);
-UTILS_EXPORT void arrayList_ensureCapacity(ARRAY_LIST list, int capacity);
-UTILS_EXPORT unsigned int arrayList_size(ARRAY_LIST list);
-UTILS_EXPORT bool arrayList_isEmpty(ARRAY_LIST list);
-UTILS_EXPORT bool arrayList_contains(ARRAY_LIST list, void * element);
-UTILS_EXPORT int arrayList_indexOf(ARRAY_LIST list, void * element);
-UTILS_EXPORT int arrayList_lastIndexOf(ARRAY_LIST list, void * element);
-UTILS_EXPORT void * arrayList_get(ARRAY_LIST list, unsigned int index);
-UTILS_EXPORT void * arrayList_set(ARRAY_LIST list, unsigned int index, void * element);
-UTILS_EXPORT bool arrayList_add(ARRAY_LIST list, void * element);
-UTILS_EXPORT int arrayList_addIndex(ARRAY_LIST list, unsigned int index, void * element);
-UTILS_EXPORT bool arrayList_addAll(ARRAY_LIST list, ARRAY_LIST toAdd);
-UTILS_EXPORT void * arrayList_remove(ARRAY_LIST list, unsigned int index);
-UTILS_EXPORT bool arrayList_removeElement(ARRAY_LIST list, void * element);
-UTILS_EXPORT void arrayList_clear(ARRAY_LIST list);
-UTILS_EXPORT ARRAY_LIST arrayList_clone(apr_pool_t *pool, ARRAY_LIST list);
-
-UTILS_EXPORT ARRAY_LIST_ITERATOR arrayListIterator_create(ARRAY_LIST list);
-UTILS_EXPORT void arrayListIterator_destroy(ARRAY_LIST_ITERATOR iterator);
-UTILS_EXPORT bool arrayListIterator_hasNext(ARRAY_LIST_ITERATOR iterator);
-UTILS_EXPORT void * arrayListIterator_next(ARRAY_LIST_ITERATOR iterator);
-UTILS_EXPORT bool arrayListIterator_hasPrevious(ARRAY_LIST_ITERATOR iterator);
-UTILS_EXPORT void * arrayListIterator_previous(ARRAY_LIST_ITERATOR iterator);
-UTILS_EXPORT void arrayListIterator_remove(ARRAY_LIST_ITERATOR iterator);
+typedef celix_status_t (*arrayListElementEqualsFunction)(void *, void *, bool *equals);
+
+UTILS_EXPORT celix_status_t arrayList_create(apr_pool_t *pool, array_list_t *list);
+UTILS_EXPORT celix_status_t arrayList_createWithEquals(apr_pool_t *pool, arrayListElementEqualsFunction equals, array_list_t *list);
+
+UTILS_EXPORT void arrayList_destroy(array_list_t list);
+UTILS_EXPORT void arrayList_trimToSize(array_list_t list);
+UTILS_EXPORT void arrayList_ensureCapacity(array_list_t list, int capacity);
+UTILS_EXPORT unsigned int arrayList_size(array_list_t list);
+UTILS_EXPORT bool arrayList_isEmpty(array_list_t list);
+UTILS_EXPORT bool arrayList_contains(array_list_t list, void * element);
+UTILS_EXPORT int arrayList_indexOf(array_list_t list, void * element);
+UTILS_EXPORT int arrayList_lastIndexOf(array_list_t list, void * element);
+UTILS_EXPORT void * arrayList_get(array_list_t list, unsigned int index);
+UTILS_EXPORT void * arrayList_set(array_list_t list, unsigned int index, void * element);
+UTILS_EXPORT bool arrayList_add(array_list_t list, void * element);
+UTILS_EXPORT int arrayList_addIndex(array_list_t list, unsigned int index, void * element);
+UTILS_EXPORT bool arrayList_addAll(array_list_t list, array_list_t toAdd);
+UTILS_EXPORT void * arrayList_remove(array_list_t list, unsigned int index);
+UTILS_EXPORT bool arrayList_removeElement(array_list_t list, void * element);
+UTILS_EXPORT void arrayList_clear(array_list_t list);
+UTILS_EXPORT array_list_t arrayList_clone(apr_pool_t *pool, array_list_t list);
+
+UTILS_EXPORT array_list_iterator_t arrayListIterator_create(array_list_t list);
+UTILS_EXPORT void arrayListIterator_destroy(array_list_iterator_t iterator);
+UTILS_EXPORT bool arrayListIterator_hasNext(array_list_iterator_t iterator);
+UTILS_EXPORT void * arrayListIterator_next(array_list_iterator_t iterator);
+UTILS_EXPORT bool arrayListIterator_hasPrevious(array_list_iterator_t iterator);
+UTILS_EXPORT void * arrayListIterator_previous(array_list_iterator_t iterator);
+UTILS_EXPORT void arrayListIterator_remove(array_list_iterator_t iterator);
 
 #endif /* ARRAY_LIST_H_ */

Modified: incubator/celix/trunk/utils/public/include/hash_map.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/public/include/hash_map.h?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/public/include/hash_map.h (original)
+++ incubator/celix/trunk/utils/public/include/hash_map.h Wed Dec  5 09:05:46 2012
@@ -30,61 +30,61 @@
 #include "celixbool.h"
 #include "exports.h"
 
-typedef struct hashMapEntry * HASH_MAP_ENTRY;
-typedef struct hashMap * HASH_MAP;
+typedef struct hashMapEntry * hash_map_entry_t;
+typedef struct hashMap * hash_map_t;
 
-typedef struct hashMapIterator * HASH_MAP_ITERATOR;
+typedef struct hashMapIterator * hash_map_iterator_t;
 
-typedef struct hashMapKeySet * HASH_MAP_KEY_SET;
-typedef struct hashMapValues * HASH_MAP_VALUES;
-typedef struct hashMapEntrySet * HASH_MAP_ENTRY_SET;
+typedef struct hashMapKeySet * hash_map_key_set_t;
+typedef struct hashMapValues * hash_map_values_t;
+typedef struct hashMapEntrySet * hash_map_entry_set_t;
 
-UTILS_EXPORT HASH_MAP hashMap_create(unsigned int (*keyHash)(void *), unsigned int (*valueHash)(void *),
+UTILS_EXPORT hash_map_t hashMap_create(unsigned int (*keyHash)(void *), unsigned int (*valueHash)(void *),
 		int (*keyEquals)(void *, void *), int (*valueEquals)(void *, void *));
-UTILS_EXPORT void hashMap_destroy(HASH_MAP map, bool freeKeys, bool freeValues);
-UTILS_EXPORT int hashMap_size(HASH_MAP map);
-UTILS_EXPORT bool hashMap_isEmpty(HASH_MAP map);
-UTILS_EXPORT void * hashMap_get(HASH_MAP map, void * key);
-UTILS_EXPORT bool hashMap_containsKey(HASH_MAP map, void * key);
-UTILS_EXPORT HASH_MAP_ENTRY hashMap_getEntry(HASH_MAP map, void * key);
-UTILS_EXPORT void * hashMap_put(HASH_MAP map, void * key, void * value);
-UTILS_EXPORT void * hashMap_remove(HASH_MAP map, void * key);
-UTILS_EXPORT void hashMap_clear(HASH_MAP map, bool freeKey, bool freeValue);
-UTILS_EXPORT bool hashMap_containsValue(HASH_MAP map, void * value);
-
-UTILS_EXPORT HASH_MAP_ITERATOR hashMapIterator_create(HASH_MAP map);
-UTILS_EXPORT void hashMapIterator_destroy(HASH_MAP_ITERATOR iterator);
-UTILS_EXPORT bool hashMapIterator_hasNext(HASH_MAP_ITERATOR iterator);
-UTILS_EXPORT void hashMapIterator_remove(HASH_MAP_ITERATOR iterator);
-UTILS_EXPORT void * hashMapIterator_nextValue(HASH_MAP_ITERATOR iterator);
-UTILS_EXPORT void * hashMapIterator_nextKey(HASH_MAP_ITERATOR iterator);
-UTILS_EXPORT HASH_MAP_ENTRY hashMapIterator_nextEntry(HASH_MAP_ITERATOR iterator);
-
-UTILS_EXPORT HASH_MAP_KEY_SET hashMapKeySet_create(HASH_MAP map);
-UTILS_EXPORT int hashMapKeySet_size(HASH_MAP_KEY_SET keySet);
-UTILS_EXPORT bool hashMapKeySet_contains(HASH_MAP_KEY_SET keySet, void * key);
-UTILS_EXPORT bool hashMapKeySet_remove(HASH_MAP_KEY_SET keySet, void * key);
-UTILS_EXPORT void hashMapKeySet_clear(HASH_MAP_KEY_SET keySet);
-UTILS_EXPORT bool hashMapKeySet_isEmpty(HASH_MAP_KEY_SET keySet);
-
-UTILS_EXPORT HASH_MAP_VALUES hashMapValues_create(HASH_MAP map);
-UTILS_EXPORT void hashMapValues_destroy(HASH_MAP_VALUES values);
-UTILS_EXPORT HASH_MAP_ITERATOR hashMapValues_iterator(HASH_MAP_VALUES values);
-UTILS_EXPORT int hashMapValues_size(HASH_MAP_VALUES values);
-UTILS_EXPORT bool hashMapValues_contains(HASH_MAP_VALUES values, void * o);
-UTILS_EXPORT void hashMapValues_toArray(HASH_MAP_VALUES values, void* *array[], unsigned int *size);
-UTILS_EXPORT bool hashMapValues_remove(HASH_MAP_VALUES values, void * o);
-UTILS_EXPORT void hashMapValues_clear(HASH_MAP_VALUES values);
-UTILS_EXPORT bool hashMapValues_isEmpty(HASH_MAP_VALUES values);
-
-UTILS_EXPORT HASH_MAP_ENTRY_SET hashMapEntrySet_create(HASH_MAP map);
-UTILS_EXPORT int hashMapEntrySet_size(HASH_MAP_ENTRY_SET entrySet);
-UTILS_EXPORT bool hashMapEntrySet_contains(HASH_MAP_ENTRY_SET entrySet, HASH_MAP_ENTRY entry);
-UTILS_EXPORT bool hashMapEntrySet_remove(HASH_MAP_VALUES entrySet, HASH_MAP_ENTRY entry);
-UTILS_EXPORT void hashMapEntrySet_clear(HASH_MAP_ENTRY_SET entrySet);
-UTILS_EXPORT bool hashMapEntrySet_isEmpty(HASH_MAP_ENTRY_SET entrySet);
+UTILS_EXPORT void hashMap_destroy(hash_map_t map, bool freeKeys, bool freeValues);
+UTILS_EXPORT int hashMap_size(hash_map_t map);
+UTILS_EXPORT bool hashMap_isEmpty(hash_map_t map);
+UTILS_EXPORT void * hashMap_get(hash_map_t map, void * key);
+UTILS_EXPORT bool hashMap_containsKey(hash_map_t map, void * key);
+UTILS_EXPORT hash_map_entry_t hashMap_getEntry(hash_map_t map, void * key);
+UTILS_EXPORT void * hashMap_put(hash_map_t map, void * key, void * value);
+UTILS_EXPORT void * hashMap_remove(hash_map_t map, void * key);
+UTILS_EXPORT void hashMap_clear(hash_map_t map, bool freeKey, bool freeValue);
+UTILS_EXPORT bool hashMap_containsValue(hash_map_t map, void * value);
+
+UTILS_EXPORT hash_map_iterator_t hashMapIterator_create(hash_map_t map);
+UTILS_EXPORT void hashMapIterator_destroy(hash_map_iterator_t iterator);
+UTILS_EXPORT bool hashMapIterator_hasNext(hash_map_iterator_t iterator);
+UTILS_EXPORT void hashMapIterator_remove(hash_map_iterator_t iterator);
+UTILS_EXPORT void * hashMapIterator_nextValue(hash_map_iterator_t iterator);
+UTILS_EXPORT void * hashMapIterator_nextKey(hash_map_iterator_t iterator);
+UTILS_EXPORT hash_map_entry_t hashMapIterator_nextEntry(hash_map_iterator_t iterator);
+
+UTILS_EXPORT hash_map_key_set_t hashMapKeySet_create(hash_map_t map);
+UTILS_EXPORT int hashMapKeySet_size(hash_map_key_set_t keySet);
+UTILS_EXPORT bool hashMapKeySet_contains(hash_map_key_set_t keySet, void * key);
+UTILS_EXPORT bool hashMapKeySet_remove(hash_map_key_set_t keySet, void * key);
+UTILS_EXPORT void hashMapKeySet_clear(hash_map_key_set_t keySet);
+UTILS_EXPORT bool hashMapKeySet_isEmpty(hash_map_key_set_t keySet);
+
+UTILS_EXPORT hash_map_values_t hashMapValues_create(hash_map_t map);
+UTILS_EXPORT void hashMapValues_destroy(hash_map_values_t values);
+UTILS_EXPORT hash_map_iterator_t hashMapValues_iterator(hash_map_values_t values);
+UTILS_EXPORT int hashMapValues_size(hash_map_values_t values);
+UTILS_EXPORT bool hashMapValues_contains(hash_map_values_t values, void * o);
+UTILS_EXPORT void hashMapValues_toArray(hash_map_values_t values, void* *array[], unsigned int *size);
+UTILS_EXPORT bool hashMapValues_remove(hash_map_values_t values, void * o);
+UTILS_EXPORT void hashMapValues_clear(hash_map_values_t values);
+UTILS_EXPORT bool hashMapValues_isEmpty(hash_map_values_t values);
+
+UTILS_EXPORT hash_map_entry_set_t hashMapEntrySet_create(hash_map_t map);
+UTILS_EXPORT int hashMapEntrySet_size(hash_map_entry_set_t entrySet);
+UTILS_EXPORT bool hashMapEntrySet_contains(hash_map_entry_set_t entrySet, hash_map_entry_t entry);
+UTILS_EXPORT bool hashMapEntrySet_remove(hash_map_values_t entrySet, hash_map_entry_t entry);
+UTILS_EXPORT void hashMapEntrySet_clear(hash_map_entry_set_t entrySet);
+UTILS_EXPORT bool hashMapEntrySet_isEmpty(hash_map_entry_set_t entrySet);
 
-UTILS_EXPORT void * hashMapEntry_getKey(HASH_MAP_ENTRY entry);
-UTILS_EXPORT void * hashMapEntry_getValue(HASH_MAP_ENTRY entry);
+UTILS_EXPORT void * hashMapEntry_getKey(hash_map_entry_t entry);
+UTILS_EXPORT void * hashMapEntry_getValue(hash_map_entry_t entry);
 
 #endif /* HASH_MAP_H_ */

Modified: incubator/celix/trunk/utils/public/include/linked_list_iterator.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/public/include/linked_list_iterator.h?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/public/include/linked_list_iterator.h (original)
+++ incubator/celix/trunk/utils/public/include/linked_list_iterator.h Wed Dec  5 09:05:46 2012
@@ -32,19 +32,19 @@
 #include "linkedlist.h"
 #include "exports.h"
 
-typedef struct linkedListIterator * LINKED_LIST_ITERATOR;
+typedef struct linkedListIterator * linked_list_iterator_t;
 
-UTILS_EXPORT LINKED_LIST_ITERATOR linkedListIterator_create(LINKED_LIST list, unsigned int index);
-UTILS_EXPORT void linkedListIterator_destroy(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT bool linkedListIterator_hasNext(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT void * linkedListIterator_next(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT bool linkedListIterator_hasPrevious(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT void * linkedListIterator_previous(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT int linkedListIterator_nextIndex(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT int linkedListIterator_previousIndex(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT void linkedListIterator_remove(LINKED_LIST_ITERATOR iterator);
-UTILS_EXPORT void linkedListIterator_set(LINKED_LIST_ITERATOR iterator, void * element);
-UTILS_EXPORT void linkedListIterator_add(LINKED_LIST_ITERATOR iterator, void * element);
+UTILS_EXPORT linked_list_iterator_t linkedListIterator_create(linked_list_t list, unsigned int index);
+UTILS_EXPORT void linkedListIterator_destroy(linked_list_iterator_t iterator);
+UTILS_EXPORT bool linkedListIterator_hasNext(linked_list_iterator_t iterator);
+UTILS_EXPORT void * linkedListIterator_next(linked_list_iterator_t iterator);
+UTILS_EXPORT bool linkedListIterator_hasPrevious(linked_list_iterator_t iterator);
+UTILS_EXPORT void * linkedListIterator_previous(linked_list_iterator_t iterator);
+UTILS_EXPORT int linkedListIterator_nextIndex(linked_list_iterator_t iterator);
+UTILS_EXPORT int linkedListIterator_previousIndex(linked_list_iterator_t iterator);
+UTILS_EXPORT void linkedListIterator_remove(linked_list_iterator_t iterator);
+UTILS_EXPORT void linkedListIterator_set(linked_list_iterator_t iterator, void * element);
+UTILS_EXPORT void linkedListIterator_add(linked_list_iterator_t iterator, void * element);
 
 
 #endif /* LINKED_LIST_ITERATOR_H_ */

Modified: incubator/celix/trunk/utils/public/include/linkedlist.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/public/include/linkedlist.h?rev=1417320&r1=1417319&r2=1417320&view=diff
==============================================================================
--- incubator/celix/trunk/utils/public/include/linkedlist.h (original)
+++ incubator/celix/trunk/utils/public/include/linkedlist.h Wed Dec  5 09:05:46 2012
@@ -33,31 +33,31 @@
 #include "celix_errno.h"
 #include "exports.h"
 
-typedef struct linkedListEntry * LINKED_LIST_ENTRY;
-typedef struct linkedList * LINKED_LIST;
+typedef struct linkedListEntry * linked_list_entry_t;
+typedef struct linkedList * linked_list_t;
 
-UTILS_EXPORT celix_status_t linkedList_create(apr_pool_t *pool, LINKED_LIST *list);
-UTILS_EXPORT celix_status_t linkedList_clone(LINKED_LIST list, apr_pool_t *pool, LINKED_LIST *clone);
-UTILS_EXPORT void * linkedList_getFirst(LINKED_LIST list);
-UTILS_EXPORT void * linkedList_getLast(LINKED_LIST list);
-UTILS_EXPORT void * linkedList_removeFirst(LINKED_LIST list);
-UTILS_EXPORT void * linkedList_removeLast(LINKED_LIST list);
-UTILS_EXPORT void linkedList_addFirst(LINKED_LIST list, void * element);
-UTILS_EXPORT void linkedList_addLast(LINKED_LIST list, void * element);
-UTILS_EXPORT bool linkedList_contains(LINKED_LIST list, void * element);
-UTILS_EXPORT int linkedList_size(LINKED_LIST list);
-UTILS_EXPORT bool linkedList_isEmpty(LINKED_LIST list);
-UTILS_EXPORT bool linkedList_addElement(LINKED_LIST list, void * element);
-UTILS_EXPORT bool linkedList_removeElement(LINKED_LIST list, void * element);
-UTILS_EXPORT void linkedList_clear(LINKED_LIST list);
-UTILS_EXPORT void * linkedList_get(LINKED_LIST list, int index);
-UTILS_EXPORT void * linkedList_set(LINKED_LIST list, int index, void * element);
-UTILS_EXPORT void linkedList_addIndex(LINKED_LIST list, int index, void * element);
-UTILS_EXPORT void * linkedList_removeIndex(LINKED_LIST list, int index);
-UTILS_EXPORT LINKED_LIST_ENTRY linkedList_entry(LINKED_LIST list, int index);
-UTILS_EXPORT int linkedList_indexOf(LINKED_LIST list, void * element);
-UTILS_EXPORT LINKED_LIST_ENTRY linkedList_addBefore(LINKED_LIST list, void * element, LINKED_LIST_ENTRY entry);
-UTILS_EXPORT void * linkedList_removeEntry(LINKED_LIST list, LINKED_LIST_ENTRY entry);
+UTILS_EXPORT celix_status_t linkedList_create(apr_pool_t *pool, linked_list_t *list);
+UTILS_EXPORT celix_status_t linkedList_clone(linked_list_t list, apr_pool_t *pool, linked_list_t *clone);
+UTILS_EXPORT void * linkedList_getFirst(linked_list_t list);
+UTILS_EXPORT void * linkedList_getLast(linked_list_t list);
+UTILS_EXPORT void * linkedList_removeFirst(linked_list_t list);
+UTILS_EXPORT void * linkedList_removeLast(linked_list_t list);
+UTILS_EXPORT void linkedList_addFirst(linked_list_t list, void * element);
+UTILS_EXPORT void linkedList_addLast(linked_list_t list, void * element);
+UTILS_EXPORT bool linkedList_contains(linked_list_t list, void * element);
+UTILS_EXPORT int linkedList_size(linked_list_t list);
+UTILS_EXPORT bool linkedList_isEmpty(linked_list_t list);
+UTILS_EXPORT bool linkedList_addElement(linked_list_t list, void * element);
+UTILS_EXPORT bool linkedList_removeElement(linked_list_t list, void * element);
+UTILS_EXPORT void linkedList_clear(linked_list_t list);
+UTILS_EXPORT void * linkedList_get(linked_list_t list, int index);
+UTILS_EXPORT void * linkedList_set(linked_list_t list, int index, void * element);
+UTILS_EXPORT void linkedList_addIndex(linked_list_t list, int index, void * element);
+UTILS_EXPORT void * linkedList_removeIndex(linked_list_t list, int index);
+UTILS_EXPORT linked_list_entry_t linkedList_entry(linked_list_t list, int index);
+UTILS_EXPORT int linkedList_indexOf(linked_list_t list, void * element);
+UTILS_EXPORT linked_list_entry_t linkedList_addBefore(linked_list_t list, void * element, linked_list_entry_t entry);
+UTILS_EXPORT void * linkedList_removeEntry(linked_list_t list, linked_list_entry_t entry);
 
 
 #endif /* LINKEDLIST_H_ */



Mime
View raw message