You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2013/06/12 21:08:55 UTC
svn commit: r1492377 [12/12] - in /incubator/celix/trunk:
dependency_manager/private/src/ dependency_manager/public/include/
deployment_admin/private/include/ deployment_admin/private/src/
deployment_admin/public/include/ device_access/device_access/pr...
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_ */