incubator-celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject svn commit: r1492377 [7/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/pri...
Date Wed, 12 Jun 2013 19:08:55 GMT
Modified: incubator/celix/trunk/framework/private/src/service_tracker.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/service_tracker.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/service_tracker.c (original)
+++ incubator/celix/trunk/framework/private/src/service_tracker.c Wed Jun 12 19:08:50 2013
@@ -35,29 +35,29 @@
 #include "service_reference.h"
 
 struct serviceTracker {
-	bundle_context_t context;
+	bundle_context_pt context;
 	char * filter;
 
 	apr_pool_t *pool;
-	service_tracker_t tracker;
-	service_tracker_customizer_t customizer;
-	service_listener_t listener;
-	array_list_t tracked;
+	service_tracker_pt tracker;
+	service_tracker_customizer_pt customizer;
+	service_listener_pt listener;
+	array_list_pt tracked;
 };
 
 struct tracked {
-	service_reference_t reference;
+	service_reference_pt reference;
 	void * service;
 };
 
-typedef struct tracked * TRACKED;
+typedef struct tracked * tracked_pt;
 
 static apr_status_t serviceTracker_destroy(void *trackerP);
-static void * serviceTracker_addingService(service_tracker_t tracker, service_reference_t reference);
-static celix_status_t serviceTracker_track(service_tracker_t tracker, service_reference_t reference, service_event_t event);
-static celix_status_t serviceTracker_untrack(service_tracker_t tracker, service_reference_t reference, service_event_t event);
+static void * serviceTracker_addingService(service_tracker_pt tracker, service_reference_pt reference);
+static celix_status_t serviceTracker_track(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event);
+static celix_status_t serviceTracker_untrack(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event);
 
-celix_status_t serviceTracker_create(apr_pool_t *pool, bundle_context_t context, char * service, service_tracker_customizer_t customizer, service_tracker_t *tracker) {
+celix_status_t serviceTracker_create(apr_pool_t *pool, bundle_context_pt context, char * service, service_tracker_customizer_pt customizer, service_tracker_pt *tracker) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (service == NULL || *tracker != NULL) {
@@ -78,10 +78,10 @@ celix_status_t serviceTracker_create(apr
 	return status;
 }
 
-celix_status_t serviceTracker_createWithFilter(apr_pool_t *pool, bundle_context_t context, char * filter, service_tracker_customizer_t customizer, service_tracker_t *tracker) {
+celix_status_t serviceTracker_createWithFilter(apr_pool_t *pool, bundle_context_pt context, char * filter, service_tracker_customizer_pt customizer, service_tracker_pt *tracker) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	*tracker = (service_tracker_t) apr_palloc(pool, sizeof(**tracker));
+	*tracker = (service_tracker_pt) apr_palloc(pool, sizeof(**tracker));
 	if (!*tracker) {
 		status = CELIX_ENOMEM;
 	} else {
@@ -102,22 +102,22 @@ celix_status_t serviceTracker_createWith
 }
 
 apr_status_t serviceTracker_destroy(void *trackerP) {
-	service_tracker_t tracker = (service_tracker_t) trackerP;
+	service_tracker_pt tracker = (service_tracker_pt) trackerP;
 	bundleContext_removeServiceListener(tracker->context, tracker->listener);
 	arrayList_destroy(tracker->tracked);
 
 	return APR_SUCCESS;
 }
 
-celix_status_t serviceTracker_open(service_tracker_t tracker) {
-	service_listener_t listener;
-	array_list_t initial = NULL;
+celix_status_t serviceTracker_open(service_tracker_pt tracker) {
+	service_listener_pt listener;
+	array_list_pt initial = NULL;
 	celix_status_t status = CELIX_SUCCESS;
-	listener = (service_listener_t) apr_palloc(tracker->pool, sizeof(*listener));
+	listener = (service_listener_pt) apr_palloc(tracker->pool, sizeof(*listener));
 	
 	status = bundleContext_getServiceReferences(tracker->context, NULL, tracker->filter, &initial);
 	if (status == CELIX_SUCCESS) {
-		service_reference_t initial_reference;
+		service_reference_pt initial_reference;
 		unsigned int i;
 
 		listener->pool = tracker->pool;
@@ -128,7 +128,7 @@ celix_status_t serviceTracker_open(servi
 			tracker->listener = listener;
 
 			for (i = 0; i < arrayList_size(initial); i++) {
-				initial_reference = (service_reference_t) arrayList_get(initial, i);
+				initial_reference = (service_reference_pt) arrayList_get(initial, i);
 				serviceTracker_track(tracker, initial_reference, NULL);
 			}
 			arrayList_clear(initial);
@@ -141,16 +141,16 @@ celix_status_t serviceTracker_open(servi
 	return status;
 }
 
-celix_status_t serviceTracker_close(service_tracker_t tracker) {
+celix_status_t serviceTracker_close(service_tracker_pt tracker) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = bundleContext_removeServiceListener(tracker->context, tracker->listener);
 	if (status == CELIX_SUCCESS) {
-		array_list_t refs = serviceTracker_getServiceReferences(tracker);
+		array_list_pt refs = serviceTracker_getServiceReferences(tracker);
 		if (refs != NULL) {
 			unsigned int i;
 			for (i = 0; i < arrayList_size(refs); i++) {
-				service_reference_t ref = (service_reference_t) arrayList_get(refs, i);
+				service_reference_pt ref = (service_reference_pt) arrayList_get(refs, i);
 				status = serviceTracker_untrack(tracker, ref, NULL);
 			}
 		}
@@ -160,60 +160,60 @@ celix_status_t serviceTracker_close(serv
 	return status;
 }
 
-service_reference_t serviceTracker_getServiceReference(service_tracker_t tracker) {
-	TRACKED tracked;
+service_reference_pt serviceTracker_getServiceReference(service_tracker_pt tracker) {
+	tracked_pt tracked;
 	unsigned int i;
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		return tracked->reference;
 	}
 	return NULL;
 }
 
-array_list_t serviceTracker_getServiceReferences(service_tracker_t tracker) {
-	TRACKED tracked;
+array_list_pt serviceTracker_getServiceReferences(service_tracker_pt tracker) {
+	tracked_pt tracked;
 	unsigned int i;
 	int size = arrayList_size(tracker->tracked);
-	array_list_t references = NULL;
+	array_list_pt references = NULL;
 	arrayList_create(tracker->pool, &references);
 	
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		arrayList_add(references, tracked->reference);
 	}
 	return references;
 }
 
-void *serviceTracker_getService(service_tracker_t tracker) {
-	TRACKED tracked;
+void *serviceTracker_getService(service_tracker_pt tracker) {
+	tracked_pt tracked;
 	unsigned int i;
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		return tracked->service;
 	}
 	return NULL;
 }
 
-array_list_t serviceTracker_getServices(service_tracker_t tracker) {
-	TRACKED tracked;
+array_list_pt serviceTracker_getServices(service_tracker_pt tracker) {
+	tracked_pt tracked;
 	unsigned int i;
 	int size = arrayList_size(tracker->tracked);
-	array_list_t references = NULL;
+	array_list_pt references = NULL;
 	arrayList_create(tracker->pool, &references);
 	
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		arrayList_add(references, tracked->service);
 	}
 	return references;
 }
 
-void *serviceTracker_getServiceByReference(service_tracker_t tracker, service_reference_t reference) {
-	TRACKED tracked;
+void *serviceTracker_getServiceByReference(service_tracker_pt tracker, service_reference_pt reference) {
+	tracked_pt tracked;
 	unsigned int i;
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
 		bool equals;
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		serviceReference_equals(reference, tracked->reference, &equals);
 		if (equals) {
 			return tracked->service;
@@ -222,8 +222,8 @@ void *serviceTracker_getServiceByReferen
 	return NULL;
 }
 
-void serviceTracker_serviceChanged(service_listener_t listener, service_event_t event) {
-	service_tracker_t tracker = listener->handle;
+void serviceTracker_serviceChanged(service_listener_pt listener, service_event_pt event) {
+	service_tracker_pt tracker = listener->handle;
 	switch (event->type) {
 		case SERVICE_EVENT_REGISTERED:
 		case SERVICE_EVENT_MODIFIED:
@@ -237,15 +237,15 @@ void serviceTracker_serviceChanged(servi
 	}
 }
 
-celix_status_t serviceTracker_track(service_tracker_t tracker, service_reference_t reference, service_event_t event) {
+celix_status_t serviceTracker_track(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	TRACKED tracked = NULL;
+	tracked_pt tracked = NULL;
 	int found = -1;
 	unsigned int i;
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
 		bool equals;
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		serviceReference_equals(reference, tracked->reference, &equals);
 		if (equals) {
 			found = 0;
@@ -256,13 +256,13 @@ celix_status_t serviceTracker_track(serv
 	if (found) {
 		void * service = serviceTracker_addingService(tracker, reference);
 		if (service != NULL) {
-			tracked = (TRACKED) malloc(sizeof(*tracked));
+			tracked = (tracked_pt) malloc(sizeof(*tracked));
 			tracked->reference = reference;
 			tracked->service = service;
 			arrayList_add(tracker->tracked, tracked);
 			if (tracker->customizer != NULL) {
 				void *handle = NULL;
-				addedCallback function = NULL;
+				added_callback_pt function = NULL;
 
 				serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
 				serviceTrackerCustomizer_getAddedFunction(tracker->customizer, &function);
@@ -274,7 +274,7 @@ celix_status_t serviceTracker_track(serv
 	} else {
 		if (tracker->customizer != NULL) {
 			void *handle = NULL;
-			modifiedCallback function = NULL;
+			modified_callback_pt function = NULL;
 
 			serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
 			serviceTrackerCustomizer_getModifiedFunction(tracker->customizer, &function);
@@ -286,12 +286,12 @@ celix_status_t serviceTracker_track(serv
 	return status;
 }
 
-void * serviceTracker_addingService(service_tracker_t tracker, service_reference_t reference) {
+void * serviceTracker_addingService(service_tracker_pt tracker, service_reference_pt reference) {
     void *svc = NULL;
 
     if (tracker->customizer != NULL) {
     	void *handle = NULL;
-		addingCallback function = NULL;
+		adding_callback_pt function = NULL;
 
 		serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
 		serviceTrackerCustomizer_getAddingFunction(tracker->customizer, &function);
@@ -304,15 +304,15 @@ void * serviceTracker_addingService(serv
     return svc;
 }
 
-celix_status_t serviceTracker_untrack(service_tracker_t tracker, service_reference_t reference, service_event_t event) {
+celix_status_t serviceTracker_untrack(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event) {
 	celix_status_t status = CELIX_SUCCESS;
-	TRACKED tracked = NULL;
+	tracked_pt tracked = NULL;
 	unsigned int i;
 	bool result = false;
 
 	for (i = 0; i < arrayList_size(tracker->tracked); i++) {
 		bool equals;
-		tracked = (TRACKED) arrayList_get(tracker->tracked, i);
+		tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
 		serviceReference_equals(reference, tracked->reference, &equals);
 		if (equals) {
 			if (tracked != NULL) {
@@ -322,7 +322,7 @@ celix_status_t serviceTracker_untrack(se
 			if (status == CELIX_SUCCESS) {
 				if (tracker->customizer != NULL) {
 					void *handle = NULL;
-					removedCallback function = NULL;
+					removed_callback_pt function = NULL;
 
 					serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
 					serviceTrackerCustomizer_getRemovedFunction(tracker->customizer, &function);

Modified: incubator/celix/trunk/framework/private/src/service_tracker_customizer.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/service_tracker_customizer.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/service_tracker_customizer.c (original)
+++ incubator/celix/trunk/framework/private/src/service_tracker_customizer.c Wed Jun 12 19:08:50 2013
@@ -34,15 +34,15 @@ static apr_status_t serviceTrackerCustom
 
 struct serviceTrackerCustomizer {
 	void * handle;
-	celix_status_t (*addingService)(void * handle, service_reference_t reference, void **service);
-	celix_status_t (*addedService)(void * handle, service_reference_t reference, void * service);
-	celix_status_t (*modifiedService)(void * handle, service_reference_t reference, void * service);
-	celix_status_t (*removedService)(void * handle, service_reference_t reference, void * service);
+	celix_status_t (*addingService)(void * handle, service_reference_pt reference, void **service);
+	celix_status_t (*addedService)(void * handle, service_reference_pt reference, void * service);
+	celix_status_t (*modifiedService)(void * handle, service_reference_pt reference, void * service);
+	celix_status_t (*removedService)(void * handle, service_reference_pt reference, void * service);
 };
 
 celix_status_t serviceTrackerCustomizer_create(apr_pool_t *pool, void *handle,
-		addingCallback addingFunction, addedCallback addedFunction,
-		modifiedCallback modifiedFunction, removedCallback removedFunction, service_tracker_customizer_t *customizer) {
+		adding_callback_pt addingFunction, added_callback_pt addedFunction,
+		modified_callback_pt modifiedFunction, removed_callback_pt removedFunction, service_tracker_customizer_pt *customizer) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (pool == NULL || handle == NULL || *customizer != NULL) {
@@ -66,7 +66,7 @@ celix_status_t serviceTrackerCustomizer_
 }
 
 static apr_status_t serviceTrackerCustomizer_destroy(void *customizerPointer) {
-	service_tracker_customizer_t customizer = (service_tracker_customizer_t) customizerPointer;
+	service_tracker_customizer_pt customizer = (service_tracker_customizer_pt) customizerPointer;
 
 	customizer->handle = NULL;
 	customizer->addingService = NULL;
@@ -77,7 +77,7 @@ static apr_status_t serviceTrackerCustom
 	return APR_SUCCESS;
 }
 
-celix_status_t serviceTrackerCustomizer_getHandle(service_tracker_customizer_t customizer, void **handle) {
+celix_status_t serviceTrackerCustomizer_getHandle(service_tracker_customizer_pt customizer, void **handle) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*handle = customizer->handle;
@@ -85,7 +85,7 @@ celix_status_t serviceTrackerCustomizer_
 	return status;
 }
 
-celix_status_t serviceTrackerCustomizer_getAddingFunction(service_tracker_customizer_t customizer, addingCallback *function) {
+celix_status_t serviceTrackerCustomizer_getAddingFunction(service_tracker_customizer_pt customizer, adding_callback_pt *function) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*function = customizer->addingService;
@@ -93,7 +93,7 @@ celix_status_t serviceTrackerCustomizer_
 	return status;
 }
 
-celix_status_t serviceTrackerCustomizer_getAddedFunction(service_tracker_customizer_t customizer, addedCallback *function) {
+celix_status_t serviceTrackerCustomizer_getAddedFunction(service_tracker_customizer_pt customizer, added_callback_pt *function) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*function = customizer->addedService;
@@ -101,7 +101,7 @@ celix_status_t serviceTrackerCustomizer_
 	return status;
 }
 
-celix_status_t serviceTrackerCustomizer_getModifiedFunction(service_tracker_customizer_t customizer, modifiedCallback *function) {
+celix_status_t serviceTrackerCustomizer_getModifiedFunction(service_tracker_customizer_pt customizer, modified_callback_pt *function) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*function = customizer->modifiedService;
@@ -109,7 +109,7 @@ celix_status_t serviceTrackerCustomizer_
 	return status;
 }
 
-celix_status_t serviceTrackerCustomizer_getRemovedFunction(service_tracker_customizer_t customizer, removedCallback *function) {
+celix_status_t serviceTrackerCustomizer_getRemovedFunction(service_tracker_customizer_pt customizer, removed_callback_pt *function) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*function = customizer->removedService;

Modified: incubator/celix/trunk/framework/private/src/version.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/version.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/version.c (original)
+++ incubator/celix/trunk/framework/private/src/version.c Wed Jun 12 19:08:50 2013
@@ -43,10 +43,10 @@ struct version {
 
 static apr_status_t version_destroy(void *handle);
 
-celix_status_t version_createVersion(apr_pool_t *pool, int major, int minor, int micro, char * qualifier, version_t *version) {
+celix_status_t version_createVersion(apr_pool_t *pool, int major, int minor, int micro, char * qualifier, version_pt *version) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	*version = (version_t) apr_palloc(pool, sizeof(**version));
+	*version = (version_pt) apr_palloc(pool, sizeof(**version));
 	if (!*version) {
 		status = CELIX_ENOMEM;
 	} else {
@@ -93,12 +93,12 @@ celix_status_t version_createVersion(apr
 	return status;
 }
 
-celix_status_t version_clone(version_t version, apr_pool_t *pool, version_t *clone) {
+celix_status_t version_clone(version_pt version, apr_pool_t *pool, version_pt *clone) {
 	return version_createVersion(pool, version->major, version->minor, version->micro, version->qualifier, clone);
 }
 
 apr_status_t version_destroy(void *handle) {
-	version_t version = (version_t) handle;
+	version_pt version = (version_pt) handle;
 	version->major = 0;
 	version->minor = 0;
 	version->micro = 0;
@@ -106,7 +106,7 @@ apr_status_t version_destroy(void *handl
 	return APR_SUCCESS;
 }
 
-celix_status_t version_createVersionFromString(apr_pool_t *pool, char * versionStr, version_t *version) {
+celix_status_t version_createVersionFromString(apr_pool_t *pool, char * versionStr, version_pt *version) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	int major = 0;
@@ -146,11 +146,11 @@ celix_status_t version_createVersionFrom
 	return status;
 }
 
-celix_status_t version_createEmptyVersion(apr_pool_t *pool, version_t *version) {
+celix_status_t version_createEmptyVersion(apr_pool_t *pool, version_pt *version) {
 	return version_createVersion(pool, 0, 0, 0, "", version);
 }
 
-celix_status_t version_compareTo(version_t version, version_t compare, int *result) {
+celix_status_t version_compareTo(version_pt version, version_pt compare, int *result) {
 	celix_status_t status = CELIX_SUCCESS;
 	if (compare == version) {
 		*result = 0;
@@ -176,7 +176,7 @@ celix_status_t version_compareTo(version
 	return status;
 }
 
-celix_status_t version_toString(version_t version, apr_pool_t *pool, char **string) {
+celix_status_t version_toString(version_pt version, apr_pool_t *pool, char **string) {
 	if (strlen(version->qualifier) > 0) {
 		*string = apr_psprintf(pool, "%d.%d.%d.%s", version->major, version->minor, version->micro, version->qualifier);
 	} else {

Modified: incubator/celix/trunk/framework/private/src/version_range.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/version_range.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/version_range.c (original)
+++ incubator/celix/trunk/framework/private/src/version_range.c Wed Jun 12 19:08:50 2013
@@ -30,19 +30,19 @@
 #include "version_range.h"
 
 struct versionRange {
-	version_t low;
+	version_pt low;
 	bool isLowInclusive;
-	version_t high;
+	version_pt high;
 	bool isHighInclusive;
 
 };
 
 apr_status_t versionRange_destroy(void *rangeP);
 
-celix_status_t versionRange_createVersionRange(apr_pool_t *pool, version_t low, bool isLowInclusive,
-			version_t high, bool isHighInclusive, version_range_t *range) {
+celix_status_t versionRange_createVersionRange(apr_pool_t *pool, version_pt low, bool isLowInclusive,
+			version_pt high, bool isHighInclusive, version_range_pt *range) {
 	celix_status_t status = CELIX_SUCCESS;
-	*range = (version_range_t) apr_palloc(pool, sizeof(**range));
+	*range = (version_range_pt) apr_palloc(pool, sizeof(**range));
 	if (!*range) {
 		status = CELIX_ENOMEM;
 	} else {
@@ -58,7 +58,7 @@ celix_status_t versionRange_createVersio
 }
 
 apr_status_t versionRange_destroy(void *rangeP) {
-	version_range_t range = rangeP;
+	version_range_pt range = rangeP;
 	range->high = NULL;
 	range->isHighInclusive = false;
 	range->low = NULL;
@@ -66,10 +66,10 @@ apr_status_t versionRange_destroy(void *
 	return APR_SUCCESS;
 }
 
-celix_status_t versionRange_createInfiniteVersionRange(apr_pool_t *pool, version_range_t *range) {
+celix_status_t versionRange_createInfiniteVersionRange(apr_pool_t *pool, version_range_pt *range) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	version_t version = NULL;
+	version_pt version = NULL;
 	status = version_createEmptyVersion(pool, &version);
 	if (status == CELIX_SUCCESS) {
 		status = versionRange_createVersionRange(pool, version, true, NULL, true, range);
@@ -78,7 +78,7 @@ celix_status_t versionRange_createInfini
 	return status;
 }
 
-celix_status_t versionRange_isInRange(version_range_t versionRange, version_t version, bool *inRange) {
+celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version, bool *inRange) {
 	celix_status_t status = CELIX_SUCCESS;
 	if (versionRange->high == NULL) {
 		int cmp;
@@ -127,7 +127,7 @@ celix_status_t versionRange_isInRange(ve
 	return status;
 }
 
-celix_status_t versionRange_parse(apr_pool_t *pool, char * rangeStr, version_range_t *range) {
+celix_status_t versionRange_parse(apr_pool_t *pool, char * rangeStr, version_range_pt *range) {
 	celix_status_t status = CELIX_SUCCESS;
 	if (strchr(rangeStr, ',') != NULL) {
 		apr_pool_t *spool;
@@ -148,7 +148,7 @@ celix_status_t versionRange_parse(apr_po
 				if (!vhigh) {
 					status = CELIX_ENOMEM;
 				} else {					
-					version_t versionLow = NULL;
+					version_pt versionLow = NULL;
 					int rangeL = strlen(rangeStr);
 					char start = rangeStr[0];
 					char end = rangeStr[rangeL-1];
@@ -157,7 +157,7 @@ celix_status_t versionRange_parse(apr_po
 					
 					status = version_createVersionFromString(pool, vlow, &versionLow);
 					if (status == CELIX_SUCCESS) {
-						version_t versionHigh = NULL;
+						version_pt versionHigh = NULL;
 						status = version_createVersionFromString(pool, vhigh, &versionHigh);
 						if (status == CELIX_SUCCESS) {
 							status = versionRange_createVersionRange(pool,
@@ -174,7 +174,7 @@ celix_status_t versionRange_parse(apr_po
 			apr_pool_destroy(spool);
 		}
 	} else {
-		version_t version = NULL;
+		version_pt version = NULL;
 		status = version_createVersionFromString(pool, rangeStr, &version);
 		if (status == CELIX_SUCCESS) {
 			status = versionRange_createVersionRange(pool, version, true, NULL, false, range);

Modified: incubator/celix/trunk/framework/private/src/wire.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/wire.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/wire.c (original)
+++ incubator/celix/trunk/framework/private/src/wire.c Wed Jun 12 19:08:50 2013
@@ -29,19 +29,19 @@
 #include "wire.h"
 
 struct wire {
-	module_t importer;
-	requirement_t requirement;
-	module_t exporter;
-	capability_t capability;
+	module_pt importer;
+	requirement_pt requirement;
+	module_pt exporter;
+	capability_pt capability;
 };
 
 apr_status_t wire_destroy(void *handle);
 
-celix_status_t wire_create(apr_pool_t *pool, module_t importer, requirement_t requirement,
-		module_t exporter, capability_t capability, wire_t *wire) {
+celix_status_t wire_create(apr_pool_t *pool, module_pt importer, requirement_pt requirement,
+		module_pt exporter, capability_pt capability, wire_pt *wire) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	(*wire) = (wire_t) apr_palloc(pool, sizeof(**wire));
+	(*wire) = (wire_pt) apr_palloc(pool, sizeof(**wire));
 	if (!*wire) {
 		status = CELIX_ENOMEM;
 	} else {
@@ -57,7 +57,7 @@ celix_status_t wire_create(apr_pool_t *p
 }
 
 apr_status_t wire_destroy(void *handle) {
-	wire_t wire = (wire_t) handle;
+	wire_pt wire = (wire_pt) handle;
 	wire->importer = NULL;
 	wire->requirement = NULL;
 	wire->exporter = NULL;
@@ -65,22 +65,22 @@ apr_status_t wire_destroy(void *handle) 
 	return APR_SUCCESS;
 }
 
-celix_status_t wire_getCapability(wire_t wire, capability_t *capability) {
+celix_status_t wire_getCapability(wire_pt wire, capability_pt *capability) {
 	*capability = wire->capability;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t wire_getRequirement(wire_t wire, requirement_t *requirement) {
+celix_status_t wire_getRequirement(wire_pt wire, requirement_pt *requirement) {
 	*requirement = wire->requirement;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t wire_getImporter(wire_t wire, module_t *importer) {
+celix_status_t wire_getImporter(wire_pt wire, module_pt *importer) {
 	*importer = wire->importer;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t wire_getExporter(wire_t wire, module_t *exporter) {
+celix_status_t wire_getExporter(wire_pt wire, module_pt *exporter) {
 	*exporter = wire->exporter;
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/framework/public/include/bundle.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle.h Wed Jun 12 19:08:50 2013
@@ -30,7 +30,7 @@
 #include <apr_general.h>
 #include <apr_portable.h>
 
-typedef struct bundle * bundle_t;
+typedef struct bundle * bundle_pt;
 
 #include "celix_errno.h"
 #include "bundle_state.h"
@@ -39,62 +39,62 @@ typedef struct bundle * bundle_t;
 #include "service_reference.h"
 #include "bundle_context.h"
 
-FRAMEWORK_EXPORT celix_status_t bundle_create(bundle_t * bundle, apr_pool_t *mp);
-FRAMEWORK_EXPORT celix_status_t bundle_createFromArchive(bundle_t * bundle, framework_t framework, bundle_archive_t archive, apr_pool_t *bundlePool);
-FRAMEWORK_EXPORT celix_status_t bundle_destroy(bundle_t bundle);
-
-FRAMEWORK_EXPORT celix_status_t bundle_isSystemBundle(bundle_t bundle, bool *systemBundle);
-FRAMEWORK_EXPORT celix_status_t bundle_getArchive(bundle_t bundle, bundle_archive_t *archive);
-FRAMEWORK_EXPORT celix_status_t bundle_getCurrentModule(bundle_t bundle, module_t *module);
-FRAMEWORK_EXPORT array_list_t bundle_getModules(bundle_t bundle);
-FRAMEWORK_EXPORT void * bundle_getHandle(bundle_t bundle);
-FRAMEWORK_EXPORT void bundle_setHandle(bundle_t bundle, void * handle);
-FRAMEWORK_EXPORT ACTIVATOR bundle_getActivator(bundle_t bundle);
-FRAMEWORK_EXPORT celix_status_t bundle_setActivator(bundle_t bundle, ACTIVATOR activator);
-FRAMEWORK_EXPORT celix_status_t bundle_getManifest(bundle_t bundle, MANIFEST *manifest);
-FRAMEWORK_EXPORT celix_status_t bundle_setManifest(bundle_t bundle, MANIFEST manifest);
-FRAMEWORK_EXPORT celix_status_t bundle_getContext(bundle_t bundle, bundle_context_t *context);
-FRAMEWORK_EXPORT celix_status_t bundle_setContext(bundle_t bundle, bundle_context_t context);
-FRAMEWORK_EXPORT celix_status_t bundle_getEntry(bundle_t bundle, char * name, apr_pool_t *pool, char **entry);
-
-FRAMEWORK_EXPORT celix_status_t bundle_start(bundle_t bundle, int options);
-FRAMEWORK_EXPORT celix_status_t bundle_update(bundle_t bundle, char *inputFile);
-FRAMEWORK_EXPORT celix_status_t bundle_stop(bundle_t bundle, int options);
-FRAMEWORK_EXPORT celix_status_t bundle_uninstall(bundle_t bundle);
-
-FRAMEWORK_EXPORT celix_status_t bundle_setState(bundle_t bundle, bundle_state_e state);
-FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateInactive(bundle_t bundle);
-FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateUninstalled(bundle_t bundle);
-
-FRAMEWORK_EXPORT void uninstallBundle(bundle_t bundle);
-
-FRAMEWORK_EXPORT celix_status_t bundle_revise(bundle_t bundle, char * location, char *inputFile);
-FRAMEWORK_EXPORT celix_status_t bundle_addModule(bundle_t bundle, module_t module);
-FRAMEWORK_EXPORT celix_status_t bundle_closeModules(bundle_t bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_create(bundle_pt * bundle, apr_pool_t *mp);
+FRAMEWORK_EXPORT celix_status_t bundle_createFromArchive(bundle_pt * bundle, framework_pt framework, bundle_archive_pt archive, apr_pool_t *bundlePool);
+FRAMEWORK_EXPORT celix_status_t bundle_destroy(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_isSystemBundle(bundle_pt bundle, bool *systemBundle);
+FRAMEWORK_EXPORT celix_status_t bundle_getArchive(bundle_pt bundle, bundle_archive_pt *archive);
+FRAMEWORK_EXPORT celix_status_t bundle_getCurrentModule(bundle_pt bundle, module_pt *module);
+FRAMEWORK_EXPORT array_list_pt bundle_getModules(bundle_pt bundle);
+FRAMEWORK_EXPORT void * bundle_getHandle(bundle_pt bundle);
+FRAMEWORK_EXPORT void bundle_setHandle(bundle_pt bundle, void * handle);
+FRAMEWORK_EXPORT activator_pt bundle_getActivator(bundle_pt bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_setActivator(bundle_pt bundle, activator_pt activator);
+FRAMEWORK_EXPORT celix_status_t bundle_getManifest(bundle_pt bundle, manifest_pt *manifest);
+FRAMEWORK_EXPORT celix_status_t bundle_setManifest(bundle_pt bundle, manifest_pt manifest);
+FRAMEWORK_EXPORT celix_status_t bundle_getContext(bundle_pt bundle, bundle_context_pt *context);
+FRAMEWORK_EXPORT celix_status_t bundle_setContext(bundle_pt bundle, bundle_context_pt context);
+FRAMEWORK_EXPORT celix_status_t bundle_getEntry(bundle_pt bundle, char * name, apr_pool_t *pool, char **entry);
+
+FRAMEWORK_EXPORT celix_status_t bundle_start(bundle_pt bundle, int options);
+FRAMEWORK_EXPORT celix_status_t bundle_update(bundle_pt bundle, char *inputFile);
+FRAMEWORK_EXPORT celix_status_t bundle_stop(bundle_pt bundle, int options);
+FRAMEWORK_EXPORT celix_status_t bundle_uninstall(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setState(bundle_pt bundle, bundle_state_e state);
+FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateInactive(bundle_pt bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateUninstalled(bundle_pt bundle);
+
+FRAMEWORK_EXPORT void uninstallBundle(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_revise(bundle_pt bundle, char * location, char *inputFile);
+FRAMEWORK_EXPORT celix_status_t bundle_addModule(bundle_pt bundle, module_pt module);
+FRAMEWORK_EXPORT celix_status_t bundle_closeModules(bundle_pt bundle);
 
 // Service Reference Functions
-FRAMEWORK_EXPORT array_list_t getUsingBundles(service_reference_t reference);
+FRAMEWORK_EXPORT array_list_pt getUsingBundles(service_reference_pt reference);
 
-FRAMEWORK_EXPORT int compareTo(service_reference_t a, service_reference_t b);
+FRAMEWORK_EXPORT int compareTo(service_reference_pt a, service_reference_pt b);
 
-FRAMEWORK_EXPORT celix_status_t bundle_getState(bundle_t bundle, bundle_state_e *state);
-FRAMEWORK_EXPORT celix_status_t bundle_isLockable(bundle_t bundle, bool *lockable);
-FRAMEWORK_EXPORT celix_status_t bundle_getLockingThread(bundle_t bundle, apr_os_thread_t *thread);
-FRAMEWORK_EXPORT celix_status_t bundle_lock(bundle_t bundle, bool *locked);
-FRAMEWORK_EXPORT celix_status_t bundle_unlock(bundle_t bundle, bool *unlocked);
+FRAMEWORK_EXPORT celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state);
+FRAMEWORK_EXPORT celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable);
+FRAMEWORK_EXPORT celix_status_t bundle_getLockingThread(bundle_pt bundle, apr_os_thread_t *thread);
+FRAMEWORK_EXPORT celix_status_t bundle_lock(bundle_pt bundle, bool *locked);
+FRAMEWORK_EXPORT celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked);
 
-FRAMEWORK_EXPORT celix_status_t bundle_closeAndDelete(bundle_t bundle);
-FRAMEWORK_EXPORT celix_status_t bundle_close(bundle_t bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_closeAndDelete(bundle_pt bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_close(bundle_pt bundle);
 
-FRAMEWORK_EXPORT celix_status_t bundle_refresh(bundle_t bundle);
-FRAMEWORK_EXPORT celix_status_t bundle_getBundleId(bundle_t bundle, long *id);
+FRAMEWORK_EXPORT celix_status_t bundle_refresh(bundle_pt bundle);
+FRAMEWORK_EXPORT celix_status_t bundle_getBundleId(bundle_pt bundle, long *id);
 
-FRAMEWORK_EXPORT celix_status_t bundle_getRegisteredServices(bundle_t bundle, apr_pool_t *pool, array_list_t *list);
-FRAMEWORK_EXPORT celix_status_t bundle_getServicesInUse(bundle_t bundle, array_list_t *list);
+FRAMEWORK_EXPORT celix_status_t bundle_getRegisteredServices(bundle_pt bundle, apr_pool_t *pool, array_list_pt *list);
+FRAMEWORK_EXPORT celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list);
 
-FRAMEWORK_EXPORT celix_status_t bundle_getMemoryPool(bundle_t bundle, apr_pool_t **pool);
+FRAMEWORK_EXPORT celix_status_t bundle_getMemoryPool(bundle_pt bundle, apr_pool_t **pool);
 
-FRAMEWORK_EXPORT celix_status_t bundle_setFramework(bundle_t bundle, framework_t framework);
-FRAMEWORK_EXPORT celix_status_t bundle_getFramework(bundle_t bundle, framework_t *framework);
+FRAMEWORK_EXPORT celix_status_t bundle_setFramework(bundle_pt bundle, framework_pt framework);
+FRAMEWORK_EXPORT celix_status_t bundle_getFramework(bundle_pt bundle, framework_pt *framework);
 
 #endif /* BUNDLE_H_ */

Modified: incubator/celix/trunk/framework/public/include/bundle_activator.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_activator.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_activator.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_activator.h Wed Jun 12 19:08:50 2013
@@ -54,7 +54,7 @@
  * 		- Any other status code will mark the bundle as stopped and the framework will remove this
  * 		  bundle's listeners, unregister all services, and release all services used by this bundle.
  */
-ACTIVATOR_EXPORT celix_status_t bundleActivator_create(bundle_context_t context, void **userData);
+ACTIVATOR_EXPORT celix_status_t bundleActivator_create(bundle_context_pt context, void **userData);
 
 /**
  * Called when this bundle is started so the Framework can perform the bundle-specific activities necessary
@@ -72,7 +72,7 @@ ACTIVATOR_EXPORT celix_status_t bundleAc
  * 		- Any other status code will mark the bundle as stopped and the framework will remove this
  * 		  bundle's listeners, unregister all services, and release all services used by this bundle.
  */
-ACTIVATOR_EXPORT celix_status_t bundleActivator_start(void * userData, bundle_context_t context);
+ACTIVATOR_EXPORT celix_status_t bundleActivator_start(void * userData, bundle_context_pt context);
 
 /**
  * Called when this bundle is stopped so the Framework can perform the bundle-specific activities necessary
@@ -91,7 +91,7 @@ ACTIVATOR_EXPORT celix_status_t bundleAc
  * 		- Any other status code will mark the bundle as stopped and the framework will remove this
  * 		  bundle's listeners, unregister all services, and release all services used by this bundle.
  */
-ACTIVATOR_EXPORT celix_status_t bundleActivator_stop(void * userData, bundle_context_t context);
+ACTIVATOR_EXPORT celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context);
 
 /**
  * Called when this bundle is stopped so the bundle can destroy the instance of its activator. In general, this
@@ -108,7 +108,7 @@ ACTIVATOR_EXPORT celix_status_t bundleAc
  * 		- Any other status code will mark the bundle as stopped and the framework will remove this
  * 		  bundle's listeners, unregister all services, and release all services used by this bundle.
  */
-ACTIVATOR_EXPORT celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context);
+ACTIVATOR_EXPORT celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context);
 
 #endif /* BUNDLE_ACTIVATOR_H_ */
 

Modified: incubator/celix/trunk/framework/public/include/bundle_archive.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_archive.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_archive.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_archive.h Wed Jun 12 19:08:50 2013
@@ -35,31 +35,31 @@
 #include "celixbool.h"
 #include "framework_exports.h"
 
-typedef struct bundleArchive * bundle_archive_t;
+typedef struct bundleArchive * bundle_archive_pt;
 
-celix_status_t bundleArchive_create(char * archiveRoot, long id, char * location, char *inputFile, apr_pool_t *mp, bundle_archive_t *bundle_archive);
-celix_status_t bundleArchive_createSystemBundleArchive(apr_pool_t *mp, bundle_archive_t *bundle_archive);
-celix_status_t bundleArchive_recreate(char * archiveRoot, apr_pool_t *mp, bundle_archive_t *bundle_archive);
-
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getId(bundle_archive_t archive, long *id);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getLocation(bundle_archive_t archive, char **location);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getArchiveRoot(bundle_archive_t archive, char **archiveRoot);
-
-FRAMEWORK_EXPORT celix_status_t bundleArchive_revise(bundle_archive_t archive, char * location, char *inputFile);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_rollbackRevise(bundle_archive_t archive, bool *rolledback);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getRevision(bundle_archive_t archive, long revNr, bundle_revision_t *revision);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getCurrentRevision(bundle_archive_t archive, bundle_revision_t *revision);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getCurrentRevisionNumber(bundle_archive_t archive, long *revisionNumber);
-
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getRefreshCount(bundle_archive_t archive, long *refreshCount);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_setRefreshCount(bundle_archive_t archive);
-
-FRAMEWORK_EXPORT celix_status_t bundleArchive_close(bundle_archive_t archive);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_closeAndDelete(bundle_archive_t archive);
-
-FRAMEWORK_EXPORT celix_status_t bundleArchive_setLastModified(bundle_archive_t archive, time_t lastModifiedTime);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getLastModified(bundle_archive_t archive, time_t *lastModified);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_setPersistentState(bundle_archive_t archive, bundle_state_e state);
-FRAMEWORK_EXPORT celix_status_t bundleArchive_getPersistentState(bundle_archive_t archive, bundle_state_e *state);
+celix_status_t bundleArchive_create(char * archiveRoot, long id, char * location, char *inputFile, apr_pool_t *mp, bundle_archive_pt *bundle_archive);
+celix_status_t bundleArchive_createSystemBundleArchive(apr_pool_t *mp, bundle_archive_pt *bundle_archive);
+celix_status_t bundleArchive_recreate(char * archiveRoot, apr_pool_t *mp, bundle_archive_pt *bundle_archive);
+
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getId(bundle_archive_pt archive, long *id);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getLocation(bundle_archive_pt archive, char **location);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getArchiveRoot(bundle_archive_pt archive, char **archiveRoot);
+
+FRAMEWORK_EXPORT celix_status_t bundleArchive_revise(bundle_archive_pt archive, char * location, char *inputFile);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_rollbackRevise(bundle_archive_pt archive, bool *rolledback);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getRevision(bundle_archive_pt archive, long revNr, bundle_revision_pt *revision);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getCurrentRevision(bundle_archive_pt archive, bundle_revision_pt *revision);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getCurrentRevisionNumber(bundle_archive_pt archive, long *revisionNumber);
+
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getRefreshCount(bundle_archive_pt archive, long *refreshCount);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_setRefreshCount(bundle_archive_pt archive);
+
+FRAMEWORK_EXPORT celix_status_t bundleArchive_close(bundle_archive_pt archive);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_closeAndDelete(bundle_archive_pt archive);
+
+FRAMEWORK_EXPORT celix_status_t bundleArchive_setLastModified(bundle_archive_pt archive, time_t lastModifiedTime);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getLastModified(bundle_archive_pt archive, time_t *lastModified);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_setPersistentState(bundle_archive_pt archive, bundle_state_e state);
+FRAMEWORK_EXPORT celix_status_t bundleArchive_getPersistentState(bundle_archive_pt archive, bundle_state_e *state);
 
 #endif /* BUNDLE_ARCHIVE_H_ */

Modified: incubator/celix/trunk/framework/public/include/bundle_context.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_context.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_context.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_context.h Wed Jun 12 19:08:50 2013
@@ -32,7 +32,7 @@
  * grant access to other methods so that this bundle can interact with the
  * Framework.
  */
-typedef struct bundleContext *bundle_context_t;
+typedef struct bundleContext *bundle_context_pt;
 
 #include "service_factory.h"
 #include "service_listener.h"
@@ -40,36 +40,36 @@ typedef struct bundleContext *bundle_con
 #include "properties.h"
 #include "array_list.h"
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_create(framework_t framework, bundle_t bundle, bundle_context_t *bundle_context);
-FRAMEWORK_EXPORT celix_status_t bundleContext_destroy(bundle_context_t context);
+FRAMEWORK_EXPORT celix_status_t bundleContext_create(framework_pt framework, bundle_pt bundle, bundle_context_pt *bundle_context);
+FRAMEWORK_EXPORT celix_status_t bundleContext_destroy(bundle_context_pt context);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_getBundle(bundle_context_t context, bundle_t *bundle);
-FRAMEWORK_EXPORT celix_status_t bundleContext_getFramework(bundle_context_t context, framework_t *framework);
-FRAMEWORK_EXPORT celix_status_t bundleContext_getMemoryPool(bundle_context_t context, apr_pool_t **memory_pool);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getBundle(bundle_context_pt context, bundle_pt *bundle);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getFramework(bundle_context_pt context, framework_pt *framework);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getMemoryPool(bundle_context_pt context, apr_pool_t **memory_pool);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_installBundle(bundle_context_t context, char * location, bundle_t *bundle);
-FRAMEWORK_EXPORT celix_status_t bundleContext_installBundle2(bundle_context_t context, char * location, char *inputFile, bundle_t *bundle);
+FRAMEWORK_EXPORT celix_status_t bundleContext_installBundle(bundle_context_pt context, char * location, bundle_pt *bundle);
+FRAMEWORK_EXPORT celix_status_t bundleContext_installBundle2(bundle_context_pt context, char * location, char *inputFile, bundle_pt *bundle);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_registerService(bundle_context_t context, char * serviceName, void * svcObj,
-        properties_t properties, service_registration_t *service_registration);
-FRAMEWORK_EXPORT celix_status_t bundleContext_registerServiceFactory(bundle_context_t context, char * serviceName, service_factory_t factory,
-        properties_t properties, service_registration_t *service_registration);
+FRAMEWORK_EXPORT celix_status_t bundleContext_registerService(bundle_context_pt context, char * serviceName, void * svcObj,
+        properties_pt properties, service_registration_pt *service_registration);
+FRAMEWORK_EXPORT celix_status_t bundleContext_registerServiceFactory(bundle_context_pt context, char * serviceName, service_factory_pt factory,
+        properties_pt properties, service_registration_pt *service_registration);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_getServiceReferences(bundle_context_t context, const char * serviceName, char * filter, array_list_t *service_references);
-FRAMEWORK_EXPORT celix_status_t bundleContext_getServiceReference(bundle_context_t context, char * serviceName, service_reference_t *service_reference);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getServiceReferences(bundle_context_pt context, const char * serviceName, char * filter, array_list_pt *service_references);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getServiceReference(bundle_context_pt context, char * serviceName, service_reference_pt *service_reference);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_getService(bundle_context_t context, service_reference_t reference, void **service_instance);
-FRAMEWORK_EXPORT celix_status_t bundleContext_ungetService(bundle_context_t context, service_reference_t reference, bool *result);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getService(bundle_context_pt context, service_reference_pt reference, void **service_instance);
+FRAMEWORK_EXPORT celix_status_t bundleContext_ungetService(bundle_context_pt context, service_reference_pt reference, bool *result);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_getBundles(bundle_context_t context, array_list_t *bundles);
-FRAMEWORK_EXPORT celix_status_t bundleContext_getBundleById(bundle_context_t context, long id, bundle_t *bundle);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getBundles(bundle_context_pt context, array_list_pt *bundles);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getBundleById(bundle_context_pt context, long id, bundle_pt *bundle);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_addServiceListener(bundle_context_t context, service_listener_t listener, char * filter);
-FRAMEWORK_EXPORT celix_status_t bundleContext_removeServiceListener(bundle_context_t context, service_listener_t listener);
+FRAMEWORK_EXPORT celix_status_t bundleContext_addServiceListener(bundle_context_pt context, service_listener_pt listener, char * filter);
+FRAMEWORK_EXPORT celix_status_t bundleContext_removeServiceListener(bundle_context_pt context, service_listener_pt listener);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_addBundleListener(bundle_context_t context, bundle_listener_t listener);
-FRAMEWORK_EXPORT celix_status_t bundleContext_removeBundleListener(bundle_context_t context, bundle_listener_t listener);
+FRAMEWORK_EXPORT celix_status_t bundleContext_addBundleListener(bundle_context_pt context, bundle_listener_pt listener);
+FRAMEWORK_EXPORT celix_status_t bundleContext_removeBundleListener(bundle_context_pt context, bundle_listener_pt listener);
 
-FRAMEWORK_EXPORT celix_status_t bundleContext_getProperty(bundle_context_t context, const char *name, char **value);
+FRAMEWORK_EXPORT celix_status_t bundleContext_getProperty(bundle_context_pt context, const char *name, char **value);
 
 #endif /* BUNDLE_CONTEXT_H_ */

Modified: incubator/celix/trunk/framework/public/include/bundle_event.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_event.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_event.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_event.h Wed Jun 12 19:08:50 2013
@@ -42,13 +42,13 @@ enum bundle_event_type
 };
 
 typedef enum bundle_event_type bundle_event_type_e;
-typedef struct bundle_event *bundle_event_t;
+typedef struct bundle_event *bundle_event_pt;
 
 #include "service_reference.h"
 #include "bundle.h"
 
 struct bundle_event {
-	bundle_t bundle;
+	bundle_pt bundle;
 	bundle_event_type_e type;
 };
 

Modified: incubator/celix/trunk/framework/public/include/bundle_listener.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_listener.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_listener.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_listener.h Wed Jun 12 19:08:50 2013
@@ -31,7 +31,7 @@
 
 #include <apr_general.h>
 
-typedef struct bundle_listener *bundle_listener_t;
+typedef struct bundle_listener *bundle_listener_pt;
 
 #include "celix_errno.h"
 #include "bundle_event.h"
@@ -39,7 +39,7 @@ typedef struct bundle_listener *bundle_l
 struct bundle_listener {
 	apr_pool_t *pool;
 	void * handle;
-	celix_status_t (*bundleChanged)(void * listener, bundle_event_t event);
+	celix_status_t (*bundleChanged)(void * listener, bundle_event_pt event);
 };
 
 

Modified: incubator/celix/trunk/framework/public/include/bundle_revision.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle_revision.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle_revision.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle_revision.h Wed Jun 12 19:08:50 2013
@@ -35,14 +35,14 @@
 #include "celix_errno.h"
 
 /**
- * Typedef for bundle_revision_t.
+ * Typedef for bundle_revision_pt.
  *
  * A bundle revision represents the content of a bundle. A revision is associated with a bundle archive.
  * An archive can have multiple revisions, each update of a bundle results in a new one.
  *
  * In a revision the content of a bundle (ZIP file) is extracted to a specified location inside the archive.
  */
-typedef struct bundleRevision * bundle_revision_t;
+typedef struct bundleRevision * bundle_revision_pt;
 
 /**
  * Creates a new revision for the given inputFile or location.
@@ -60,7 +60,7 @@ typedef struct bundleRevision * bundle_r
  * 		- CELIX_SUCCESS when no errors are encountered.
  * 		- CELIX_ENOMEM If allocating memory for <code>bundle_revision</code> failed.
  */
-celix_status_t bundleRevision_create(apr_pool_t *pool, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_t *bundle_revision);
+celix_status_t bundleRevision_create(apr_pool_t *pool, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_pt *bundle_revision);
 
 /**
  * Retrieves the revision number of the given revision.
@@ -72,7 +72,7 @@ celix_status_t bundleRevision_create(apr
  * 		- CELIX_SUCCESS when no errors are encountered.
  * 		- CELIX_ILLEGAL_ARGUMENT If <code>revision</code> is illegal.
  */
-celix_status_t bundleRevision_getNumber(bundle_revision_t revision, long *revisionNr);
+celix_status_t bundleRevision_getNumber(bundle_revision_pt revision, long *revisionNr);
 
 /**
  * Retrieves the location of the given revision.
@@ -84,7 +84,7 @@ celix_status_t bundleRevision_getNumber(
  * 		- CELIX_SUCCESS when no errors are encountered.
  * 		- CELIX_ILLEGAL_ARGUMENT If <code>revision</code> is illegal.
  */
-celix_status_t bundleRevision_getLocation(bundle_revision_t revision, char **location);
+celix_status_t bundleRevision_getLocation(bundle_revision_pt revision, char **location);
 
 /**
  * Retrieves the root of the given revision.
@@ -96,7 +96,7 @@ celix_status_t bundleRevision_getLocatio
  * 		- CELIX_SUCCESS when no errors are encountered.
  * 		- CELIX_ILLEGAL_ARGUMENT If <code>revision</code> is illegal.
  */
-celix_status_t bundleRevision_getRoot(bundle_revision_t revision, char **root);
+celix_status_t bundleRevision_getRoot(bundle_revision_pt revision, char **root);
 
 #endif /* BUNDLE_REVISION_H_ */
 

Modified: incubator/celix/trunk/framework/public/include/capability.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/capability.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/capability.h (original)
+++ incubator/celix/trunk/framework/public/include/capability.h Wed Jun 12 19:08:50 2013
@@ -27,14 +27,14 @@
 #ifndef CAPABILITY_H_
 #define CAPABILITY_H_
 
-typedef struct capability *capability_t;
+typedef struct capability *capability_pt;
 
 #include "hash_map.h"
 #include "module.h"
 
-celix_status_t capability_create(apr_pool_t *pool, module_t module, hash_map_t directives, hash_map_t attributes, capability_t *capability);
-celix_status_t capability_getServiceName(capability_t capability, char **serviceName);
-celix_status_t capability_getVersion(capability_t capability, version_t *version);
-celix_status_t capability_getModule(capability_t capability, module_t *module);
+celix_status_t capability_create(apr_pool_t *pool, module_pt module, hash_map_pt directives, hash_map_pt attributes, capability_pt *capability);
+celix_status_t capability_getServiceName(capability_pt capability, char **serviceName);
+celix_status_t capability_getVersion(capability_pt capability, version_pt *version);
+celix_status_t capability_getModule(capability_pt capability, module_pt *module);
 
 #endif /* CAPABILITY_H_ */

Modified: incubator/celix/trunk/framework/public/include/filter.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/filter.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/filter.h (original)
+++ incubator/celix/trunk/framework/public/include/filter.h Wed Jun 12 19:08:50 2013
@@ -33,13 +33,13 @@
 #include "properties.h"
 #include "celixbool.h"
 
-typedef struct filter * filter_t;
+typedef struct filter * filter_pt;
 
-filter_t filter_create(char * filterString, apr_pool_t *pool);
-void filter_destroy(filter_t filter);
+filter_pt filter_create(char * filterString, apr_pool_t *pool);
+void filter_destroy(filter_pt filter);
 
-celix_status_t filter_match(filter_t filter, properties_t properties, bool *result);
+celix_status_t filter_match(filter_pt filter, properties_pt properties, bool *result);
 
-celix_status_t filter_getString(filter_t filter, char **filterStr);
+celix_status_t filter_getString(filter_pt filter, char **filterStr);
 
 #endif /* FILTER_H_ */

Modified: incubator/celix/trunk/framework/public/include/framework.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/framework.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/framework.h (original)
+++ incubator/celix/trunk/framework/public/include/framework.h Wed Jun 12 19:08:50 2013
@@ -27,8 +27,8 @@
 #ifndef FRAMEWORK_H_
 #define FRAMEWORK_H_
 
-typedef struct activator * ACTIVATOR;
-typedef struct framework * framework_t;
+typedef struct activator * activator_pt;
+typedef struct framework * framework_pt;
 
 #include "manifest.h"
 #include "wire.h"
@@ -43,61 +43,61 @@ typedef struct framework * framework_t;
 #include "bundle_context.h"
 #include "framework_exports.h"
 
-FRAMEWORK_EXPORT celix_status_t framework_create(framework_t *framework, apr_pool_t *memoryPool, properties_t config);
-FRAMEWORK_EXPORT celix_status_t framework_destroy(framework_t framework);
+FRAMEWORK_EXPORT celix_status_t framework_create(framework_pt *framework, apr_pool_t *memoryPool, properties_pt config);
+FRAMEWORK_EXPORT celix_status_t framework_destroy(framework_pt framework);
 
-FRAMEWORK_EXPORT celix_status_t fw_init(framework_t framework);
-FRAMEWORK_EXPORT celix_status_t framework_start(framework_t framework);
-FRAMEWORK_EXPORT void framework_stop(framework_t framework);
+FRAMEWORK_EXPORT celix_status_t fw_init(framework_pt framework);
+FRAMEWORK_EXPORT celix_status_t framework_start(framework_pt framework);
+FRAMEWORK_EXPORT void framework_stop(framework_pt framework);
 
-FRAMEWORK_EXPORT celix_status_t fw_getProperty(framework_t framework, const char *name, char **value);
+FRAMEWORK_EXPORT celix_status_t fw_getProperty(framework_pt framework, const char *name, char **value);
 
-FRAMEWORK_EXPORT celix_status_t fw_installBundle(framework_t framework, bundle_t * bundle, char * location, char *inputFile);
-FRAMEWORK_EXPORT celix_status_t fw_uninstallBundle(framework_t framework, bundle_t bundle);
+FRAMEWORK_EXPORT celix_status_t fw_installBundle(framework_pt framework, bundle_pt * bundle, char * location, char *inputFile);
+FRAMEWORK_EXPORT celix_status_t fw_uninstallBundle(framework_pt framework, bundle_pt bundle);
 
-FRAMEWORK_EXPORT celix_status_t framework_getBundleEntry(framework_t framework, bundle_t bundle, char *name, apr_pool_t *pool, char **entry);
+FRAMEWORK_EXPORT celix_status_t framework_getBundleEntry(framework_pt framework, bundle_pt bundle, char *name, apr_pool_t *pool, char **entry);
 
-FRAMEWORK_EXPORT celix_status_t fw_startBundle(framework_t framework, bundle_t bundle, int options);
-FRAMEWORK_EXPORT celix_status_t framework_updateBundle(framework_t framework, bundle_t bundle, char *inputFile);
-FRAMEWORK_EXPORT celix_status_t fw_stopBundle(framework_t framework, bundle_t bundle, bool record);
+FRAMEWORK_EXPORT celix_status_t fw_startBundle(framework_pt framework, bundle_pt bundle, int options);
+FRAMEWORK_EXPORT celix_status_t framework_updateBundle(framework_pt framework, bundle_pt bundle, char *inputFile);
+FRAMEWORK_EXPORT celix_status_t fw_stopBundle(framework_pt framework, bundle_pt bundle, bool record);
 
-FRAMEWORK_EXPORT celix_status_t fw_registerService(framework_t framework, service_registration_t * registration, bundle_t bundle, char * serviceName, void * svcObj, properties_t properties);
-FRAMEWORK_EXPORT celix_status_t fw_registerServiceFactory(framework_t framework, service_registration_t * registration, bundle_t bundle, char * serviceName, service_factory_t factory, properties_t properties);
-FRAMEWORK_EXPORT void fw_unregisterService(service_registration_t registration);
+FRAMEWORK_EXPORT celix_status_t fw_registerService(framework_pt framework, service_registration_pt * registration, bundle_pt bundle, char * serviceName, void * svcObj, properties_pt properties);
+FRAMEWORK_EXPORT celix_status_t fw_registerServiceFactory(framework_pt framework, service_registration_pt * registration, bundle_pt bundle, char * serviceName, service_factory_pt factory, properties_pt properties);
+FRAMEWORK_EXPORT void fw_unregisterService(service_registration_pt registration);
 
-FRAMEWORK_EXPORT celix_status_t fw_getServiceReferences(framework_t framework, array_list_t *references, bundle_t bundle, const char * serviceName, char * filter);
-FRAMEWORK_EXPORT void * fw_getService(framework_t framework, bundle_t bundle, service_reference_t reference);
-FRAMEWORK_EXPORT bool framework_ungetService(framework_t framework, bundle_t bundle, service_reference_t reference);
-FRAMEWORK_EXPORT celix_status_t fw_getBundleRegisteredServices(framework_t framework, apr_pool_t *pool, bundle_t bundle, array_list_t *services);
-FRAMEWORK_EXPORT celix_status_t fw_getBundleServicesInUse(framework_t framework, bundle_t bundle, array_list_t *services);
+FRAMEWORK_EXPORT celix_status_t fw_getServiceReferences(framework_pt framework, array_list_pt *references, bundle_pt bundle, const char * serviceName, char * filter);
+FRAMEWORK_EXPORT void * fw_getService(framework_pt framework, bundle_pt bundle, service_reference_pt reference);
+FRAMEWORK_EXPORT bool framework_ungetService(framework_pt framework, bundle_pt bundle, service_reference_pt reference);
+FRAMEWORK_EXPORT celix_status_t fw_getBundleRegisteredServices(framework_pt framework, apr_pool_t *pool, bundle_pt bundle, array_list_pt *services);
+FRAMEWORK_EXPORT celix_status_t fw_getBundleServicesInUse(framework_pt framework, bundle_pt bundle, array_list_pt *services);
 
-FRAMEWORK_EXPORT void fw_addServiceListener(framework_t framework, bundle_t bundle, service_listener_t listener, char * filter);
-FRAMEWORK_EXPORT void fw_removeServiceListener(framework_t framework, bundle_t bundle, service_listener_t listener);
+FRAMEWORK_EXPORT void fw_addServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener, char * filter);
+FRAMEWORK_EXPORT void fw_removeServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener);
 
-FRAMEWORK_EXPORT celix_status_t fw_addBundleListener(framework_t framework, bundle_t bundle, bundle_listener_t listener);
-FRAMEWORK_EXPORT celix_status_t fw_removeBundleListener(framework_t framework, bundle_t bundle, bundle_listener_t listener);
+FRAMEWORK_EXPORT celix_status_t fw_addBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener);
+FRAMEWORK_EXPORT celix_status_t fw_removeBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener);
 
-FRAMEWORK_EXPORT void fw_serviceChanged(framework_t framework, service_event_type_e eventType, service_registration_t registration, properties_t oldprops);
+FRAMEWORK_EXPORT void fw_serviceChanged(framework_pt framework, service_event_type_e eventType, service_registration_pt registration, properties_pt oldprops);
 
-FRAMEWORK_EXPORT celix_status_t fw_isServiceAssignable(framework_t fw, bundle_t requester, service_reference_t reference, bool *assignable);
+FRAMEWORK_EXPORT celix_status_t fw_isServiceAssignable(framework_pt fw, bundle_pt requester, service_reference_pt reference, bool *assignable);
 
-//bundle_archive_t fw_createArchive(long id, char * location);
-//void revise(bundle_archive_t archive, char * location);
-FRAMEWORK_EXPORT celix_status_t getManifest(bundle_archive_t archive, apr_pool_t *pool, MANIFEST *manifest);
+//bundle_archive_pt fw_createArchive(long id, char * location);
+//void revise(bundle_archive_pt archive, char * location);
+FRAMEWORK_EXPORT celix_status_t getManifest(bundle_archive_pt archive, apr_pool_t *pool, manifest_pt *manifest);
 
-FRAMEWORK_EXPORT bundle_t findBundle(bundle_context_t context);
-FRAMEWORK_EXPORT service_registration_t findRegistration(service_reference_t reference);
+FRAMEWORK_EXPORT bundle_pt findBundle(bundle_context_pt context);
+FRAMEWORK_EXPORT service_registration_pt findRegistration(service_reference_pt reference);
 
-FRAMEWORK_EXPORT service_reference_t listToArray(array_list_t list);
-FRAMEWORK_EXPORT celix_status_t framework_markResolvedModules(framework_t framework, hash_map_t wires);
+FRAMEWORK_EXPORT service_reference_pt listToArray(array_list_pt list);
+FRAMEWORK_EXPORT celix_status_t framework_markResolvedModules(framework_pt framework, hash_map_pt wires);
 
-FRAMEWORK_EXPORT celix_status_t framework_waitForStop(framework_t framework);
+FRAMEWORK_EXPORT celix_status_t framework_waitForStop(framework_pt framework);
 
-FRAMEWORK_EXPORT array_list_t framework_getBundles(framework_t framework);
-FRAMEWORK_EXPORT bundle_t framework_getBundle(framework_t framework, char * location);
-FRAMEWORK_EXPORT bundle_t framework_getBundleById(framework_t framework, long id);
+FRAMEWORK_EXPORT array_list_pt framework_getBundles(framework_pt framework);
+FRAMEWORK_EXPORT bundle_pt framework_getBundle(framework_pt framework, char * location);
+FRAMEWORK_EXPORT bundle_pt framework_getBundleById(framework_pt framework, long id);
 
-FRAMEWORK_EXPORT celix_status_t framework_getMemoryPool(framework_t framework, apr_pool_t **pool);
-FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(framework_t framework, bundle_t *bundle);
+FRAMEWORK_EXPORT celix_status_t framework_getMemoryPool(framework_pt framework, apr_pool_t **pool);
+FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(framework_pt framework, bundle_pt *bundle);
 
 #endif /* FRAMEWORK_H_ */

Modified: incubator/celix/trunk/framework/public/include/listener_hook_service.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/listener_hook_service.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/listener_hook_service.h (original)
+++ incubator/celix/trunk/framework/public/include/listener_hook_service.h Wed Jun 12 19:08:50 2013
@@ -28,24 +28,24 @@
 #define LISTENER_HOOK_SERVICE_H_
 
 
-typedef struct listener_hook *listener_hook_t;
-typedef struct listener_hook_info *listener_hook_info_t;
-typedef struct listener_hook_service *listener_hook_service_t;
+typedef struct listener_hook *listener_hook_pt;
+typedef struct listener_hook_info *listener_hook_info_pt;
+typedef struct listener_hook_service *listener_hook_service_pt;
 
 #include "bundle_context.h"
 
 #define listener_hook_service_name "listener_hook_service"
 
 struct listener_hook_info {
-	bundle_context_t context;
+	bundle_context_pt context;
 	char *filter;
 	bool removed;
 };
 
 struct listener_hook_service {
 	void *handle;
-	celix_status_t (*added)(void *hook, array_list_t listeners);
-	celix_status_t (*removed)(void *hook, array_list_t listeners);
+	celix_status_t (*added)(void *hook, array_list_pt listeners);
+	celix_status_t (*removed)(void *hook, array_list_pt listeners);
 };
 
 #endif /* LISTENER_HOOK_SERVICE_H_ */

Modified: incubator/celix/trunk/framework/public/include/manifest.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/manifest.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/manifest.h (original)
+++ incubator/celix/trunk/framework/public/include/manifest.h Wed Jun 12 19:08:50 2013
@@ -34,22 +34,22 @@
 
 struct manifest {
 	apr_pool_t *pool;
-	properties_t mainAttributes;
-	hash_map_t attributes;
+	properties_pt mainAttributes;
+	hash_map_pt attributes;
 };
 
-typedef struct manifest * MANIFEST;
+typedef struct manifest * manifest_pt;
 
-celix_status_t manifest_create(apr_pool_t *pool, MANIFEST *manifest);
-celix_status_t manifest_createFromFile(apr_pool_t *pool, char *filename, MANIFEST *manifest);
+celix_status_t manifest_create(apr_pool_t *pool, manifest_pt *manifest);
+celix_status_t manifest_createFromFile(apr_pool_t *pool, char *filename, manifest_pt *manifest);
 
-void manifest_clear(MANIFEST manifest);
-properties_t manifest_getMainAttributes(MANIFEST manifest);
-celix_status_t manifest_getEntries(MANIFEST manifest, hash_map_t *map);
+void manifest_clear(manifest_pt manifest);
+properties_pt manifest_getMainAttributes(manifest_pt manifest);
+celix_status_t manifest_getEntries(manifest_pt manifest, hash_map_pt *map);
 
-celix_status_t manifest_read(MANIFEST manifest, char *filename);
-void manifest_write(MANIFEST manifest, char * filename);
+celix_status_t manifest_read(manifest_pt manifest, char *filename);
+void manifest_write(manifest_pt manifest, char * filename);
 
-char * manifest_getValue(MANIFEST manifest, const char * name);
+char * manifest_getValue(manifest_pt manifest, const char * name);
 
 #endif /* MANIFEST_H_ */

Modified: incubator/celix/trunk/framework/public/include/module.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/module.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/module.h (original)
+++ incubator/celix/trunk/framework/public/include/module.h Wed Jun 12 19:08:50 2013
@@ -27,7 +27,7 @@
 #ifndef MODULE_H_
 #define MODULE_H_
 
-typedef struct module *module_t;
+typedef struct module *module_pt;
 
 #include "celixbool.h"
 #include "linkedlist.h"
@@ -37,35 +37,35 @@ typedef struct module *module_t;
 #include "bundle.h"
 #include "framework_exports.h"
 
-module_t module_create(MANIFEST headerMap, char * moduleId, bundle_t bundle);
-module_t module_createFrameworkModule(bundle_t bundle);
-void module_destroy(module_t module);
+module_pt module_create(manifest_pt headerMap, char * moduleId, bundle_pt bundle);
+module_pt module_createFrameworkModule(bundle_pt bundle);
+void module_destroy(module_pt module);
 
 FRAMEWORK_EXPORT unsigned int module_hash(void * module);
 FRAMEWORK_EXPORT int module_equals(void * module, void * compare);
 
-FRAMEWORK_EXPORT wire_t module_getWire(module_t module, char * serviceName);
+FRAMEWORK_EXPORT wire_pt module_getWire(module_pt module, char * serviceName);
 
-FRAMEWORK_EXPORT version_t module_getVersion(module_t module);
-FRAMEWORK_EXPORT celix_status_t module_getSymbolicName(module_t module, char **symbolicName);
-FRAMEWORK_EXPORT char * module_getId(module_t module);
-FRAMEWORK_EXPORT linked_list_t module_getWires(module_t module);
-FRAMEWORK_EXPORT void module_setWires(module_t module, linked_list_t wires);
-FRAMEWORK_EXPORT bool module_isResolved(module_t module);
-FRAMEWORK_EXPORT void module_setResolved(module_t module);
-FRAMEWORK_EXPORT bundle_t module_getBundle(module_t module);
-
-FRAMEWORK_EXPORT linked_list_t module_getRequirements(module_t module);
-FRAMEWORK_EXPORT linked_list_t module_getCapabilities(module_t module);
-
-FRAMEWORK_EXPORT array_list_t module_getDependentImporters(module_t module);
-FRAMEWORK_EXPORT void module_addDependentImporter(module_t module, module_t importer);
-FRAMEWORK_EXPORT void module_removeDependentImporter(module_t module, module_t importer);
-
-FRAMEWORK_EXPORT array_list_t module_getDependentRequirers(module_t module);
-FRAMEWORK_EXPORT void module_addDependentRequirer(module_t module, module_t requirer);
-FRAMEWORK_EXPORT void module_removeDependentRequirer(module_t module, module_t requirer);
+FRAMEWORK_EXPORT version_pt module_getVersion(module_pt module);
+FRAMEWORK_EXPORT celix_status_t module_getSymbolicName(module_pt module, char **symbolicName);
+FRAMEWORK_EXPORT char * module_getId(module_pt module);
+FRAMEWORK_EXPORT linked_list_pt module_getWires(module_pt module);
+FRAMEWORK_EXPORT void module_setWires(module_pt module, linked_list_pt wires);
+FRAMEWORK_EXPORT bool module_isResolved(module_pt module);
+FRAMEWORK_EXPORT void module_setResolved(module_pt module);
+FRAMEWORK_EXPORT bundle_pt module_getBundle(module_pt module);
+
+FRAMEWORK_EXPORT linked_list_pt module_getRequirements(module_pt module);
+FRAMEWORK_EXPORT linked_list_pt module_getCapabilities(module_pt module);
+
+FRAMEWORK_EXPORT array_list_pt module_getDependentImporters(module_pt module);
+FRAMEWORK_EXPORT void module_addDependentImporter(module_pt module, module_pt importer);
+FRAMEWORK_EXPORT void module_removeDependentImporter(module_pt module, module_pt importer);
+
+FRAMEWORK_EXPORT array_list_pt module_getDependentRequirers(module_pt module);
+FRAMEWORK_EXPORT void module_addDependentRequirer(module_pt module, module_pt requirer);
+FRAMEWORK_EXPORT void module_removeDependentRequirer(module_pt module, module_pt requirer);
 
-FRAMEWORK_EXPORT array_list_t module_getDependents(module_t module);
+FRAMEWORK_EXPORT array_list_pt module_getDependents(module_pt module);
 
 #endif /* MODULE_H_ */

Modified: incubator/celix/trunk/framework/public/include/properties.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/properties.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/properties.h (original)
+++ incubator/celix/trunk/framework/public/include/properties.h Wed Jun 12 19:08:50 2013
@@ -30,15 +30,15 @@
 #include "hash_map.h"
 #include "framework_exports.h"
 
-typedef hash_map_t properties_t;
+typedef hash_map_pt properties_pt;
 
-FRAMEWORK_EXPORT properties_t properties_create(void);
-FRAMEWORK_EXPORT void properties_destroy(properties_t properties);
-FRAMEWORK_EXPORT properties_t properties_load(char * filename);
-FRAMEWORK_EXPORT void properties_store(properties_t properties, char * file, char * header);
+FRAMEWORK_EXPORT properties_pt properties_create(void);
+FRAMEWORK_EXPORT void properties_destroy(properties_pt properties);
+FRAMEWORK_EXPORT properties_pt properties_load(char * filename);
+FRAMEWORK_EXPORT void properties_store(properties_pt properties, char * file, char * header);
 
-FRAMEWORK_EXPORT char * properties_get(properties_t properties, char * key);
-FRAMEWORK_EXPORT char * properties_getWithDefault(properties_t properties, char * key, char * defaultValue);
-FRAMEWORK_EXPORT char * properties_set(properties_t properties, char * key, char * value);
+FRAMEWORK_EXPORT char * properties_get(properties_pt properties, char * key);
+FRAMEWORK_EXPORT char * properties_getWithDefault(properties_pt properties, char * key, char * defaultValue);
+FRAMEWORK_EXPORT char * properties_set(properties_pt properties, char * key, char * value);
 
 #endif /* PROPERTIES_H_ */

Modified: incubator/celix/trunk/framework/public/include/requirement.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/requirement.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/requirement.h (original)
+++ incubator/celix/trunk/framework/public/include/requirement.h Wed Jun 12 19:08:50 2013
@@ -27,16 +27,16 @@
 #ifndef REQUIREMENT_H_
 #define REQUIREMENT_H_
 
-typedef struct requirement *requirement_t;
+typedef struct requirement *requirement_pt;
 
 #include "capability.h"
 #include "hash_map.h"
 #include "version_range.h"
 
-celix_status_t requirement_create(apr_pool_t *pool, hash_map_t directives, hash_map_t attributes, requirement_t *requirement);
-celix_status_t requirement_getVersionRange(requirement_t requirement, version_range_t *range);
-celix_status_t requirement_getTargetName(requirement_t requirement, char **targetName);
+celix_status_t requirement_create(apr_pool_t *pool, hash_map_pt directives, hash_map_pt attributes, requirement_pt *requirement);
+celix_status_t requirement_getVersionRange(requirement_pt requirement, version_range_pt *range);
+celix_status_t requirement_getTargetName(requirement_pt requirement, char **targetName);
 
-celix_status_t requirement_isSatisfied(requirement_t requirement, capability_t capability, bool *inRange);
+celix_status_t requirement_isSatisfied(requirement_pt requirement, capability_pt capability, bool *inRange);
 
 #endif /* REQUIREMENT_H_ */

Modified: incubator/celix/trunk/framework/public/include/service_event.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/service_event.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/service_event.h (original)
+++ incubator/celix/trunk/framework/public/include/service_event.h Wed Jun 12 19:08:50 2013
@@ -30,7 +30,7 @@
 #define SERVICE_EVENT_H_
 
 typedef enum serviceEventType service_event_type_e;
-typedef struct serviceEvent *service_event_t;
+typedef struct serviceEvent *service_event_pt;
 
 #include "service_reference.h"
 
@@ -43,7 +43,7 @@ enum serviceEventType
 };
 
 struct serviceEvent {
-	service_reference_t reference;
+	service_reference_pt reference;
 	service_event_type_e type;
 };
 

Modified: incubator/celix/trunk/framework/public/include/service_factory.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/service_factory.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/service_factory.h (original)
+++ incubator/celix/trunk/framework/public/include/service_factory.h Wed Jun 12 19:08:50 2013
@@ -29,7 +29,7 @@
 
 #include <apr_general.h>
 
-typedef struct service_factory * service_factory_t;
+typedef struct service_factory * service_factory_pt;
 
 #include "celix_errno.h"
 #include "service_registration.h"
@@ -37,8 +37,8 @@ typedef struct service_factory * service
 
 struct service_factory {
     void *factory;
-    celix_status_t (*getService)(void *factory, bundle_t bundle, service_registration_t registration, void **service);
-    celix_status_t (*ungetService)(void *factory, bundle_t bundle, service_registration_t registration);
+    celix_status_t (*getService)(void *factory, bundle_pt bundle, service_registration_pt registration, void **service);
+    celix_status_t (*ungetService)(void *factory, bundle_pt bundle, service_registration_pt registration);
 };
 
 

Modified: incubator/celix/trunk/framework/public/include/service_listener.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/service_listener.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/service_listener.h (original)
+++ incubator/celix/trunk/framework/public/include/service_listener.h Wed Jun 12 19:08:50 2013
@@ -31,7 +31,7 @@
 
 #include <apr_general.h>
 
-typedef struct serviceListener * service_listener_t;
+typedef struct serviceListener * service_listener_pt;
 
 #include "celix_errno.h"
 #include "service_event.h"
@@ -39,7 +39,7 @@ typedef struct serviceListener * service
 struct serviceListener {
 	apr_pool_t *pool;
 	void * handle;
-	celix_status_t (*serviceChanged)(void * listener, service_event_t event);
+	celix_status_t (*serviceChanged)(void * listener, service_event_pt event);
 };
 
 

Modified: incubator/celix/trunk/framework/public/include/service_reference.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/service_reference.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/service_reference.h (original)
+++ incubator/celix/trunk/framework/public/include/service_reference.h Wed Jun 12 19:08:50 2013
@@ -27,7 +27,7 @@
 #ifndef SERVICE_REFERENCE_H_
 #define SERVICE_REFERENCE_H_
 
-typedef struct serviceReference * service_reference_t;
+typedef struct serviceReference * service_reference_pt;
 
 #include "celixbool.h"
 #include "array_list.h"
@@ -35,17 +35,17 @@ typedef struct serviceReference * servic
 #include "bundle.h"
 #include "framework_exports.h"
 
-celix_status_t serviceReference_create(apr_pool_t *pool, bundle_t bundle, service_registration_t registration, service_reference_t *reference);
+celix_status_t serviceReference_create(apr_pool_t *pool, bundle_pt bundle, service_registration_pt registration, service_reference_pt *reference);
 
-FRAMEWORK_EXPORT celix_status_t serviceReference_invalidate(service_reference_t reference);
+FRAMEWORK_EXPORT celix_status_t serviceReference_invalidate(service_reference_pt reference);
 
-FRAMEWORK_EXPORT celix_status_t serviceReference_getServiceRegistration(service_reference_t reference, service_registration_t *registration);
-FRAMEWORK_EXPORT celix_status_t serviceReference_getBundle(service_reference_t reference, bundle_t *bundle);
+FRAMEWORK_EXPORT celix_status_t serviceReference_getServiceRegistration(service_reference_pt reference, service_registration_pt *registration);
+FRAMEWORK_EXPORT celix_status_t serviceReference_getBundle(service_reference_pt reference, bundle_pt *bundle);
 
-FRAMEWORK_EXPORT bool serviceReference_isAssignableTo(service_reference_t reference, bundle_t requester, char * serviceName);
+FRAMEWORK_EXPORT bool serviceReference_isAssignableTo(service_reference_pt reference, bundle_pt requester, char * serviceName);
 
-FRAMEWORK_EXPORT celix_status_t serviceReference_getUsingBundles(service_reference_t reference, apr_pool_t *pool, array_list_t *bundles);
-FRAMEWORK_EXPORT celix_status_t serviceReference_equals(service_reference_t reference, service_reference_t compareTo, bool *equal);
+FRAMEWORK_EXPORT celix_status_t serviceReference_getUsingBundles(service_reference_pt reference, apr_pool_t *pool, array_list_pt *bundles);
+FRAMEWORK_EXPORT celix_status_t serviceReference_equals(service_reference_pt reference, service_reference_pt compareTo, bool *equal);
 FRAMEWORK_EXPORT unsigned int serviceReference_hashCode(void *referenceP);
 FRAMEWORK_EXPORT int serviceReference_equals2(void *reference1, void *reference2);
 

Modified: incubator/celix/trunk/framework/public/include/service_registration.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/service_registration.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/service_registration.h (original)
+++ incubator/celix/trunk/framework/public/include/service_registration.h Wed Jun 12 19:08:50 2013
@@ -29,27 +29,27 @@
 
 #include "celixbool.h"
 
-typedef struct serviceRegistration * service_registration_t;
+typedef struct serviceRegistration * service_registration_pt;
 
 #include "service_registry.h"
 #include "array_list.h"
 #include "bundle.h"
 #include "framework_exports.h"
 
-service_registration_t serviceRegistration_create(apr_pool_t *pool, service_registry_t registry, bundle_t bundle, char * serviceName, long serviceId, void * serviceObject, properties_t dictionary);
-service_registration_t serviceRegistration_createServiceFactory(apr_pool_t *pool, service_registry_t registry, bundle_t bundle, char * serviceName, long serviceId, void * serviceObject, properties_t dictionary);
-void serviceRegistration_destroy(service_registration_t registration);
-
-FRAMEWORK_EXPORT bool serviceRegistration_isValid(service_registration_t registration);
-FRAMEWORK_EXPORT void serviceRegistration_invalidate(service_registration_t registration);
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_unregister(service_registration_t registration);
-
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getService(service_registration_t registration, bundle_t bundle, void **service);
-
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getProperties(service_registration_t registration, properties_t *properties);
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getRegistry(service_registration_t registration, service_registry_t *registry);
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getServiceReferences(service_registration_t registration, array_list_t *references);
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getBundle(service_registration_t registration, bundle_t *bundle);
-FRAMEWORK_EXPORT celix_status_t serviceRegistration_getServiceName(service_registration_t registration, char **serviceName);
+service_registration_pt serviceRegistration_create(apr_pool_t *pool, service_registry_pt registry, bundle_pt bundle, char * serviceName, long serviceId, void * serviceObject, properties_pt dictionary);
+service_registration_pt serviceRegistration_createServiceFactory(apr_pool_t *pool, service_registry_pt registry, bundle_pt bundle, char * serviceName, long serviceId, void * serviceObject, properties_pt dictionary);
+void serviceRegistration_destroy(service_registration_pt registration);
+
+FRAMEWORK_EXPORT bool serviceRegistration_isValid(service_registration_pt registration);
+FRAMEWORK_EXPORT void serviceRegistration_invalidate(service_registration_pt registration);
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_unregister(service_registration_pt registration);
+
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getService(service_registration_pt registration, bundle_pt bundle, void **service);
+
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getProperties(service_registration_pt registration, properties_pt *properties);
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getRegistry(service_registration_pt registration, service_registry_pt *registry);
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getServiceReferences(service_registration_pt registration, array_list_pt *references);
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getBundle(service_registration_pt registration, bundle_pt *bundle);
+FRAMEWORK_EXPORT celix_status_t serviceRegistration_getServiceName(service_registration_pt registration, char **serviceName);
 
 #endif /* SERVICE_REGISTRATION_H_ */



Mime
View raw message