You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by ab...@apache.org on 2012/12/05 10:06:34 UTC
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...
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_ */