celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject 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...
Date Wed, 12 Jun 2013 19:08:55 GMT
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_ */



Mime
View raw message