Modified: incubator/celix/trunk/utils/private/src/linkedlist.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/linkedlist.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/private/src/linkedlist.c (original) +++ incubator/celix/trunk/utils/private/src/linkedlist.c Wed Jun 12 19:08:50 2013 @@ -30,10 +30,10 @@ #include "linkedlist.h" #include "linked_list_private.h" -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)); +celix_status_t linkedList_create(apr_pool_t *pool, linked_list_pt *list) { + linked_list_pt linked_list = (linked_list_pt) apr_pcalloc(pool, sizeof(*linked_list)); if (linked_list) { - linked_list->header = (linked_list_entry_t) apr_pcalloc(pool, sizeof(*(linked_list->header))); + linked_list->header = (linked_list_entry_pt) 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_t list, apr_pool_t *pool, linked_list_t *clone) { +celix_status_t linkedList_clone(linked_list_pt list, apr_pool_t *pool, linked_list_pt *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_t list) { +void * linkedList_getFirst(linked_list_pt list) { if (list->size == 0) { return NULL; } return list->header->next->element; } -void * linkedList_getLast(linked_list_t list) { +void * linkedList_getLast(linked_list_pt list) { if (list->size == 0) { return NULL; } return list->header->previous->element; } -void * linkedList_removeFirst(linked_list_t list) { +void * linkedList_removeFirst(linked_list_pt list) { return linkedList_removeEntry(list, list->header->next); } -void * linkedList_removeLast(linked_list_t list) { +void * linkedList_removeLast(linked_list_pt list) { return linkedList_removeEntry(list, list->header->previous); } -void linkedList_addFirst(linked_list_t list, void * element) { +void linkedList_addFirst(linked_list_pt list, void * element) { linkedList_addBefore(list, element, list->header->next); } -void linkedList_addLast(linked_list_t list, void * element) { +void linkedList_addLast(linked_list_pt list, void * element) { linkedList_addBefore(list, element, list->header); } -bool linkedList_contains(linked_list_t list, void * element) { +bool linkedList_contains(linked_list_pt list, void * element) { return linkedList_indexOf(list, element) != 0; } -int linkedList_size(linked_list_t list) { +int linkedList_size(linked_list_pt list) { return list->size; } -bool linkedList_isEmpty(linked_list_t list) { +bool linkedList_isEmpty(linked_list_pt list) { return linkedList_size(list) == 0; } -bool linkedList_addElement(linked_list_t list, void * element) { +bool linkedList_addElement(linked_list_pt list, void * element) { linkedList_addBefore(list, element, list->header); return true; } -bool linkedList_removeElement(linked_list_t list, void * element) { +bool linkedList_removeElement(linked_list_pt list, void * element) { if (element == NULL) { - linked_list_entry_t entry; + linked_list_entry_pt 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_t entry; + linked_list_entry_pt 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_t list) { - linked_list_entry_t entry = list->header->next; +void linkedList_clear(linked_list_pt list) { + linked_list_entry_pt entry = list->header->next; while (entry != list->header) { - linked_list_entry_t next = entry->next; + linked_list_entry_pt next = entry->next; entry->next = entry->previous = NULL; // free(entry->element); entry->element = NULL; @@ -148,26 +148,26 @@ void linkedList_clear(linked_list_t list list->modificationCount++; } -void * linkedList_get(linked_list_t list, int index) { +void * linkedList_get(linked_list_pt list, int index) { return linkedList_entry(list, index)->element; } -void * linkedList_set(linked_list_t list, int index, void * element) { - linked_list_entry_t entry = linkedList_entry(list, index); +void * linkedList_set(linked_list_pt list, int index, void * element) { + linked_list_entry_pt entry = linkedList_entry(list, index); void * old = entry->element; entry->element = element; return old; } -void linkedList_addIndex(linked_list_t list, int index, void * element) { +void linkedList_addIndex(linked_list_pt list, int index, void * element) { linkedList_addBefore(list, element, (index == list->size ? list->header : linkedList_entry(list, index))); } -void * linkedList_removeIndex(linked_list_t list, int index) { +void * linkedList_removeIndex(linked_list_pt list, int index) { return linkedList_removeEntry(list, linkedList_entry(list, index)); } -linked_list_entry_t linkedList_entry(linked_list_t list, int index) { - linked_list_entry_t entry; +linked_list_entry_pt linkedList_entry(linked_list_pt list, int index) { + linked_list_entry_pt entry; int i; if (index < 0 || index >= list->size) { return NULL; @@ -186,10 +186,10 @@ linked_list_entry_t linkedList_entry(lin return entry; } -int linkedList_indexOf(linked_list_t list, void * element) { +int linkedList_indexOf(linked_list_pt list, void * element) { int index = 0; if (element == NULL) { - linked_list_entry_t entry; + linked_list_entry_pt 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_t lis index++; } } else { - linked_list_entry_t entry; + linked_list_entry_pt 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_t lis return -1; } -linked_list_entry_t linkedList_addBefore(linked_list_t list, void * element, linked_list_entry_t entry) { - linked_list_entry_t new = NULL; +linked_list_entry_pt linkedList_addBefore(linked_list_pt list, void * element, linked_list_entry_pt entry) { + linked_list_entry_pt new = NULL; apr_pool_t *sub_pool = NULL; if (apr_pool_create(&sub_pool, list->memory_pool) == APR_SUCCESS) { - new = (linked_list_entry_t) apr_palloc(sub_pool, sizeof(*new)); + new = (linked_list_entry_pt) apr_palloc(sub_pool, sizeof(*new)); new->memory_pool = sub_pool; new->element = element; new->next = entry; @@ -229,7 +229,7 @@ linked_list_entry_t linkedList_addBefore return new; } -void * linkedList_removeEntry(linked_list_t list, linked_list_entry_t entry) { +void * linkedList_removeEntry(linked_list_pt list, linked_list_entry_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/private/test/array_list_test.c (original) +++ incubator/celix/trunk/utils/private/test/array_list_test.c Wed Jun 12 19:08:50 2013 @@ -35,7 +35,7 @@ #include "array_list_private.h" apr_pool_t *memory_pool; -array_list_t list; +array_list_pt list; int setup(void) { apr_initialize(); @@ -222,7 +222,7 @@ void test_arrayList_addAll(void) { char * entry2 = "entry2"; char * entry3 = "entry3"; char * get; - array_list_t toAdd; + array_list_pt toAdd; bool changed; arrayList_clear(list); 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/private/test/hash_map_test.c (original) +++ incubator/celix/trunk/utils/private/test/hash_map_test.c Wed Jun 12 19:08:50 2013 @@ -32,7 +32,7 @@ #include "hash_map.h" #include "hash_map_private.h" -hash_map_t map; +hash_map_pt 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_t entry; + hash_map_entry_pt 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_t entry1; - hash_map_entry_t entry2; - hash_map_entry_t removed; + hash_map_entry_pt entry1; + hash_map_entry_pt entry2; + hash_map_entry_pt 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_t values; + hash_map_values_pt 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=1492377&r1=1492376&r2=1492377&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 Jun 12 19:08:50 2013 @@ -32,7 +32,7 @@ #include "hash_map.h" #include "hash_map_private.h" -hash_map_t map; +hash_map_pt 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_t entry; + hash_map_entry_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/private/test/linked_list_test.c (original) +++ incubator/celix/trunk/utils/private/test/linked_list_test.c Wed Jun 12 19:08:50 2013 @@ -31,7 +31,7 @@ #include "linkedlist.h" apr_pool_t *memory_pool; -linked_list_t list; +linked_list_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/public/include/array_list.h (original) +++ incubator/celix/trunk/utils/public/include/array_list.h Wed Jun 12 19:08:50 2013 @@ -33,39 +33,39 @@ #include "exports.h" #include "celix_errno.h" -typedef struct arrayList * array_list_t; +typedef struct arrayList * array_list_pt; -typedef struct arrayListIterator * array_list_iterator_t; +typedef struct arrayListIterator * array_list_iterator_pt; -typedef celix_status_t (*arrayListElementEqualsFunction)(void *, void *, bool *equals); +typedef celix_status_t (*array_list_element_equals_pt)(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 celix_status_t arrayList_create(apr_pool_t *pool, array_list_pt *list); +UTILS_EXPORT celix_status_t arrayList_createWithEquals(apr_pool_t *pool, array_list_element_equals_pt equals, array_list_pt *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); +UTILS_EXPORT void arrayList_destroy(array_list_pt list); +UTILS_EXPORT void arrayList_trimToSize(array_list_pt list); +UTILS_EXPORT void arrayList_ensureCapacity(array_list_pt list, int capacity); +UTILS_EXPORT unsigned int arrayList_size(array_list_pt list); +UTILS_EXPORT bool arrayList_isEmpty(array_list_pt list); +UTILS_EXPORT bool arrayList_contains(array_list_pt list, void * element); +UTILS_EXPORT int arrayList_indexOf(array_list_pt list, void * element); +UTILS_EXPORT int arrayList_lastIndexOf(array_list_pt list, void * element); +UTILS_EXPORT void * arrayList_get(array_list_pt list, unsigned int index); +UTILS_EXPORT void * arrayList_set(array_list_pt list, unsigned int index, void * element); +UTILS_EXPORT bool arrayList_add(array_list_pt list, void * element); +UTILS_EXPORT int arrayList_addIndex(array_list_pt list, unsigned int index, void * element); +UTILS_EXPORT bool arrayList_addAll(array_list_pt list, array_list_pt toAdd); +UTILS_EXPORT void * arrayList_remove(array_list_pt list, unsigned int index); +UTILS_EXPORT bool arrayList_removeElement(array_list_pt list, void * element); +UTILS_EXPORT void arrayList_clear(array_list_pt list); +UTILS_EXPORT array_list_pt arrayList_clone(apr_pool_t *pool, array_list_pt list); + +UTILS_EXPORT array_list_iterator_pt arrayListIterator_create(array_list_pt list); +UTILS_EXPORT void arrayListIterator_destroy(array_list_iterator_pt iterator); +UTILS_EXPORT bool arrayListIterator_hasNext(array_list_iterator_pt iterator); +UTILS_EXPORT void * arrayListIterator_next(array_list_iterator_pt iterator); +UTILS_EXPORT bool arrayListIterator_hasPrevious(array_list_iterator_pt iterator); +UTILS_EXPORT void * arrayListIterator_previous(array_list_iterator_pt iterator); +UTILS_EXPORT void arrayListIterator_remove(array_list_iterator_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/public/include/hash_map.h (original) +++ incubator/celix/trunk/utils/public/include/hash_map.h Wed Jun 12 19:08:50 2013 @@ -30,61 +30,61 @@ #include "celixbool.h" #include "exports.h" -typedef struct hashMapEntry * hash_map_entry_t; -typedef struct hashMap * hash_map_t; +typedef struct hashMapEntry * hash_map_entry_pt; +typedef struct hashMap * hash_map_pt; -typedef struct hashMapIterator * hash_map_iterator_t; +typedef struct hashMapIterator * hash_map_iterator_pt; -typedef struct hashMapKeySet * hash_map_key_set_t; -typedef struct hashMapValues * hash_map_values_t; -typedef struct hashMapEntrySet * hash_map_entry_set_t; +typedef struct hashMapKeySet * hash_map_key_set_pt; +typedef struct hashMapValues * hash_map_values_pt; +typedef struct hashMapEntrySet * hash_map_entry_set_pt; -UTILS_EXPORT hash_map_t hashMap_create(unsigned int (*keyHash)(void *), unsigned int (*valueHash)(void *), +UTILS_EXPORT hash_map_pt 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_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 hashMap_destroy(hash_map_pt map, bool freeKeys, bool freeValues); +UTILS_EXPORT int hashMap_size(hash_map_pt map); +UTILS_EXPORT bool hashMap_isEmpty(hash_map_pt map); +UTILS_EXPORT void * hashMap_get(hash_map_pt map, void * key); +UTILS_EXPORT bool hashMap_containsKey(hash_map_pt map, void * key); +UTILS_EXPORT hash_map_entry_pt hashMap_getEntry(hash_map_pt map, void * key); +UTILS_EXPORT void * hashMap_put(hash_map_pt map, void * key, void * value); +UTILS_EXPORT void * hashMap_remove(hash_map_pt map, void * key); +UTILS_EXPORT void hashMap_clear(hash_map_pt map, bool freeKey, bool freeValue); +UTILS_EXPORT bool hashMap_containsValue(hash_map_pt map, void * value); + +UTILS_EXPORT hash_map_iterator_pt hashMapIterator_create(hash_map_pt map); +UTILS_EXPORT void hashMapIterator_destroy(hash_map_iterator_pt iterator); +UTILS_EXPORT bool hashMapIterator_hasNext(hash_map_iterator_pt iterator); +UTILS_EXPORT void hashMapIterator_remove(hash_map_iterator_pt iterator); +UTILS_EXPORT void * hashMapIterator_nextValue(hash_map_iterator_pt iterator); +UTILS_EXPORT void * hashMapIterator_nextKey(hash_map_iterator_pt iterator); +UTILS_EXPORT hash_map_entry_pt hashMapIterator_nextEntry(hash_map_iterator_pt iterator); + +UTILS_EXPORT hash_map_key_set_pt hashMapKeySet_create(hash_map_pt map); +UTILS_EXPORT int hashMapKeySet_size(hash_map_key_set_pt keySet); +UTILS_EXPORT bool hashMapKeySet_contains(hash_map_key_set_pt keySet, void * key); +UTILS_EXPORT bool hashMapKeySet_remove(hash_map_key_set_pt keySet, void * key); +UTILS_EXPORT void hashMapKeySet_clear(hash_map_key_set_pt keySet); +UTILS_EXPORT bool hashMapKeySet_isEmpty(hash_map_key_set_pt keySet); + +UTILS_EXPORT hash_map_values_pt hashMapValues_create(hash_map_pt map); +UTILS_EXPORT void hashMapValues_destroy(hash_map_values_pt values); +UTILS_EXPORT hash_map_iterator_pt hashMapValues_iterator(hash_map_values_pt values); +UTILS_EXPORT int hashMapValues_size(hash_map_values_pt values); +UTILS_EXPORT bool hashMapValues_contains(hash_map_values_pt values, void * o); +UTILS_EXPORT void hashMapValues_toArray(hash_map_values_pt values, void* *array[], unsigned int *size); +UTILS_EXPORT bool hashMapValues_remove(hash_map_values_pt values, void * o); +UTILS_EXPORT void hashMapValues_clear(hash_map_values_pt values); +UTILS_EXPORT bool hashMapValues_isEmpty(hash_map_values_pt values); + +UTILS_EXPORT hash_map_entry_set_pt hashMapEntrySet_create(hash_map_pt map); +UTILS_EXPORT int hashMapEntrySet_size(hash_map_entry_set_pt entrySet); +UTILS_EXPORT bool hashMapEntrySet_contains(hash_map_entry_set_pt entrySet, hash_map_entry_pt entry); +UTILS_EXPORT bool hashMapEntrySet_remove(hash_map_values_pt entrySet, hash_map_entry_pt entry); +UTILS_EXPORT void hashMapEntrySet_clear(hash_map_entry_set_pt entrySet); +UTILS_EXPORT bool hashMapEntrySet_isEmpty(hash_map_entry_set_pt entrySet); -UTILS_EXPORT void * hashMapEntry_getKey(hash_map_entry_t entry); -UTILS_EXPORT void * hashMapEntry_getValue(hash_map_entry_t entry); +UTILS_EXPORT void * hashMapEntry_getKey(hash_map_entry_pt entry); +UTILS_EXPORT void * hashMapEntry_getValue(hash_map_entry_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/public/include/linked_list_iterator.h (original) +++ incubator/celix/trunk/utils/public/include/linked_list_iterator.h Wed Jun 12 19:08:50 2013 @@ -32,19 +32,19 @@ #include "linkedlist.h" #include "exports.h" -typedef struct linkedListIterator * linked_list_iterator_t; +typedef struct linkedListIterator * linked_list_iterator_pt; -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); +UTILS_EXPORT linked_list_iterator_pt linkedListIterator_create(linked_list_pt list, unsigned int index); +UTILS_EXPORT void linkedListIterator_destroy(linked_list_iterator_pt iterator); +UTILS_EXPORT bool linkedListIterator_hasNext(linked_list_iterator_pt iterator); +UTILS_EXPORT void * linkedListIterator_next(linked_list_iterator_pt iterator); +UTILS_EXPORT bool linkedListIterator_hasPrevious(linked_list_iterator_pt iterator); +UTILS_EXPORT void * linkedListIterator_previous(linked_list_iterator_pt iterator); +UTILS_EXPORT int linkedListIterator_nextIndex(linked_list_iterator_pt iterator); +UTILS_EXPORT int linkedListIterator_previousIndex(linked_list_iterator_pt iterator); +UTILS_EXPORT void linkedListIterator_remove(linked_list_iterator_pt iterator); +UTILS_EXPORT void linkedListIterator_set(linked_list_iterator_pt iterator, void * element); +UTILS_EXPORT void linkedListIterator_add(linked_list_iterator_pt 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=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/utils/public/include/linkedlist.h (original) +++ incubator/celix/trunk/utils/public/include/linkedlist.h Wed Jun 12 19:08:50 2013 @@ -33,31 +33,31 @@ #include "celix_errno.h" #include "exports.h" -typedef struct linkedListEntry * linked_list_entry_t; -typedef struct linkedList * linked_list_t; +typedef struct linkedListEntry * linked_list_entry_pt; +typedef struct linkedList * linked_list_pt; -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); +UTILS_EXPORT celix_status_t linkedList_create(apr_pool_t *pool, linked_list_pt *list); +UTILS_EXPORT celix_status_t linkedList_clone(linked_list_pt list, apr_pool_t *pool, linked_list_pt *clone); +UTILS_EXPORT void * linkedList_getFirst(linked_list_pt list); +UTILS_EXPORT void * linkedList_getLast(linked_list_pt list); +UTILS_EXPORT void * linkedList_removeFirst(linked_list_pt list); +UTILS_EXPORT void * linkedList_removeLast(linked_list_pt list); +UTILS_EXPORT void linkedList_addFirst(linked_list_pt list, void * element); +UTILS_EXPORT void linkedList_addLast(linked_list_pt list, void * element); +UTILS_EXPORT bool linkedList_contains(linked_list_pt list, void * element); +UTILS_EXPORT int linkedList_size(linked_list_pt list); +UTILS_EXPORT bool linkedList_isEmpty(linked_list_pt list); +UTILS_EXPORT bool linkedList_addElement(linked_list_pt list, void * element); +UTILS_EXPORT bool linkedList_removeElement(linked_list_pt list, void * element); +UTILS_EXPORT void linkedList_clear(linked_list_pt list); +UTILS_EXPORT void * linkedList_get(linked_list_pt list, int index); +UTILS_EXPORT void * linkedList_set(linked_list_pt list, int index, void * element); +UTILS_EXPORT void linkedList_addIndex(linked_list_pt list, int index, void * element); +UTILS_EXPORT void * linkedList_removeIndex(linked_list_pt list, int index); +UTILS_EXPORT linked_list_entry_pt linkedList_entry(linked_list_pt list, int index); +UTILS_EXPORT int linkedList_indexOf(linked_list_pt list, void * element); +UTILS_EXPORT linked_list_entry_pt linkedList_addBefore(linked_list_pt list, void * element, linked_list_entry_pt entry); +UTILS_EXPORT void * linkedList_removeEntry(linked_list_pt list, linked_list_entry_pt entry); #endif /* LINKEDLIST_H_ */
