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_ */
