celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject svn commit: r1492377 [3/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/device_access/example/base_driver/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/base_driver/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/base_driver/private/src/activator.c (original)
+++ incubator/celix/trunk/device_access/example/base_driver/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -37,20 +37,20 @@
 #include "base_driver_device.h"
 
 struct base_driver_bundle_instance {
-	bundle_context_t context;
+	bundle_context_pt context;
 	apr_pool_t * pool;
-	array_list_t serviceRegistrations;
+	array_list_pt serviceRegistrations;
 };
 
-typedef struct base_driver_bundle_instance *base_driver_bundle_instance_t;
+typedef struct base_driver_bundle_instance *base_driver_bundle_instance_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	printf("BASE_DRIVER: creating bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *pool;
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
-		base_driver_bundle_instance_t instance = apr_palloc(pool, sizeof(*instance));
+		base_driver_bundle_instance_pt instance = apr_palloc(pool, sizeof(*instance));
 		if (instance != NULL) {
 			instance->context = context;
 			instance->pool = pool;
@@ -65,18 +65,18 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-static celix_status_t bundleActivator_registerBaseDriverDevice(base_driver_bundle_instance_t bi, char *serial) {
+static celix_status_t bundleActivator_registerBaseDriverDevice(base_driver_bundle_instance_pt bi, char *serial) {
 	celix_status_t status = CELIX_SUCCESS;
-	base_driver_device_t device = NULL;
+	base_driver_device_pt device = NULL;
 	status = baseDriver_create(bi->pool, &device);
 	if (status == CELIX_SUCCESS) {
-		base_driver_device_service_t service = NULL;
+		base_driver_device_service_pt service = NULL;
 		status = baseDriver_createService(device, &service);
 		if (status == CELIX_SUCCESS) {
-			properties_t props = properties_create();
+			properties_pt props = properties_create();
 			properties_set(props, DEVICE_CATEGORY, BASE_DRIVER_DEVICE_CATEGORY);
 			properties_set(props, DEVICE_SERIAL, serial);
-			service_registration_t service_registration = NULL;
+			service_registration_pt service_registration = NULL;
 			status = bundleContext_registerService(bi->context, DEVICE_SERVICE_NAME, service, props, &service_registration);
 			if (status == CELIX_SUCCESS) {
 				arrayList_add(bi->serviceRegistrations, service_registration);
@@ -98,10 +98,10 @@ static celix_status_t bundleActivator_re
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	printf("BASE_DRIVER: starting bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	base_driver_bundle_instance_t bundleInstance = userData;
+	base_driver_bundle_instance_pt bundleInstance = userData;
 	status = bundleActivator_registerBaseDriverDevice(bundleInstance, "0001");
 //	if (status == CELIX_SUCCESS) {
 //		status = bundleActivator_registerBaseDriverDevice(bundleInstance, "0002");
@@ -109,14 +109,14 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	printf("BASE_DRIVER: stopping bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	base_driver_bundle_instance_t bundleInstance = userData;
+	base_driver_bundle_instance_pt bundleInstance = userData;
 
-	array_list_iterator_t iterator = arrayListIterator_create(bundleInstance->serviceRegistrations);
+	array_list_iterator_pt iterator = arrayListIterator_create(bundleInstance->serviceRegistrations);
 	while (arrayListIterator_hasNext(iterator)) {
-		service_registration_t reg = arrayListIterator_next(iterator);
+		service_registration_pt reg = arrayListIterator_next(iterator);
 		printf("BASE_DRIVER: unregistering service\n");
 		celix_status_t unregStatus = serviceRegistration_unregister(reg);
 		if (unregStatus != CELIX_SUCCESS) {
@@ -131,10 +131,10 @@ celix_status_t bundleActivator_stop(void
 	return status;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	printf("BASE_DRIVER: destroying bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	base_driver_bundle_instance_t bundleInstance = userData;
+	base_driver_bundle_instance_pt bundleInstance = userData;
 
 	arrayList_destroy(bundleInstance->serviceRegistrations);
 	return status;

Modified: incubator/celix/trunk/device_access/example/base_driver/private/src/base_driver.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/base_driver/private/src/base_driver.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/base_driver/private/src/base_driver.c (original)
+++ incubator/celix/trunk/device_access/example/base_driver/private/src/base_driver.c Wed Jun 12 19:08:50 2013
@@ -42,19 +42,19 @@ struct device {
 };
 
 struct base_driver_device {
-	device_t device;
+	device_pt device;
 	apr_pool_t *pool;
 	char *input;
 	int inputLength;
 	int currentChar;
 };
 
-celix_status_t baseDriver_noDriverFound(device_t device) {
+celix_status_t baseDriver_noDriverFound(device_pt device) {
 	printf("BASE_DRIVER: No driver found\n");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t baseDriver_create(apr_pool_t *pool, base_driver_device_t *baseDriverDevice) {
+celix_status_t baseDriver_create(apr_pool_t *pool, base_driver_device_pt *baseDriverDevice) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*baseDriverDevice) = apr_palloc(pool, sizeof(struct base_driver_device));
 	if (*baseDriverDevice != NULL) {
@@ -72,7 +72,7 @@ celix_status_t baseDriver_create(apr_poo
 	return status;
 }
 
-celix_status_t baseDriver_createService(base_driver_device_t baseDriverDevice, base_driver_device_service_t *service) {
+celix_status_t baseDriver_createService(base_driver_device_pt baseDriverDevice, base_driver_device_service_pt *service) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*service) = apr_palloc(baseDriverDevice->pool, sizeof(struct base_driver_device_service));
 	if ((*service) != NULL) {
@@ -86,7 +86,7 @@ celix_status_t baseDriver_createService(
 	return status;
 }
 
-celix_status_t baseDriver_getNextChar(base_driver_device_t device, char *c) {
+celix_status_t baseDriver_getNextChar(base_driver_device_pt device, char *c) {
 	(*c) = device->input[device->currentChar];
 	device->currentChar+=1;
 	if (device->currentChar >= device->inputLength) {

Modified: incubator/celix/trunk/device_access/example/base_driver/public/include/base_driver_device.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/base_driver/public/include/base_driver_device.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/base_driver/public/include/base_driver_device.h (original)
+++ incubator/celix/trunk/device_access/example/base_driver/public/include/base_driver_device.h Wed Jun 12 19:08:50 2013
@@ -31,14 +31,14 @@
 #define BASE_DRIVER_SERVICE_NAME "base_driver_device_service"
 #define BASE_DRIVER_DEVICE_CATEGORY "char"
 
-typedef struct base_driver_device *base_driver_device_t;
+typedef struct base_driver_device *base_driver_device_pt;
 
 struct base_driver_device_service {
 	struct device_service deviceService; /*NOTE: base_driver_device_service is a device_service.*/
-	base_driver_device_t baseDriverDevice;
-	celix_status_t (*getNextChar)(base_driver_device_t baseDriverDevice, char *c);
+	base_driver_device_pt baseDriverDevice;
+	celix_status_t (*getNextChar)(base_driver_device_pt baseDriverDevice, char *c);
 };
 
-typedef struct base_driver_device_service * base_driver_device_service_t;
+typedef struct base_driver_device_service * base_driver_device_service_pt;
 
 #endif /* BASE_DRIVER_DEVICE_H_ */

Modified: incubator/celix/trunk/device_access/example/consuming_driver/private/include/consuming_driver_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/consuming_driver/private/include/consuming_driver_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/consuming_driver/private/include/consuming_driver_private.h (original)
+++ incubator/celix/trunk/device_access/example/consuming_driver/private/include/consuming_driver_private.h Wed Jun 12 19:08:50 2013
@@ -32,12 +32,12 @@
 
 #define CONSUMING_DRIVER_ID "CONSUMING_DRIVER"
 
-typedef struct consuming_driver *consuming_driver_t;
+typedef struct consuming_driver *consuming_driver_pt;
 
-celix_status_t consumingDriver_create(bundle_context_t context, apr_pool_t *pool, consuming_driver_t *driver);
-celix_status_t consumingDriver_createService(consuming_driver_t driver, driver_service_t *service);
+celix_status_t consumingDriver_create(bundle_context_pt context, apr_pool_t *pool, consuming_driver_pt *driver);
+celix_status_t consumingDriver_createService(consuming_driver_pt driver, driver_service_pt *service);
 
-celix_status_t consumingDriver_attach(void *driver, service_reference_t reference, char **result);
-celix_status_t consumingDriver_match(void *driver, service_reference_t reference, int *value);
+celix_status_t consumingDriver_attach(void *driver, service_reference_pt reference, char **result);
+celix_status_t consumingDriver_match(void *driver, service_reference_pt reference, int *value);
 
 #endif /* CONSUMING_DRIVER_PRIVATE_H_ */

Modified: incubator/celix/trunk/device_access/example/consuming_driver/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/consuming_driver/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/consuming_driver/private/src/activator.c (original)
+++ incubator/celix/trunk/device_access/example/consuming_driver/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -36,20 +36,20 @@
 #include "consuming_driver_private.h"
 
 struct consuming_driver_bundle_instance {
-	bundle_context_t context;
+	bundle_context_pt context;
 	apr_pool_t * pool;
-	service_registration_t registration;
+	service_registration_pt registration;
 };
 
-typedef struct consuming_driver_bundle_instance *consuming_driver_bundle_instance_t;
+typedef struct consuming_driver_bundle_instance *consuming_driver_bundle_instance_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	printf("CONSUMING_DRIVER: creating bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *pool;
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
-		consuming_driver_bundle_instance_t instance = apr_palloc(pool, sizeof(*instance));
+		consuming_driver_bundle_instance_pt instance = apr_palloc(pool, sizeof(*instance));
 		if (instance != NULL) {
 			instance->context = context;
 			instance->pool = pool;
@@ -62,18 +62,18 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	printf("CONSUMING_DRIVER: starting bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	consuming_driver_bundle_instance_t bi = userData;
+	consuming_driver_bundle_instance_pt bi = userData;
 
-	consuming_driver_t driver = NULL;
+	consuming_driver_pt driver = NULL;
 	status = consumingDriver_create(context, bi->pool, &driver);
 	if (status == CELIX_SUCCESS) {
-		driver_service_t service = NULL;
+		driver_service_pt service = NULL;
 		status = consumingDriver_createService(driver, &service);
 		if (status == CELIX_SUCCESS) {
-			properties_t props = properties_create();
+			properties_pt props = properties_create();
 			properties_set(props, "DRIVER_ID", CONSUMING_DRIVER_ID);
 			status = bundleContext_registerService(context, DRIVER_SERVICE_NAME, service, props, &bi->registration);
 		}
@@ -88,10 +88,10 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	printf("CONSUMING_DRIVER: stopping bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	consuming_driver_bundle_instance_t bi = userData;
+	consuming_driver_bundle_instance_pt bi = userData;
 
 	if (bi->registration != NULL) {
 		serviceRegistration_unregister(bi->registration);
@@ -101,10 +101,10 @@ celix_status_t bundleActivator_stop(void
 	return status;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	printf("CONSUMING_DRIVER: destroying bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	consuming_driver_bundle_instance_t bi = userData;
+	consuming_driver_bundle_instance_pt bi = userData;
 	return status;
 }
 

Modified: incubator/celix/trunk/device_access/example/consuming_driver/private/src/consuming_driver.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/consuming_driver/private/src/consuming_driver.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/consuming_driver/private/src/consuming_driver.c (original)
+++ incubator/celix/trunk/device_access/example/consuming_driver/private/src/consuming_driver.c Wed Jun 12 19:08:50 2013
@@ -41,18 +41,18 @@
 
 struct consuming_driver {
 	apr_pool_t *pool;
-	bundle_context_t context;
-	array_list_t references;
+	bundle_context_pt context;
+	array_list_pt references;
 };
 
 static apr_status_t consumingDriver_cleanup(void *handler) {
 	printf("CONSUMING_DRIVER: cleanup\n");
-	consuming_driver_t driver = handler;
+	consuming_driver_pt driver = handler;
 
 	if (driver->references != NULL) {
-		array_list_iterator_t iterator = arrayListIterator_create(driver->references);
+		array_list_iterator_pt iterator = arrayListIterator_create(driver->references);
 		while (arrayListIterator_hasNext(iterator)) {
-			service_reference_t reference = arrayListIterator_next(iterator);
+			service_reference_pt reference = arrayListIterator_next(iterator);
 			bool result;
 			bundleContext_ungetService(driver->context, reference, &result);
 		}
@@ -66,7 +66,7 @@ static apr_status_t consumingDriver_clea
 	return APR_SUCCESS;
 }
 
-celix_status_t consumingDriver_create(bundle_context_t context, apr_pool_t *pool, consuming_driver_t *driver) {
+celix_status_t consumingDriver_create(bundle_context_pt context, apr_pool_t *pool, consuming_driver_pt *driver) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*driver) = apr_palloc(pool, sizeof(**driver));
 	if ((*driver) != NULL) {
@@ -83,7 +83,7 @@ celix_status_t consumingDriver_create(bu
 	return status;
 }
 
-celix_status_t consumingDriver_createService(consuming_driver_t driver, driver_service_t *service) {
+celix_status_t consumingDriver_createService(consuming_driver_pt driver, driver_service_pt *service) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*service) = apr_palloc(driver->pool, sizeof(**service));
 	if ((*service) != NULL) {
@@ -96,12 +96,12 @@ celix_status_t consumingDriver_createSer
 	return status;
 }
 
-celix_status_t consumingDriver_attach(void * driverHandler, service_reference_t reference, char **result) {
+celix_status_t consumingDriver_attach(void * driverHandler, service_reference_pt reference, char **result) {
 	printf("CONSUMING_DRIVER: attached called\n");
 	celix_status_t status = CELIX_SUCCESS;
-	consuming_driver_t driver = driverHandler;
+	consuming_driver_pt driver = driverHandler;
 	(*result) = NULL;
-	refining_driver_device_service_t device_service = NULL;
+	refining_driver_device_service_pt device_service = NULL;
 
 	status = bundleContext_getService(driver->context, reference, (void **)&device_service);
 	if (status == CELIX_SUCCESS) {
@@ -121,14 +121,14 @@ celix_status_t consumingDriver_attach(vo
 	return status;
 }
 
-celix_status_t consumingDriver_match(void *driverHandler, service_reference_t reference, int *value) {
+celix_status_t consumingDriver_match(void *driverHandler, service_reference_pt reference, int *value) {
 	printf("CONSUMING_DRIVER: match called\n");
 	int match=0;
 	celix_status_t status = CELIX_SUCCESS;
-	consuming_driver_t driver = driverHandler;
+	consuming_driver_pt driver = driverHandler;
 
-	service_registration_t registration = NULL;
-	properties_t properties = NULL;
+	service_registration_pt registration = NULL;
+	properties_pt properties = NULL;
 	status = serviceReference_getServiceRegistration(reference, &registration);
 	if (status == CELIX_SUCCESS) {
 		status = serviceRegistration_getProperties(registration, &properties);

Modified: incubator/celix/trunk/device_access/example/refining_driver/private/include/refining_driver_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/refining_driver/private/include/refining_driver_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/refining_driver/private/include/refining_driver_private.h (original)
+++ incubator/celix/trunk/device_access/example/refining_driver/private/include/refining_driver_private.h Wed Jun 12 19:08:50 2013
@@ -35,23 +35,23 @@
 
 #define REFINING_DRIVER_ID "REFINING_DRIVER"
 
-typedef struct refining_driver *refining_driver_t;
+typedef struct refining_driver *refining_driver_pt;
 
-celix_status_t refiningDriver_create(bundle_context_t context, apr_pool_t *pool, refining_driver_t *driver);
-celix_status_t refiningDriver_destroy(refining_driver_t driver);
+celix_status_t refiningDriver_create(bundle_context_pt context, apr_pool_t *pool, refining_driver_pt *driver);
+celix_status_t refiningDriver_destroy(refining_driver_pt driver);
 
-celix_status_t refiningDriver_createService(refining_driver_t driver, driver_service_t *service);
+celix_status_t refiningDriver_createService(refining_driver_pt driver, driver_service_pt *service);
 
-celix_status_t refiningDriver_createDevice(refining_driver_t driver, service_reference_t reference, base_driver_device_service_t baseDevice, refining_driver_device_t *device);
-celix_status_t refiningDriver_destroyDevice(refining_driver_device_t device);
+celix_status_t refiningDriver_createDevice(refining_driver_pt driver, service_reference_pt reference, base_driver_device_service_pt baseDevice, refining_driver_device_pt *device);
+celix_status_t refiningDriver_destroyDevice(refining_driver_device_pt device);
 
 
-celix_status_t refiningDriver_attach(void *driver, service_reference_t reference, char **result);
-celix_status_t refiningDriver_match(void *driver, service_reference_t reference, int *value);
+celix_status_t refiningDriver_attach(void *driver, service_reference_pt reference, char **result);
+celix_status_t refiningDriver_match(void *driver, service_reference_pt reference, int *value);
 
 
-celix_status_t refiningDriverDevice_noDriverFound(device_t device);
-celix_status_t refiningDriverDevice_createService(refining_driver_device_t, refining_driver_device_service_t *service);
-celix_status_t refiningDriverDevice_getNextWord(refining_driver_device_t refiningDriverDevice, apr_pool_t *pool, char **word);
+celix_status_t refiningDriverDevice_noDriverFound(device_pt device);
+celix_status_t refiningDriverDevice_createService(refining_driver_device_pt, refining_driver_device_service_pt *service);
+celix_status_t refiningDriverDevice_getNextWord(refining_driver_device_pt refiningDriverDevice, apr_pool_t *pool, char **word);
 
 #endif /* REFINING_DRIVER_PRIVATE_H_ */

Modified: incubator/celix/trunk/device_access/example/refining_driver/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/refining_driver/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/refining_driver/private/src/activator.c (original)
+++ incubator/celix/trunk/device_access/example/refining_driver/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -36,20 +36,20 @@
 #include "refining_driver_private.h"
 
 struct refining_driver_bundle_instance {
-	bundle_context_t context;
+	bundle_context_pt context;
 	apr_pool_t * pool;
-	service_registration_t registration;
+	service_registration_pt registration;
 };
 
-typedef struct refining_driver_bundle_instance *refining_driver_bundle_instance_t;
+typedef struct refining_driver_bundle_instance *refining_driver_bundle_instance_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	printf("REFINING_DRIVER: creating bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *pool;
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
-		refining_driver_bundle_instance_t instance = apr_palloc(pool, sizeof(*instance));
+		refining_driver_bundle_instance_pt instance = apr_palloc(pool, sizeof(*instance));
 		if (instance != NULL) {
 			instance->context = context;
 			instance->pool = pool;
@@ -62,18 +62,18 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	printf("REFINING_DRIVER: starting bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_bundle_instance_t bi = userData;
+	refining_driver_bundle_instance_pt bi = userData;
 
-	refining_driver_t driver = NULL;
+	refining_driver_pt driver = NULL;
 	status = refiningDriver_create(context, bi->pool, &driver);
 	if (status == CELIX_SUCCESS) {
-		driver_service_t service = NULL;
+		driver_service_pt service = NULL;
 		status = refiningDriver_createService(driver, &service);
 		if (status == CELIX_SUCCESS) {
-			properties_t props = properties_create();
+			properties_pt props = properties_create();
 			properties_set(props, "DRIVER_ID", REFINING_DRIVER_ID);
 			status = bundleContext_registerService(context, DRIVER_SERVICE_NAME, service, props, &bi->registration);
 		}
@@ -88,10 +88,10 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	printf("REFINING_DRIVER: stopping bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_bundle_instance_t bi = userData;
+	refining_driver_bundle_instance_pt bi = userData;
 
 	if (bi->registration != NULL) {
 		serviceRegistration_unregister(bi->registration);
@@ -101,10 +101,10 @@ celix_status_t bundleActivator_stop(void
 	return status;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	printf("REFINING_DRIVER: destroying bundle\n");
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_bundle_instance_t bi = userData;
+	refining_driver_bundle_instance_pt bi = userData;
 	return status;
 }
 

Modified: incubator/celix/trunk/device_access/example/refining_driver/private/src/refining_driver.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/refining_driver/private/src/refining_driver.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/refining_driver/private/src/refining_driver.c (original)
+++ incubator/celix/trunk/device_access/example/refining_driver/private/src/refining_driver.c Wed Jun 12 19:08:50 2013
@@ -40,11 +40,11 @@
 static const int MAX_BUFF_SIZE = 1024;
 
 struct refining_driver {
-	device_t device;
+	device_pt device;
 	apr_pool_t *pool;
-	bundle_context_t context;
+	bundle_context_pt context;
 	int deviceCount;
-	array_list_t devices;
+	array_list_pt devices;
 };
 
 struct device {
@@ -52,22 +52,22 @@ struct device {
 };
 
 struct refining_driver_device {
-	device_t device;
+	device_pt device;
 	apr_pool_t *pool;
-	base_driver_device_service_t baseDriverDeviceService;
-	refining_driver_t driver;
-	service_reference_t baseServiceReference;
-	service_registration_t deviceRegistration;
-	service_listener_t listener;
+	base_driver_device_service_pt baseDriverDeviceService;
+	refining_driver_pt driver;
+	service_reference_pt baseServiceReference;
+	service_registration_pt deviceRegistration;
+	service_listener_pt listener;
 };
 
-celix_status_t refiningDriver_destroy(refining_driver_t driver) {
+celix_status_t refiningDriver_destroy(refining_driver_pt driver) {
 	apr_pool_destroy(driver->pool);
 	return CELIX_SUCCESS;
 }
 
 static apr_status_t refiningDriver_cleanup(void *handler) {
-	refining_driver_t driver = handler;
+	refining_driver_pt driver = handler;
 	if (driver != NULL) {
 		if (driver->devices != NULL) {
 			arrayList_destroy(driver->devices);
@@ -77,7 +77,7 @@ static apr_status_t refiningDriver_clean
 	return CELIX_SUCCESS;
 }
 
-celix_status_t refiningDriver_create(bundle_context_t context, apr_pool_t *pool, refining_driver_t *driver) {
+celix_status_t refiningDriver_create(bundle_context_pt context, apr_pool_t *pool, refining_driver_pt *driver) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *driverPool = NULL;
 	apr_status_t aprStatus = apr_pool_create(&driverPool, pool);
@@ -96,7 +96,7 @@ celix_status_t refiningDriver_create(bun
 	return status;
 }
 
-celix_status_t refiningDriver_createService(refining_driver_t driver, driver_service_t *service) {
+celix_status_t refiningDriver_createService(refining_driver_pt driver, driver_service_pt *service) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*service) = apr_palloc(driver->pool, sizeof(**service));
 	if ((*service) != NULL) {
@@ -109,7 +109,7 @@ celix_status_t refiningDriver_createServ
 	return status;
 }
 
-static celix_status_t refiningDriver_stopDevice(refining_driver_device_t device) {
+static celix_status_t refiningDriver_stopDevice(refining_driver_device_pt device) {
 	printf("REFINING_DRIVER: stopping device, parent device is unregistered\n");
 	celix_status_t status =  CELIX_SUCCESS;
 
@@ -126,9 +126,9 @@ static celix_status_t refiningDriver_sto
 }
 
 
-static celix_status_t refiningDriver_serviceChanged(service_listener_t listener, service_event_t event) {
+static celix_status_t refiningDriver_serviceChanged(service_listener_pt listener, service_event_pt event) {
 	celix_status_t status =  CELIX_SUCCESS;
-	refining_driver_device_t device = listener->handle;
+	refining_driver_device_pt device = listener->handle;
 	if (event->type == SERVICE_EVENT_UNREGISTERING) {
 		bool equal = false;
 		status = serviceReference_equals(device->baseServiceReference, event->reference, &equal);
@@ -139,14 +139,14 @@ static celix_status_t refiningDriver_ser
 	return status;
 }
 
-celix_status_t refiningDriver_destroyDevice(refining_driver_device_t device) {
+celix_status_t refiningDriver_destroyDevice(refining_driver_device_pt device) {
 	apr_pool_destroy(device->pool);
 	return CELIX_SUCCESS;
 }
 
 static apr_status_t refining_driver_cleanup_device(void *handler) {
 	apr_status_t status = APR_SUCCESS;
-	refining_driver_device_t device = handler;
+	refining_driver_device_pt device = handler;
 	if (device != NULL) {
 		if (device->listener != NULL) {
 			bundleContext_removeServiceListener(device->driver->context, device->listener);
@@ -155,7 +155,7 @@ static apr_status_t refining_driver_clea
 	return status;
 }
 
-celix_status_t refiningDriver_createDevice(refining_driver_t driver, service_reference_t reference, base_driver_device_service_t baseService, refining_driver_device_t *device) {
+celix_status_t refiningDriver_createDevice(refining_driver_pt driver, service_reference_pt reference, base_driver_device_service_pt baseService, refining_driver_device_pt *device) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *devicePool = NULL;
 	apr_status_t aprStatus = apr_pool_create(&devicePool, driver->pool);
@@ -171,10 +171,10 @@ celix_status_t refiningDriver_createDevi
 				(*device)->deviceRegistration=NULL;
 				(*device)->listener=NULL;
 
-				service_listener_t listener = apr_palloc(devicePool, sizeof(*listener));
+				service_listener_pt listener = apr_palloc(devicePool, sizeof(*listener));
 				listener->pool=devicePool;
 				listener->handle=(void *)(*device);
-				listener->serviceChanged=(celix_status_t (*)(void * listener, service_event_t event))refiningDriver_serviceChanged;
+				listener->serviceChanged=(celix_status_t (*)(void * listener, service_event_pt event))refiningDriver_serviceChanged;
 				bundleContext_addServiceListener(driver->context, listener, NULL);
 				(*device)->listener=listener;
 
@@ -189,12 +189,12 @@ celix_status_t refiningDriver_createDevi
 }
 
 
-static celix_status_t refiningDriver_registerDevice(refining_driver_t driver, refining_driver_device_t device, char *serial) {
+static celix_status_t refiningDriver_registerDevice(refining_driver_pt driver, refining_driver_device_pt device, char *serial) {
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_device_service_t service = NULL;
+	refining_driver_device_service_pt service = NULL;
 	status = refiningDriverDevice_createService(device, &service);
 	if (status == CELIX_SUCCESS) {
-		properties_t props = properties_create();
+		properties_pt props = properties_create();
 		properties_set(props, DEVICE_CATEGORY, REFINING_DRIVER_DEVICE_CATEGORY);
 		properties_set(props, DEVICE_SERIAL, serial);
 		status = bundleContext_registerService(driver->context, DEVICE_SERVICE_NAME, service, props, &device->deviceRegistration);
@@ -206,16 +206,16 @@ static celix_status_t refiningDriver_reg
 	return status;
 }
 
-celix_status_t refiningDriver_attach(void * driverHandler, service_reference_t reference, char **result) {
+celix_status_t refiningDriver_attach(void * driverHandler, service_reference_pt reference, char **result) {
 	printf("REFINING_DRIVER: attached called\n");
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_t driver = driverHandler;
+	refining_driver_pt driver = driverHandler;
 	(*result) = NULL;
-	device_service_t device = NULL;
-	base_driver_device_service_t device_service = NULL;
+	device_service_pt device = NULL;
+	base_driver_device_service_pt device_service = NULL;
 	status = bundleContext_getService(driver->context, reference, (void **)&device_service);
 	if (status == CELIX_SUCCESS) {
-		refining_driver_device_t refiningDevice = NULL;
+		refining_driver_device_pt refiningDevice = NULL;
 		status = refiningDriver_createDevice(driver, reference, device_service, &refiningDevice);
 		if (status == CELIX_SUCCESS) {
 			driver->deviceCount+=1;
@@ -227,14 +227,14 @@ celix_status_t refiningDriver_attach(voi
 	return status;
 }
 
-celix_status_t refiningDriver_match(void *driverHandler, service_reference_t reference, int *value) {
+celix_status_t refiningDriver_match(void *driverHandler, service_reference_pt reference, int *value) {
 	printf("REFINING_DRIVER: match called\n");
 	int match = 0;
 	celix_status_t status = CELIX_SUCCESS;
-	refining_driver_t driver = driverHandler;
+	refining_driver_pt driver = driverHandler;
 
-	service_registration_t registration = NULL;
-	properties_t properties = NULL;
+	service_registration_pt registration = NULL;
+	properties_pt properties = NULL;
 	status = serviceReference_getServiceRegistration(reference, &registration);
 	if (status == CELIX_SUCCESS) {
 		status = serviceRegistration_getProperties(registration, &properties);
@@ -250,7 +250,7 @@ celix_status_t refiningDriver_match(void
 	return status;
 }
 
-celix_status_t refiningDriverDevice_createService(refining_driver_device_t device, refining_driver_device_service_t *service) {
+celix_status_t refiningDriverDevice_createService(refining_driver_device_pt device, refining_driver_device_service_pt *service) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*service) = apr_palloc(device->pool, sizeof(**service));
 	if ((*service) != NULL) {
@@ -268,9 +268,9 @@ celix_status_t refiningDriverDevice_crea
 	return status;
 }
 
-celix_status_t refiningDriverDevice_getNextWord(refining_driver_device_t refiningDriverDevice, apr_pool_t *pool, char **word) {
+celix_status_t refiningDriverDevice_getNextWord(refining_driver_device_pt refiningDriverDevice, apr_pool_t *pool, char **word) {
 	celix_status_t status = CELIX_SUCCESS;
-	base_driver_device_t baseDevice = refiningDriverDevice->baseDriverDeviceService->baseDriverDevice;
+	base_driver_device_pt baseDevice = refiningDriverDevice->baseDriverDeviceService->baseDriverDevice;
 	char buff[MAX_BUFF_SIZE];
 	int i=0;
 	status = refiningDriverDevice->baseDriverDeviceService->getNextChar(baseDevice, &buff[i]);
@@ -292,7 +292,7 @@ celix_status_t refiningDriverDevice_getN
 	return status;
 }
 
-celix_status_t refiningDriverDevice_noDriverFound(device_t device) {
+celix_status_t refiningDriverDevice_noDriverFound(device_pt device) {
 	printf("REFINING_DRIVER: no driver found");
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/device_access/example/refining_driver/public/include/refining_driver_device.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/refining_driver/public/include/refining_driver_device.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/refining_driver/public/include/refining_driver_device.h (original)
+++ incubator/celix/trunk/device_access/example/refining_driver/public/include/refining_driver_device.h Wed Jun 12 19:08:50 2013
@@ -32,14 +32,14 @@
 #define REFINING_DRIVER_DEVICE_CATEGORY "word"
 #define REFINING_DRIVER_DEVICE_SERVIC_NAME "refining_driver_device"
 
-typedef struct refining_driver_device *refining_driver_device_t;
+typedef struct refining_driver_device *refining_driver_device_pt;
 
 struct refining_driver_device_service {
 	struct device_service deviceService; /*NOTE: base_driver_device_service is a device_service.*/
-	refining_driver_device_t refiningDriverDevice;
-	celix_status_t (*getNextWord)(refining_driver_device_t refiningDriverDevice, apr_pool_t *pool, char **c);
+	refining_driver_device_pt refiningDriverDevice;
+	celix_status_t (*getNextWord)(refining_driver_device_pt refiningDriverDevice, apr_pool_t *pool, char **c);
 };
 
-typedef struct refining_driver_device_service * refining_driver_device_service_t;
+typedef struct refining_driver_device_service * refining_driver_device_service_pt;
 
 #endif /* REFINING_DRIVER_DEVICE_H_ */

Modified: incubator/celix/trunk/examples/echo_service/client/private/include/echo_client_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/client/private/include/echo_client_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/client/private/include/echo_client_private.h (original)
+++ incubator/celix/trunk/examples/echo_service/client/private/include/echo_client_private.h Wed Jun 12 19:08:50 2013
@@ -30,21 +30,21 @@
 #include <celixbool.h>
 
 struct echoClient {
-	service_tracker_t tracker;
+	service_tracker_pt tracker;
 	bool running;
 	apr_pool_t *pool;
 
 	apr_thread_t *sender;
 };
 
-typedef struct echoClient * ECHO_CLIENT;
+typedef struct echoClient * echo_client_pt;
 
-ECHO_CLIENT echoClient_create(service_tracker_t context, apr_pool_t *pool);
+echo_client_pt echoClient_create(service_tracker_pt context, apr_pool_t *pool);
 
-void echoClient_start(ECHO_CLIENT client);
-void echoClient_stop(ECHO_CLIENT client);
+void echoClient_start(echo_client_pt client);
+void echoClient_stop(echo_client_pt client);
 
-void echoClient_destroy(ECHO_CLIENT client);
+void echoClient_destroy(echo_client_pt client);
 
 
 #endif /* ECHO_CLIENT_PRIVATE_H_ */

Modified: incubator/celix/trunk/examples/echo_service/client/private/src/echo_client.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/client/private/src/echo_client.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/client/private/src/echo_client.c (original)
+++ incubator/celix/trunk/examples/echo_service/client/private/src/echo_client.c Wed Jun 12 19:08:50 2013
@@ -31,9 +31,9 @@
 #include "echo_server.h"
 
 static void *APR_THREAD_FUNC trk_send(apr_thread_t *thd, void *handle) {
-	ECHO_CLIENT client = (ECHO_CLIENT) handle;
+	echo_client_pt client = (echo_client_pt) handle;
 	while (client->running) {
-		ECHO_SERVICE service = (ECHO_SERVICE) serviceTracker_getService(client->tracker);
+		echo_service_pt service = (echo_service_pt) serviceTracker_getService(client->tracker);
 		if (service != NULL) {
 			service->echo(service->server, "hi");
 		}
@@ -43,8 +43,8 @@ static void *APR_THREAD_FUNC trk_send(ap
 	return NULL;
 }
 
-ECHO_CLIENT echoClient_create(service_tracker_t echoServiceTracker, apr_pool_t *pool) {
-	ECHO_CLIENT client = malloc(sizeof(*client));
+echo_client_pt echoClient_create(service_tracker_pt echoServiceTracker, apr_pool_t *pool) {
+	echo_client_pt client = malloc(sizeof(*client));
 
 	client->tracker = echoServiceTracker;
 	client->running = false;
@@ -53,18 +53,18 @@ ECHO_CLIENT echoClient_create(service_tr
 	return client;
 }
 
-void echoClient_start(ECHO_CLIENT client) {
+void echoClient_start(echo_client_pt client) {
 	client->running = true;
 	apr_thread_create(&client->sender, NULL, trk_send, client, client->pool);
 }
 
-void echoClient_stop(ECHO_CLIENT client) {
+void echoClient_stop(echo_client_pt client) {
 	apr_status_t status;
 	client->running = false;
 	apr_thread_join(&status, client->sender);
 }
 
-void echoClient_destroy(ECHO_CLIENT client) {
+void echoClient_destroy(echo_client_pt client) {
 	client->tracker = NULL;
 	client->sender = 0;
 	free(client);

Modified: incubator/celix/trunk/examples/echo_service/client/private/src/echo_client_activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/client/private/src/echo_client_activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/client/private/src/echo_client_activator.c (original)
+++ incubator/celix/trunk/examples/echo_service/client/private/src/echo_client_activator.c Wed Jun 12 19:08:50 2013
@@ -33,11 +33,11 @@
 #include "echo_client_private.h"
 
 struct echoActivator {
-	ECHO_CLIENT client;
-	service_tracker_t tracker;
+	echo_client_pt client;
+	service_tracker_pt tracker;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	struct echoActivator * act = malloc(sizeof(*act));
 	act->client = NULL;
 	act->tracker = NULL;
@@ -47,12 +47,12 @@ celix_status_t bundleActivator_create(bu
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 
 	apr_pool_t *pool = NULL;
-	service_tracker_t tracker = NULL;
-	ECHO_CLIENT client = NULL;
+	service_tracker_pt tracker = NULL;
+	echo_client_pt client = NULL;
 
 	bundleContext_getMemoryPool(context, &pool);
 	serviceTracker_create(pool, context, ECHO_SERVICE_NAME, NULL, &tracker);
@@ -67,7 +67,7 @@ celix_status_t bundleActivator_start(voi
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 	serviceTracker_close(act->tracker);
 	echoClient_stop(act->client);
@@ -75,7 +75,7 @@ celix_status_t bundleActivator_stop(void
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 	echoClient_destroy(act->client);
 

Modified: incubator/celix/trunk/examples/echo_service/server/private/include/echo_server_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/server/private/include/echo_server_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/server/private/include/echo_server_private.h (original)
+++ incubator/celix/trunk/examples/echo_service/server/private/include/echo_server_private.h Wed Jun 12 19:08:50 2013
@@ -29,8 +29,8 @@
 
 #include "echo_server.h"
 
-ECHO_SERVER echoServer_create();
-void echoServer_echo(ECHO_SERVER server, char * text);
-void echoServer_destroy(ECHO_SERVER server);
+echo_server_pt echoServer_create();
+void echoServer_echo(echo_server_pt server, char * text);
+void echoServer_destroy(echo_server_pt server);
 
 #endif /* ECHO_SERVER_PRIVATE_H_ */

Modified: incubator/celix/trunk/examples/echo_service/server/private/src/echo_server.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/server/private/src/echo_server.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/server/private/src/echo_server.c (original)
+++ incubator/celix/trunk/examples/echo_service/server/private/src/echo_server.c Wed Jun 12 19:08:50 2013
@@ -32,17 +32,17 @@ struct echoServer {
 	char * name;
 };
 
-ECHO_SERVER echoServer_create() {
-	ECHO_SERVER server = malloc(sizeof(*server));
+echo_server_pt echoServer_create() {
+	echo_server_pt server = malloc(sizeof(*server));
 	server->name = "MacBook Pro";
 	return server;
 }
 
-void echoServer_echo(ECHO_SERVER server, char * text) {
+void echoServer_echo(echo_server_pt server, char * text) {
 	printf("Server %s says %s\n", server->name, text);
 }
 
-void echoServer_destroy(ECHO_SERVER server) {
+void echoServer_destroy(echo_server_pt server) {
 	server->name = NULL;
 	free(server);
 	server = NULL;

Modified: incubator/celix/trunk/examples/echo_service/server/private/src/echo_server_activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/server/private/src/echo_server_activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/server/private/src/echo_server_activator.c (original)
+++ incubator/celix/trunk/examples/echo_service/server/private/src/echo_server_activator.c Wed Jun 12 19:08:50 2013
@@ -31,22 +31,22 @@
 #include "echo_server_private.h"
 
 struct echoActivator {
-	service_registration_t reg;
-	ECHO_SERVICE es;
+	service_registration_pt reg;
+	echo_service_pt es;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	struct echoActivator * act = malloc(sizeof(*act));
 	act->reg = NULL;
 	*userData = act;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 
-	ECHO_SERVICE es = malloc(sizeof(*es));
-	ECHO_SERVER server = echoServer_create();
+	echo_service_pt es = malloc(sizeof(*es));
+	echo_server_pt server = echoServer_create();
 	es->server = server;
 	es->echo = echoServer_echo;
 
@@ -57,7 +57,7 @@ celix_status_t bundleActivator_start(voi
     return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 
 	serviceRegistration_unregister(act->reg);
@@ -66,7 +66,7 @@ celix_status_t bundleActivator_stop(void
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	struct echoActivator * act = (struct echoActivator *) userData;
 	act->es->echo = NULL;
 	echoServer_destroy(act->es->server);

Modified: incubator/celix/trunk/examples/echo_service/server/public/include/echo_server.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/echo_service/server/public/include/echo_server.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/echo_service/server/public/include/echo_server.h (original)
+++ incubator/celix/trunk/examples/echo_service/server/public/include/echo_server.h Wed Jun 12 19:08:50 2013
@@ -29,13 +29,13 @@
 
 #define ECHO_SERVICE_NAME "echo_server"
 
-typedef struct echoServer * ECHO_SERVER;
+typedef struct echoServer * echo_server_pt;
 
 struct echoService {
-	ECHO_SERVER server;
-	void (*echo)(ECHO_SERVER server, char * text);
+	echo_server_pt server;
+	void (*echo)(echo_server_pt server, char * text);
 };
 
-typedef struct echoService * ECHO_SERVICE;
+typedef struct echoService * echo_service_pt;
 
 #endif /* ECHO_SERVER_H_ */

Modified: incubator/celix/trunk/examples/hello_world/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/hello_world/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/hello_world/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/hello_world/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -34,7 +34,7 @@ struct userData {
 	char * word;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
@@ -46,18 +46,18 @@ celix_status_t bundleActivator_create(bu
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	struct userData * data = (struct userData *) userData;
 	printf("Hello %s\n", data->word);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	struct userData * data = (struct userData *) userData;
 	printf("Goodbye %s\n", data->word);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/examples/mongoose/private/include/mongoose.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/mongoose/private/include/mongoose.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/mongoose/private/include/mongoose.h (original)
+++ incubator/celix/trunk/examples/mongoose/private/include/mongoose.h Wed Jun 12 19:08:50 2013
@@ -73,7 +73,7 @@ enum mg_event {
 //   If callback returns NULL, that means that callback has not processed
 //   the request. Handler must not send any data to the client in this case.
 //   Mongoose proceeds with request handling as if nothing happened.
-typedef void * (*mg_callback_t)(enum mg_event event,
+typedef void * (*mg_callback_pt)(enum mg_event event,
                                 struct mg_connection *conn,
                                 const struct mg_request_info *request_info);
   
@@ -98,7 +98,7 @@ typedef void * (*mg_callback_t)(enum mg_
 //
 // Return:
 //   web server context, or NULL on error.
-struct mg_context *mg_start(mg_callback_t callback, const char **options);
+struct mg_context *mg_start(mg_callback_pt callback, const char **options);
 
 
 // Stop the web server.

Modified: incubator/celix/trunk/examples/mongoose/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/mongoose/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/mongoose/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/mongoose/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -36,15 +36,15 @@ struct userData {
 	struct mg_context *ctx;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	*userData = apr_palloc(pool, sizeof(struct userData));
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
-	bundle_t bundle;
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
+	bundle_pt bundle;
 	celix_status_t status = CELIX_SUCCESS;
 	struct userData * data = (struct userData *) userData;
 
@@ -73,13 +73,13 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	struct userData * data = (struct userData *) userData;
 	mg_stop(data->ctx);
 	printf("Mongoose stopped\n");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/examples/mongoose/private/src/mongoose.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/mongoose/private/src/mongoose.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/mongoose/private/src/mongoose.c (original)
+++ incubator/celix/trunk/examples/mongoose/private/src/mongoose.c Wed Jun 12 19:08:50 2013
@@ -227,7 +227,7 @@ typedef int SOCKET;
 typedef int socklen_t;
 #endif // NO_SOCKLEN_T
 
-typedef void * (*mg_thread_func_t)(void *);
+typedef void * (*mg_thread_func_pt)(void *);
 
 static const char *http_500_error = "Internal Server Error";
 
@@ -259,7 +259,7 @@ extern void SSL_load_error_strings(void)
 extern int SSL_CTX_use_PrivateKey_file(SSL_CTX *, const char *, int);
 extern int SSL_CTX_use_certificate_file(SSL_CTX *, const char *, int);
 extern int SSL_CTX_use_certificate_chain_file(SSL_CTX *, const char *);
-extern void SSL_CTX_set_default_passwd_cb(SSL_CTX *, mg_callback_t);
+extern void SSL_CTX_set_default_passwd_cb(SSL_CTX *, mg_callback_pt);
 extern void SSL_CTX_free(SSL_CTX *);
 extern unsigned long ERR_get_error(void);
 extern char *ERR_error_string(unsigned long, char *);
@@ -289,7 +289,7 @@ struct ssl_func {
 #define SSL_CTX_use_certificate_file (* (int (*)(SSL_CTX *, \
         const char *, int)) ssl_sw[12].ptr)
 #define SSL_CTX_set_default_passwd_cb \
-  (* (void (*)(SSL_CTX *, mg_callback_t)) ssl_sw[13].ptr)
+  (* (void (*)(SSL_CTX *, mg_callback_pt)) ssl_sw[13].ptr)
 #define SSL_CTX_free (* (void (*)(SSL_CTX *)) ssl_sw[14].ptr)
 #define SSL_load_error_strings (* (void (*)(void)) ssl_sw[15].ptr)
 #define SSL_CTX_use_certificate_chain_file \
@@ -420,7 +420,7 @@ struct mg_context {
   int stop_flag;                // Should we stop event loop
   SSL_CTX *ssl_ctx;             // SSL context
   char *config[NUM_OPTIONS];    // Mongoose configuration parameters
-  mg_callback_t user_callback;  // User-defined callback function
+  mg_callback_pt user_callback;  // User-defined callback function
 
   struct socket *listening_sockets;
 
@@ -1065,7 +1065,7 @@ struct dirent * readdir(DIR *dir) {
 
 #define set_close_on_exec(fd) // No FD_CLOEXEC on Windows
 
-static int start_thread(struct mg_context *ctx, mg_thread_func_t func,
+static int start_thread(struct mg_context *ctx, mg_thread_func_pt func,
                         void *param) {
   HANDLE hThread;
   ctx = NULL; // Unused
@@ -1187,7 +1187,7 @@ static void set_close_on_exec(int fd) {
   (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
 }
 
-static int start_thread(struct mg_context *ctx, mg_thread_func_t func,
+static int start_thread(struct mg_context *ctx, mg_thread_func_pt func,
                         void *param) {
   pthread_t thread_id;
   pthread_attr_t attr;
@@ -3984,7 +3984,7 @@ void mg_stop(struct mg_context *ctx) {
 #endif // _WIN32
 }
 
-struct mg_context *mg_start(mg_callback_t user_callback, const char **options) {
+struct mg_context *mg_start(mg_callback_pt user_callback, const char **options) {
   struct mg_context *ctx;
   const char *name, *value, *default_value;
   int i;
@@ -4051,11 +4051,11 @@ struct mg_context *mg_start(mg_callback_
   (void) pthread_cond_init(&ctx->sq_full, NULL);
 
   // Start master (listening) thread
-  start_thread(ctx, (mg_thread_func_t) master_thread, ctx);
+  start_thread(ctx, (mg_thread_func_pt) master_thread, ctx);
 
   // Start worker threads
   for (i = 0; i < atoi(ctx->config[NUM_THREADS]); i++) {
-    if (start_thread(ctx, (mg_thread_func_t) worker_thread, ctx) != 0) {
+    if (start_thread(ctx, (mg_thread_func_pt) worker_thread, ctx) != 0) {
       cry(fc(ctx), "Cannot start worker thread: %d", ERRNO);
     } else {
       ctx->num_threads++;

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/client/private/src/client.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/client/private/src/client.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/client/private/src/client.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/client/private/src/client.c Wed Jun 12 19:08:50 2013
@@ -31,19 +31,19 @@
 #include "greeting_service.h"
 
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	*userData = NULL;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t ctx) {
-	service_reference_t ref = NULL;
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt ctx) {
+	service_reference_pt ref = NULL;
 	celix_status_t status = bundleContext_getServiceReference(ctx, (char *) GREETING_SERVICE_NAME, &ref);
 	if (status == CELIX_SUCCESS) {
 		if (ref == NULL) {
 			printf("Greeting service reference not available\n");
 		} else {
-			greeting_service_t greeting = NULL;
+			greeting_service_pt greeting = NULL;
 			bundleContext_getService(ctx, ref, (void *) &greeting);
 			if (greeting == NULL){
 				printf("Greeting service not available\n");
@@ -57,10 +57,10 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/include/greeting_impl.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/include/greeting_impl.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/include/greeting_impl.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/include/greeting_impl.h Wed Jun 12 19:08:50 2013
@@ -32,7 +32,7 @@ struct greeting {
 	char *name;
 };
 
-extern void greeting_sayHello(greeting_t instance);
+extern void greeting_sayHello(greeting_pt instance);
 
 
 #endif /* GREETING_IMPL_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -34,15 +34,15 @@
 #include "service_registration.h"
 
 struct greetingActivator {
-	service_registration_t reg;
+	service_registration_pt reg;
 	apr_pool_t *pool;
 };
 
-typedef struct greetingActivator *greeting_activator_t;
+typedef struct greetingActivator *greeting_activator_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
-	greeting_activator_t activator;
+	greeting_activator_pt activator;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
 		*userData = apr_palloc(pool, sizeof(struct greetingActivator));
@@ -57,12 +57,12 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	greeting_activator_t act = (greeting_activator_t) userData;
+	greeting_activator_pt act = (greeting_activator_pt) userData;
 
-	greeting_service_t greetingService = apr_palloc(act->pool, sizeof(*greetingService));
+	greeting_service_pt greetingService = apr_palloc(act->pool, sizeof(*greetingService));
 
 	if (greetingService) {
 		greetingService->instance = apr_palloc(act->pool, sizeof(*greetingService->instance));
@@ -80,14 +80,14 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
-	greeting_activator_t act = (greeting_activator_t) userData;
+	greeting_activator_pt act = (greeting_activator_pt) userData;
 	serviceRegistration_unregister(act->reg);
 	act->reg = NULL;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/greeting_impl.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/greeting_impl.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/greeting_impl.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/private/src/greeting_impl.c Wed Jun 12 19:08:50 2013
@@ -26,7 +26,7 @@
 #include <stdio.h>
 #include "greeting_impl.h"
 
-void greeting_sayHello(greeting_t instance){
+void greeting_sayHello(greeting_pt instance){
 	printf("Greetings from %s\n", instance->name);
 }
 

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/public/include/greeting_service.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/public/include/greeting_service.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/public/include/greeting_service.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter01-greeting-example/greeting/public/include/greeting_service.h Wed Jun 12 19:08:50 2013
@@ -28,12 +28,12 @@
 
 #define GREETING_SERVICE_NAME "greeting-service"
 
-typedef struct greeting *greeting_t;
-typedef struct greeting_service *greeting_service_t;
+typedef struct greeting *greeting_pt;
+typedef struct greeting_service *greeting_service_pt;
 
 struct greeting_service {
-	greeting_t instance;
-	void (*greeting_sayHello)(greeting_t instance);
+	greeting_pt instance;
+	void (*greeting_sayHello)(greeting_pt instance);
 };
 
 #endif /* GREETING_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-listener/private/src/listener_example.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-listener/private/src/listener_example.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-listener/private/src/listener_example.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-listener/private/src/listener_example.c Wed Jun 12 19:08:50 2013
@@ -33,18 +33,18 @@
 struct listenerActivator {
 	apr_pool_t *pool;
 
-	bundle_context_t context;
-	service_listener_t listener;
+	bundle_context_pt context;
+	service_listener_pt listener;
 
 	apr_thread_mutex_t *logServiceReferencesLock;
-	array_list_t logServiceReferences;
+	array_list_pt logServiceReferences;
 
 	bool running;
 	apr_thread_t *logger;
 };
 
-void listenerExample_serviceChanged(service_listener_t listener, service_event_t event);
-celix_status_t listenerExample_getLogService(struct listenerActivator *activator, log_service_t *service);
+void listenerExample_serviceChanged(service_listener_pt listener, service_event_pt event);
+celix_status_t listenerExample_getLogService(struct listenerActivator *activator, log_service_pt *service);
 
 static void *APR_THREAD_FUNC listenerExample_logger(apr_thread_t *thd, void *activator);
 
@@ -54,7 +54,7 @@ celix_status_t ref_equals(void *a, void 
 	return serviceReference_equals(a, b, equals);
 }
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *pool;
 	apr_pool_t *subpool;
@@ -83,16 +83,16 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
 	struct listenerActivator *activator = userData;
 
-	service_listener_t listener = apr_palloc(activator->pool, sizeof(struct listenerActivator));
+	service_listener_pt listener = apr_palloc(activator->pool, sizeof(struct listenerActivator));
 	if (!listener) {
 		status = CELIX_ENOMEM;
 	} else {
 		char filter[30];
-		array_list_t logServices = NULL;
+		array_list_pt logServices = NULL;
 		apr_pool_t *pool;
 		sprintf(filter, "(objectClass=%s)", LOG_SERVICE_NAME);
 
@@ -110,8 +110,8 @@ celix_status_t bundleActivator_start(voi
 		if (status == CELIX_SUCCESS) {
 			int i;
 			for (i = 0; i < arrayList_size(logServices); i++) {
-				service_reference_t logService = (service_reference_t) arrayList_get(logServices, i);
-				service_event_t event = apr_palloc(activator->pool, sizeof(*event));
+				service_reference_pt logService = (service_reference_pt) arrayList_get(logServices, i);
+				service_event_pt event = apr_palloc(activator->pool, sizeof(*event));
 				event->reference = logService;
 				event->type = SERVICE_EVENT_REGISTERED;
 
@@ -126,7 +126,7 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
 	struct listenerActivator *activator = userData;
 	apr_status_t stat;
@@ -139,14 +139,14 @@ celix_status_t bundleActivator_stop(void
 	return status;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
 	struct listenerActivator *activator = userData;
 	arrayList_destroy(activator->logServiceReferences);
 	return status;
 }
 
-void listenerExample_serviceChanged(service_listener_t listener, service_event_t event) {
+void listenerExample_serviceChanged(service_listener_pt listener, service_event_pt event) {
 	struct listenerActivator *activator = listener->handle;
 	apr_thread_mutex_lock(activator->logServiceReferencesLock);
 
@@ -167,12 +167,12 @@ void listenerExample_serviceChanged(serv
 	apr_thread_mutex_unlock(activator->logServiceReferencesLock);
 }
 
-celix_status_t listenerExample_getLogService(struct listenerActivator *activator, log_service_t *service) {
+celix_status_t listenerExample_getLogService(struct listenerActivator *activator, log_service_pt *service) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	apr_thread_mutex_lock(activator->logServiceReferencesLock);
 	if (arrayList_size(activator->logServiceReferences) > 0) {
-		service_reference_t reference = arrayList_get(activator->logServiceReferences, 0);
+		service_reference_pt reference = arrayList_get(activator->logServiceReferences, 0);
 		status = bundleContext_getService(activator->context, reference, (void *) service);
 	}
 	apr_thread_mutex_unlock(activator->logServiceReferencesLock);
@@ -184,7 +184,7 @@ static void *APR_THREAD_FUNC listenerExa
 	struct listenerActivator *activator = data;
 
 	while (activator->running) {
-		log_service_t logService = NULL;
+		log_service_pt logService = NULL;
 		listenerExample_getLogService(activator, &logService);
 		if (logService != NULL) {
 			(*(logService->log))(logService->logger, LOG_INFO, "ping");

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-lookup/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-lookup/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-lookup/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-correct-lookup/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -32,15 +32,15 @@
 #include "log_service.h"
 #include "bundle.h"
 
-typedef log_service_t LOG_SERVICE;
+typedef log_service_pt LOG_SERVICE;
 
 struct threadData {
 	char * service;
 	int threadId;
-	bundle_context_t m_context;
+	bundle_context_pt m_context;
 };
 
-typedef struct threadData *THREAD_DATA;
+typedef struct threadData *thread_data_pt;
 
 static apr_thread_t *m_logTestThread;
 
@@ -48,40 +48,40 @@ static apr_thread_t *m_logTestThread;
 //*******************************************************************************
 // function prototypes
 //*******************************************************************************
-void startTestThread(THREAD_DATA data);
+void startTestThread(thread_data_pt data);
 void stopTestThread();
 void pauseTestThread();
-void alternativeLog(char *message, THREAD_DATA data);
+void alternativeLog(char *message, thread_data_pt data);
 //*******************************************************************************
 // global functions
 //*******************************************************************************
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
 		*userData = apr_palloc(pool, sizeof(struct threadData));
-		((THREAD_DATA)(*userData))->service = "chapter04-correct-lookup";
-		((THREAD_DATA)(*userData))->threadId = 0;
-		((THREAD_DATA)(*userData))->m_context = context;
+		((thread_data_pt)(*userData))->service = "chapter04-correct-lookup";
+		((thread_data_pt)(*userData))->threadId = 0;
+		((thread_data_pt)(*userData))->m_context = context;
 	} else {
 		status = CELIX_START_ERROR;
 	}
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t context) {
-	((THREAD_DATA) userData)->m_context = context;
-	startTestThread(((THREAD_DATA) userData));
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
+	((thread_data_pt) userData)->m_context = context;
+	startTestThread(((thread_data_pt) userData));
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	stopTestThread();
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }
 
@@ -92,12 +92,12 @@ celix_status_t bundleActivator_destroy(v
 // Test LogService by periodically sending a message
 void *APR_THREAD_FUNC LogServiceTest(apr_thread_t *thd, void *argument) {
 	celix_status_t status = CELIX_SUCCESS;
-	THREAD_DATA data = (THREAD_DATA) argument;
-	bundle_context_t m_context = ((THREAD_DATA) argument)->m_context;
+	thread_data_pt data = (thread_data_pt) argument;
+	bundle_context_pt m_context = ((thread_data_pt) argument)->m_context;
 	apr_os_thread_t *logThread = NULL;
 	apr_os_thread_get(&logThread, m_logTestThread);
 	while (apr_os_thread_current() == *logThread) {
-		service_reference_t logServiceRef = NULL;
+		service_reference_pt logServiceRef = NULL;
 		// lookup the current "best" LogService each time, just before we need to use it
 		status = bundleContext_getServiceReference(m_context, (char *) LOG_SERVICE_NAME, &logServiceRef);
 		// if the service reference is null then we know there's no log service available
@@ -120,7 +120,7 @@ void *APR_THREAD_FUNC LogServiceTest(apr
 	return NULL;
 }
 
-void startTestThread(THREAD_DATA data) {
+void startTestThread(thread_data_pt data) {
 	apr_pool_t *pool;
 	int rc;
 	// start separate worker thread to run the actual tests, managed by the bundle lifecycle
@@ -142,10 +142,10 @@ void pauseTestThread() {
 	apr_sleep(5000000);
 }
 
-void alternativeLog(char *message, THREAD_DATA data) {
+void alternativeLog(char *message, thread_data_pt data) {
 	// this provides similar style debug logging output for when the LogService disappears
 	celix_status_t status = CELIX_SUCCESS;
-	bundle_t bundle = NULL;
+	bundle_pt bundle = NULL;
 	char tid[20], bid[20];
 	long bundleId;
 	if (data->m_context != NULL) {

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/include/circle_shape.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/include/circle_shape.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/include/circle_shape.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/include/circle_shape.h Wed Jun 12 19:08:50 2013
@@ -28,6 +28,6 @@
 
 #include "celix_errno.h"
 
-celix_status_t circleShape_create(bundle_context_t context, SIMPLE_SHAPE *shape);
+celix_status_t circleShape_create(bundle_context_pt context, simple_shape_pt *shape);
 
 #endif /* CIRCLE_SHAPE_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -38,11 +38,11 @@
 #include "simple_shape.h"
 
 struct activator {
-	service_registration_t reg;
+	service_registration_pt reg;
 	apr_pool_t *pool;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
 	struct activator *activator;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
@@ -55,11 +55,11 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t ctx) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt ctx) {
 	struct activator * act = (struct activator *) userData;
 	celix_status_t status = CELIX_SUCCESS;
-	SIMPLE_SHAPE es = NULL;
-	properties_t props = NULL;
+	simple_shape_pt es = NULL;
+	properties_pt props = NULL;
 
 	circleShape_create(ctx, &es);
 	props = properties_create();
@@ -68,7 +68,7 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
 	struct activator * act = (struct activator *) userData;
 
@@ -77,6 +77,6 @@ celix_status_t bundleActivator_stop(void
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/circle_shape.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/circle_shape.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/circle_shape.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/circle/private/src/circle_shape.c Wed Jun 12 19:08:50 2013
@@ -38,12 +38,12 @@
 
 #define CIRCLE_FILE "circle.png"
 
-void circleShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
+void circleShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
 
-celix_status_t circleShape_create(bundle_context_t context, SIMPLE_SHAPE *shape) {
+celix_status_t circleShape_create(bundle_context_pt context, simple_shape_pt *shape) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	bundle_t bundle;
+	bundle_pt bundle;
 	apr_pool_t *pool;
 
 	if (*shape != NULL || context == NULL) {
@@ -53,7 +53,7 @@ celix_status_t circleShape_create(bundle
 		if (status == CELIX_SUCCESS) {
 			status = bundleContext_getMemoryPool(context, &pool);
 			if (status == CELIX_SUCCESS) {
-				*shape = (SIMPLE_SHAPE) apr_palloc(pool, sizeof(**shape));
+				*shape = (simple_shape_pt) apr_palloc(pool, sizeof(**shape));
 				if (!*shape) {
 					status = CELIX_ENOMEM;
 				} else {
@@ -73,7 +73,7 @@ celix_status_t circleShape_create(bundle
 	return status;
 }
 
-void circleShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
+void circleShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
 	GdkRectangle update_rect;
 	GError *gerror = NULL;
 	gsize rd = 0, wr = 0;

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/default_shape.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/default_shape.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/default_shape.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/default_shape.h Wed Jun 12 19:08:50 2013
@@ -26,6 +26,6 @@
 #ifndef DEFAULT_SHAPE_H_
 #define DEFAULT_SHAPE_H_
 
-extern SIMPLE_SHAPE defaultShape_create(bundle_context_t context);
+extern simple_shape_pt defaultShape_create(bundle_context_pt context);
 
 #endif /* DEFAULT_SHAPE_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/paint_frame.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/paint_frame.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/paint_frame.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/paint_frame.h Wed Jun 12 19:08:50 2013
@@ -38,22 +38,22 @@ struct paint_frame {
 	bool showing;
 
 	char *m_selected;
-	hash_map_t m_shapes;
-	SIMPLE_SHAPE m_defaultShape;
-	linked_list_t m_shapeComponents;
-	bundle_context_t context;
+	hash_map_pt m_shapes;
+	simple_shape_pt m_defaultShape;
+	linked_list_pt m_shapeComponents;
+	bundle_context_pt context;
 	GThread *main;
 	char *file;
 };
 
 
-typedef struct paint_frame *PAINT_FRAME;
-celix_status_t paintFrame_create(bundle_context_t context, apr_pool_t *pool, PAINT_FRAME *frame);
-celix_status_t paintFrame_exit(PAINT_FRAME frame);
-
-SIMPLE_SHAPE paintFrame_getShape(PAINT_FRAME frame, char *name);
-celix_status_t paintFrame_addShape(PAINT_FRAME frame, bundle_context_t context, SIMPLE_SHAPE shape);
-celix_status_t paintFrame_removeShape(PAINT_FRAME frame, SIMPLE_SHAPE sshape);
+typedef struct paint_frame *paint_frame_pt;
+celix_status_t paintFrame_create(bundle_context_pt context, apr_pool_t *pool, paint_frame_pt *frame);
+celix_status_t paintFrame_exit(paint_frame_pt frame);
+
+simple_shape_pt paintFrame_getShape(paint_frame_pt frame, char *name);
+celix_status_t paintFrame_addShape(paint_frame_pt frame, bundle_context_pt context, simple_shape_pt shape);
+celix_status_t paintFrame_removeShape(paint_frame_pt frame, simple_shape_pt sshape);
 
 
 #endif /* PAINT_FRAME_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/shape_component.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/shape_component.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/shape_component.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/include/shape_component.h Wed Jun 12 19:08:50 2013
@@ -29,17 +29,17 @@
 
 #include "paint_frame.h"
 
-typedef struct shape_component *SHAPE_COMPONENT;
+typedef struct shape_component *shape_component_pt;
 
 struct shape_component {
 	char *shapeName;
-	PAINT_FRAME m_frame;
+	paint_frame_pt m_frame;
 	gdouble x, y, w, h;
-	void (*shapeComponent_paintComponent)(SHAPE_COMPONENT shapeComponent, PAINT_FRAME frame,
+	void (*shapeComponent_paintComponent)(shape_component_pt shapeComponent, paint_frame_pt frame,
 			GdkPixmap *pixMap, GtkWidget *widget);
 };
 
-extern SHAPE_COMPONENT shapeComponent_create(PAINT_FRAME frame, SIMPLE_SHAPE sshape,
+extern shape_component_pt shapeComponent_create(paint_frame_pt frame, simple_shape_pt sshape,
 		gdouble x, gdouble y);
 
 #endif /* SHAPE_COMPONENT_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -39,24 +39,24 @@
 #include "service_registration.h"
 
 struct paintFrameActivatorData {
-	service_registration_t reg;
+	service_registration_pt reg;
 	apr_pool_t *pool;
-	service_tracker_t tracker;
-	bundle_context_t context;
-	PAINT_FRAME paint_frame;
+	service_tracker_pt tracker;
+	bundle_context_pt context;
+	paint_frame_pt paint_frame;
 };
-celix_status_t addingServ(void * handle, service_reference_t ref, void **service);
-celix_status_t addedServ(void * handle, service_reference_t reference, void * service);
-celix_status_t modifiedServ(void * handle, service_reference_t reference, void * service);
-celix_status_t removedServ(void * handle, service_reference_t reference, void * service);
+celix_status_t addingServ(void * handle, service_reference_pt ref, void **service);
+celix_status_t addedServ(void * handle, service_reference_pt reference, void * service);
+celix_status_t modifiedServ(void * handle, service_reference_pt reference, void * service);
+celix_status_t removedServ(void * handle, service_reference_pt reference, void * service);
 
-typedef struct paintFrameActivatorData *GREETING_ACTIVATOR;
+typedef struct paintFrameActivatorData *greeting_activator_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *pool;
-	GREETING_ACTIVATOR activator;
-	service_tracker_customizer_t cust = NULL;
+	greeting_activator_pt activator;
+	service_tracker_customizer_pt cust = NULL;
 	printf("Paint_frame create\n");
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
@@ -79,34 +79,34 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t ctx) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt ctx) {
 	struct paintFrameActivatorData * act = (struct paintFrameActivatorData *) userData;
 	celix_status_t status = CELIX_SUCCESS;
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	struct paintFrameActivatorData * act = (struct paintFrameActivatorData *) userData;
 	serviceTracker_close(act->tracker);
 	paintFrame_exit(act->paint_frame);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
 	struct paintFrameActivatorData * act = (struct paintFrameActivatorData *) userData;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t addingServ(void * handle, service_reference_t ref, void **service) {
+celix_status_t addingServ(void * handle, service_reference_pt ref, void **service) {
 	struct paintFrameActivatorData * data = (struct paintFrameActivatorData *) handle;
     bundleContext_getService(data->context, ref, service);
     return CELIX_SUCCESS;
 }
 
-celix_status_t addedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t addedServ(void * handle, service_reference_pt ref, void * service) {
 	struct paintFrameActivatorData * data = (struct paintFrameActivatorData *) handle;
-	service_registration_t reg = NULL;
-	properties_t props = NULL;
+	service_registration_pt reg = NULL;
+	properties_pt props = NULL;
 	char * serviceName = NULL;
 	serviceReference_getServiceRegistration(ref, &reg);
 	serviceRegistration_getProperties(reg, &props);
@@ -115,10 +115,10 @@ celix_status_t addedServ(void * handle, 
 	return CELIX_SUCCESS;
  }
 
-celix_status_t modifiedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t modifiedServ(void * handle, service_reference_pt ref, void * service) {
 	struct paintFrameActivatorData * data = (struct paintFrameActivatorData *) handle;
-	service_registration_t reg = NULL;
-	properties_t props = NULL;
+	service_registration_pt reg = NULL;
+	properties_pt props = NULL;
 	char * serviceName = NULL;
 	serviceReference_getServiceRegistration(ref, &reg);
 	serviceRegistration_getProperties(reg, &props);
@@ -126,10 +126,10 @@ celix_status_t modifiedServ(void * handl
 	return CELIX_SUCCESS;
 }
 
-celix_status_t removedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t removedServ(void * handle, service_reference_pt ref, void * service) {
 	struct paintFrameActivatorData * data = (struct paintFrameActivatorData *) handle;
-	service_registration_t reg = NULL;
-	properties_t props = NULL;
+	service_registration_pt reg = NULL;
+	properties_pt props = NULL;
 	char * serviceName = NULL;
 	serviceReference_getServiceRegistration(ref, &reg);
 	serviceRegistration_getProperties(reg, &props);



Mime
View raw message