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 [2/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/deployment_admin/private/src/deployment_package.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/deployment_admin/private/src/deployment_package.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/deployment_admin/private/src/deployment_package.c (original)
+++ incubator/celix/trunk/deployment_admin/private/src/deployment_package.c Wed Jun 12 19:08:50 2013
@@ -37,11 +37,11 @@
 static const char * const RESOURCE_PROCESSOR = "Resource-Processor";
 static const char * const DEPLOYMENTPACKAGE_CUSTOMIZER = "DeploymentPackage-Customizer";
 
-celix_status_t deploymentPackage_processEntries(deployment_package_t package);
-static celix_status_t deploymentPackage_isBundleResource(properties_t attributes, bool *isBundleResource);
+celix_status_t deploymentPackage_processEntries(deployment_package_pt package);
+static celix_status_t deploymentPackage_isBundleResource(properties_pt attributes, bool *isBundleResource);
 static celix_status_t deploymentPackage_parseBooleanHeader(char *value, bool *boolValue);
 
-celix_status_t deploymentPackage_create(apr_pool_t *pool, bundle_context_t context, MANIFEST manifest, deployment_package_t *package) {
+celix_status_t deploymentPackage_create(apr_pool_t *pool, bundle_context_pt context, manifest_pt manifest, deployment_package_pt *package) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*package = apr_palloc(pool, sizeof(**package));
@@ -63,11 +63,11 @@ celix_status_t deploymentPackage_create(
 				if (status == CELIX_SUCCESS) {
 					int i;
 					for (i = 0; i < arrayList_size((*package)->bundleInfos); i++) {
-						bundle_info_t info = arrayList_get((*package)->bundleInfos, i);
+						bundle_info_pt info = arrayList_get((*package)->bundleInfos, i);
 						hashMap_put((*package)->nameToBundleInfo, info->symbolicName, info);
 					}
 					for (i = 0; i < arrayList_size((*package)->resourceInfos); i++) {
-						resource_info_t info = arrayList_get((*package)->resourceInfos, i);
+						resource_info_pt info = arrayList_get((*package)->resourceInfos, i);
 						hashMap_put((*package)->pathToEntry, info->path, info);
 					}
 				}
@@ -78,29 +78,29 @@ celix_status_t deploymentPackage_create(
 	return status;
 }
 
-celix_status_t deploymentPackage_getName(deployment_package_t package, char **name) {
+celix_status_t deploymentPackage_getName(deployment_package_pt package, char **name) {
 	*name = manifest_getValue(package->manifest, "DeploymentPackage-SymbolicName");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getBundleInfos(deployment_package_t package, array_list_t *infos) {
+celix_status_t deploymentPackage_getBundleInfos(deployment_package_pt package, array_list_pt *infos) {
 	*infos = arrayList_clone(package->pool, package->bundleInfos);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getBundleInfoByName(deployment_package_t package, char *name, bundle_info_t *info) {
+celix_status_t deploymentPackage_getBundleInfoByName(deployment_package_pt package, char *name, bundle_info_pt *info) {
 	*info = hashMap_get(package->nameToBundleInfo, name);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getBundle(deployment_package_t package, char *name, bundle_t *bundle) {
+celix_status_t deploymentPackage_getBundle(deployment_package_pt package, char *name, bundle_pt *bundle) {
 	if (hashMap_containsKey(package->nameToBundleInfo, name)) {
-		array_list_t bundles = NULL;
+		array_list_pt bundles = NULL;
 		bundleContext_getBundles(package->context, &bundles);
 		int i;
 		for (i = 0; i < arrayList_size(bundles); i++) {
-			bundle_t ibundle = arrayList_get(bundles, i);
-			module_t module = NULL;
+			bundle_pt ibundle = arrayList_get(bundles, i);
+			module_pt module = NULL;
 			bundle_getCurrentModule(ibundle, &module);
 			char *bsn = NULL;
 			module_getSymbolicName(module, &bsn);
@@ -114,36 +114,36 @@ celix_status_t deploymentPackage_getBund
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getResourceInfos(deployment_package_t package, array_list_t *infos) {
+celix_status_t deploymentPackage_getResourceInfos(deployment_package_pt package, array_list_pt *infos) {
 	*infos = arrayList_clone(package->pool, package->resourceInfos);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getResourceInfoByPath(deployment_package_t package, char *path, resource_info_t *info) {
+celix_status_t deploymentPackage_getResourceInfoByPath(deployment_package_pt package, char *path, resource_info_pt *info) {
 	*info = hashMap_get(package->pathToEntry, path);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deploymentPackage_getVersion(deployment_package_t package, version_t *version) {
+celix_status_t deploymentPackage_getVersion(deployment_package_pt package, version_pt *version) {
 	char *versionStr = manifest_getValue(package->manifest, "DeploymentPackage-Version");
 	return version_createVersionFromString(package->pool, versionStr, version);
 }
 
-celix_status_t deploymentPackage_processEntries(deployment_package_t package) {
+celix_status_t deploymentPackage_processEntries(deployment_package_pt package) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	hash_map_t entries = NULL;
+	hash_map_pt entries = NULL;
 	manifest_getEntries(package->manifest, &entries);
-	hash_map_iterator_t iter = hashMapIterator_create(entries);
+	hash_map_iterator_pt iter = hashMapIterator_create(entries);
 	while (hashMapIterator_hasNext(iter)) {
-		hash_map_entry_t entry = hashMapIterator_nextEntry(iter);
+		hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
 		char *name = hashMapEntry_getKey(entry);
-		properties_t values = hashMapEntry_getValue(entry);
+		properties_pt values = hashMapEntry_getValue(entry);
 
 		bool isBundleResource;
 		deploymentPackage_isBundleResource(values, &isBundleResource);
 		if (isBundleResource) {
-			bundle_info_t info = apr_palloc(package->pool, sizeof(*info));
+			bundle_info_pt info = apr_palloc(package->pool, sizeof(*info));
 			info->path = name;
 			info->attributes = values;
 			info->symbolicName = properties_get(values, (char *) BUNDLE_SYMBOLICNAME);
@@ -155,7 +155,7 @@ celix_status_t deploymentPackage_process
 
 			arrayList_add(package->bundleInfos, info);
 		} else {
-			resource_info_t info = apr_palloc(package->pool, sizeof(*info));
+			resource_info_pt info = apr_palloc(package->pool, sizeof(*info));
 			info->path = name;
 			info->attributes = values;
 			info->resourceProcessor = properties_get(values, (char *) RESOURCE_PROCESSOR);
@@ -167,7 +167,7 @@ celix_status_t deploymentPackage_process
 	return status;
 }
 
-static celix_status_t deploymentPackage_isBundleResource(properties_t attributes, bool *isBundleResource) {
+static celix_status_t deploymentPackage_isBundleResource(properties_pt attributes, bool *isBundleResource) {
 	*isBundleResource = properties_get(attributes, (char *) BUNDLE_SYMBOLICNAME) != NULL;
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/deployment_admin/private/src/log.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/deployment_admin/private/src/log.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/deployment_admin/private/src/log.c (original)
+++ incubator/celix/trunk/deployment_admin/private/src/log.c Wed Jun 12 19:08:50 2013
@@ -33,10 +33,10 @@
 #include "log_store.h"
 
 struct log {
-	log_store_t logStore;
+	log_store_pt logStore;
 };
 
-celix_status_t log_create(apr_pool_t *pool, log_store_t store, log_t *log) {
+celix_status_t log_create(apr_pool_t *pool, log_store_pt store, log_pt *log) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*log = apr_palloc(pool, sizeof(**log));
@@ -49,10 +49,10 @@ celix_status_t log_create(apr_pool_t *po
 	return status;
 }
 
-celix_status_t log_log(log_t log, unsigned int type, properties_t properties) {
+celix_status_t log_log(log_pt log, unsigned int type, properties_pt properties) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	log_event_t event = NULL;
+	log_event_pt event = NULL;
 
 	status = logStore_put(log->logStore, type, properties, &event);
 

Modified: incubator/celix/trunk/deployment_admin/private/src/log_store.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/deployment_admin/private/src/log_store.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/deployment_admin/private/src/log_store.c (original)
+++ incubator/celix/trunk/deployment_admin/private/src/log_store.c Wed Jun 12 19:08:50 2013
@@ -39,12 +39,12 @@ struct log_store {
 
 	unsigned long storeId;
 
-	array_list_t logEvents;
+	array_list_pt logEvents;
 };
 
-static celix_status_t logStore_getNextID(log_store_t store, unsigned long *id);
+static celix_status_t logStore_getNextID(log_store_pt store, unsigned long *id);
 
-celix_status_t logStore_create(apr_pool_t *pool, log_store_t *store) {
+celix_status_t logStore_create(apr_pool_t *pool, log_store_pt *store) {
 	celix_status_t status = CELIX_SUCCESS;
 	*store = apr_palloc(pool, sizeof(**store));
 	if (!*store) {
@@ -58,7 +58,7 @@ celix_status_t logStore_create(apr_pool_
 	return status;
 }
 
-celix_status_t logStore_put(log_store_t store, unsigned int type, properties_t properties, log_event_t *event) {
+celix_status_t logStore_put(log_store_pt store, unsigned int type, properties_pt properties, log_event_pt *event) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*event = apr_palloc(store->pool, sizeof(**event));
@@ -76,22 +76,22 @@ celix_status_t logStore_put(log_store_t 
 	return status;
 }
 
-celix_status_t logStore_getLogId(log_store_t store, unsigned long *id) {
+celix_status_t logStore_getLogId(log_store_pt store, unsigned long *id) {
 	*id = store->storeId;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t logStore_getEvents(log_store_t store, array_list_t *events) {
+celix_status_t logStore_getEvents(log_store_pt store, array_list_pt *events) {
 	*events = store->logEvents;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t logStore_getHighestId(log_store_t store, long *id) {
+celix_status_t logStore_getHighestId(log_store_pt store, long *id) {
 	*id = ((long) arrayList_size(store->logEvents)) - 1;
 	return CELIX_SUCCESS;
 }
 
-static celix_status_t logStore_getNextID(log_store_t store, unsigned long *id) {
+static celix_status_t logStore_getNextID(log_store_pt store, unsigned long *id) {
 	*id = arrayList_size(store->logEvents);
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/deployment_admin/private/src/log_sync.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/deployment_admin/private/src/log_sync.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/deployment_admin/private/src/log_sync.c (original)
+++ incubator/celix/trunk/deployment_admin/private/src/log_sync.c Wed Jun 12 19:08:50 2013
@@ -43,7 +43,7 @@
 
 struct log_sync {
 	apr_pool_t *pool;
-	log_store_t logStore;
+	log_store_pt logStore;
 
 	char *targetId;
 	bool running;
@@ -58,13 +58,13 @@ struct log_descriptor {
 	unsigned long high;
 };
 
-typedef struct log_descriptor *log_descriptor_t;
+typedef struct log_descriptor *log_descriptor_pt;
 
-celix_status_t logSync_queryLog(log_sync_t logSync, char *targetId, long logId, char **queryReply);
+celix_status_t logSync_queryLog(log_sync_pt logSync, char *targetId, long logId, char **queryReply);
 static size_t logSync_readQeury(void *contents, size_t size, size_t nmemb, void *userp);
 static void *APR_THREAD_FUNC logSync_synchronize(apr_thread_t *thd, void *logSyncP);
 
-celix_status_t logSync_create(apr_pool_t *pool, char *targetId, log_store_t store, log_sync_t *logSync) {
+celix_status_t logSync_create(apr_pool_t *pool, char *targetId, log_store_pt store, log_sync_pt *logSync) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*logSync = apr_palloc(pool, sizeof(**logSync));
@@ -83,7 +83,7 @@ celix_status_t logSync_create(apr_pool_t
 	return status;
 }
 
-celix_status_t logSync_parseLogDescriptor(log_sync_t logSync, char *descriptorString, log_descriptor_t *descriptor) {
+celix_status_t logSync_parseLogDescriptor(log_sync_pt logSync, char *descriptorString, log_descriptor_pt *descriptor) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	printf("Descriptor: %s\n", descriptorString);
@@ -119,7 +119,7 @@ celix_status_t logSync_parseLogDescripto
 }
 
 static void *APR_THREAD_FUNC logSync_synchronize(apr_thread_t *thd, void *logSyncP) {
-	log_sync_t logSync = logSyncP;
+	log_sync_pt logSync = logSyncP;
 
 		while (logSync->running) {
 
@@ -129,7 +129,7 @@ static void *APR_THREAD_FUNC logSync_syn
 		unsigned long id = 0;
 		logStore_getLogId(logSync->logStore, &id);
 		logSync_queryLog(logSync, logSync->targetId, id, &logDescriptorString);
-		log_descriptor_t descriptor = NULL;
+		log_descriptor_pt descriptor = NULL;
 		logSync_parseLogDescriptor(logSync, logDescriptorString, &descriptor);
 
 		long highest = 0;
@@ -141,9 +141,9 @@ static void *APR_THREAD_FUNC logSync_syn
 		if (highest >= 0) {
 			int i;
 			for (i = descriptor->high + 1; i <= highest; i++) {
-				array_list_t events = NULL;
+				array_list_pt events = NULL;
 				logStore_getEvents(logSync->logStore, &events);
-				log_event_t event = arrayList_get(events, i);
+				log_event_pt event = arrayList_get(events, i);
 //				printf("Event id: %ld\n", event->id);
 
 
@@ -162,7 +162,7 @@ struct MemoryStruct {
 	size_t size;
 };
 
-celix_status_t logSync_queryLog(log_sync_t logSync, char *targetId, long logId, char **queryReply) {
+celix_status_t logSync_queryLog(log_sync_pt logSync, char *targetId, long logId, char **queryReply) {
 	// http://localhost:8080/auditlog/query?tid=targetid&logid=logid
 	celix_status_t status = CELIX_SUCCESS;
 

Modified: incubator/celix/trunk/deployment_admin/public/include/resource_processor.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/deployment_admin/public/include/resource_processor.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/deployment_admin/public/include/resource_processor.h (original)
+++ incubator/celix/trunk/deployment_admin/public/include/resource_processor.h Wed Jun 12 19:08:50 2013
@@ -31,24 +31,24 @@
 
 #define RESOURCE_PROCESSOR_SERVICE "resource_processor"
 
-typedef struct resource_processor *resource_processor_t;
+typedef struct resource_processor *resource_processor_pt;
 
-typedef struct resource_processor_service *resource_processor_service_t;
+typedef struct resource_processor_service *resource_processor_service_pt;
 
 struct resource_processor_service {
-	resource_processor_t processor;
-	celix_status_t (*begin)(resource_processor_t processor, char *packageName);
+	resource_processor_pt processor;
+	celix_status_t (*begin)(resource_processor_pt processor, char *packageName);
 
-	celix_status_t (*process)(resource_processor_t processor, char *name, char *path);
+	celix_status_t (*process)(resource_processor_pt processor, char *name, char *path);
 
-	celix_status_t (*dropped)(resource_processor_t processor, char *name);
-	celix_status_t (*dropAllResources)(resource_processor_t processor);
+	celix_status_t (*dropped)(resource_processor_pt processor, char *name);
+	celix_status_t (*dropAllResources)(resource_processor_pt processor);
 
-	//celix_status_t (*prepare)(resource_processor_t processor);
-	//celix_status_t (*commit)(resource_processor_t processor);
-	//celix_status_t (*rollback)(resource_processor_t processor);
+	//celix_status_t (*prepare)(resource_processor_pt processor);
+	//celix_status_t (*commit)(resource_processor_pt processor);
+	//celix_status_t (*rollback)(resource_processor_pt processor);
 
-	//celix_status_t (*cancel)(resource_processor_t processor);
+	//celix_status_t (*cancel)(resource_processor_pt processor);
 };
 
 #endif /* RESOURCE_PROCESSOR_H_ */

Modified: incubator/celix/trunk/device_access/device_access/private/include/device_manager.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/include/device_manager.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/include/device_manager.h (original)
+++ incubator/celix/trunk/device_access/device_access/private/include/device_manager.h Wed Jun 12 19:08:50 2013
@@ -28,27 +28,27 @@
 
 #include "driver_loader.h"
 
-typedef struct device_manager *device_manager_t;
+typedef struct device_manager *device_manager_pt;
 
-celix_status_t deviceManager_create(apr_pool_t *pool, bundle_context_t context, device_manager_t *manager);
-celix_status_t deviceManager_destroy(device_manager_t manager);
+celix_status_t deviceManager_create(apr_pool_t *pool, bundle_context_pt context, device_manager_pt *manager);
+celix_status_t deviceManager_destroy(device_manager_pt manager);
 
-celix_status_t deviceManager_matchAttachDriver(device_manager_t manager, apr_pool_t *attachPool, driver_loader_t loader,
-			array_list_t driverIds, array_list_t included, array_list_t excluded, void *service, service_reference_t reference);
-celix_status_t deviceManager_noDriverFound(device_manager_t manager, void *service, service_reference_t reference);
-
-celix_status_t deviceManager_locatorAdded(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_locatorModified(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_locatorRemoved(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_deviceAdded(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_deviceModified(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_driverAdded(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_driverModified(void * handle, service_reference_t ref, void * service);
-celix_status_t deviceManager_driverRemoved(void * handle, service_reference_t ref, void * service);
+celix_status_t deviceManager_matchAttachDriver(device_manager_pt manager, apr_pool_t *attachPool, driver_loader_pt loader,
+			array_list_pt driverIds, array_list_pt included, array_list_pt excluded, void *service, service_reference_pt reference);
+celix_status_t deviceManager_noDriverFound(device_manager_pt manager, void *service, service_reference_pt reference);
+
+celix_status_t deviceManager_locatorAdded(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_locatorModified(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_locatorRemoved(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_deviceAdded(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_deviceModified(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_driverAdded(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_driverModified(void * handle, service_reference_pt ref, void * service);
+celix_status_t deviceManager_driverRemoved(void * handle, service_reference_pt ref, void * service);
 
-celix_status_t deviceManager_getBundleContext(device_manager_t manager, bundle_context_t *context);
+celix_status_t deviceManager_getBundleContext(device_manager_pt manager, bundle_context_pt *context);
 
-// celix_status_t deviceManager_match(device_manager_t manager, ...);
+// celix_status_t deviceManager_match(device_manager_pt manager, ...);
 
 #endif /* DEVICE_MANAGER_H_ */

Modified: incubator/celix/trunk/device_access/device_access/private/include/driver_attributes.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/include/driver_attributes.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/include/driver_attributes.h (original)
+++ incubator/celix/trunk/device_access/device_access/private/include/driver_attributes.h Wed Jun 12 19:08:50 2013
@@ -28,18 +28,18 @@
 
 #include "driver.h"
 
-typedef struct driver_attributes *driver_attributes_t;
+typedef struct driver_attributes *driver_attributes_pt;
 
-celix_status_t driverAttributes_create(apr_pool_t *pool, service_reference_t reference, driver_service_t driver, driver_attributes_t *attributes);
+celix_status_t driverAttributes_create(apr_pool_t *pool, service_reference_pt reference, driver_service_pt driver, driver_attributes_pt *attributes);
 
-celix_status_t driverAttributes_getReference(driver_attributes_t driverAttributes, service_reference_t *reference);
-celix_status_t driverAttributes_getDriverId(driver_attributes_t driverAttributes, char **driverId);
+celix_status_t driverAttributes_getReference(driver_attributes_pt driverAttributes, service_reference_pt *reference);
+celix_status_t driverAttributes_getDriverId(driver_attributes_pt driverAttributes, char **driverId);
 
-celix_status_t driverAttributes_match(driver_attributes_t driverAttributes, service_reference_t reference, int *match);
-celix_status_t driverAttributes_attach(driver_attributes_t driverAttributes, service_reference_t reference, char **attach);
+celix_status_t driverAttributes_match(driver_attributes_pt driverAttributes, service_reference_pt reference, int *match);
+celix_status_t driverAttributes_attach(driver_attributes_pt driverAttributes, service_reference_pt reference, char **attach);
 
-celix_status_t driverAttributes_isInUse(driver_attributes_t driverAttributes, bool *inUse);
+celix_status_t driverAttributes_isInUse(driver_attributes_pt driverAttributes, bool *inUse);
 
-celix_status_t driverAttributes_tryUninstall(driver_attributes_t driverAttributes);
+celix_status_t driverAttributes_tryUninstall(driver_attributes_pt driverAttributes);
 
 #endif /* DRIVER_ATTRIBUTES_H_ */

Modified: incubator/celix/trunk/device_access/device_access/private/include/driver_loader.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/include/driver_loader.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/include/driver_loader.h (original)
+++ incubator/celix/trunk/device_access/device_access/private/include/driver_loader.h Wed Jun 12 19:08:50 2013
@@ -31,17 +31,17 @@
 
 #define DRIVER_LOCATION_PREFIX "_DD_"
 
-typedef struct driver_loader *driver_loader_t;
+typedef struct driver_loader *driver_loader_pt;
 
-celix_status_t driverLoader_create(apr_pool_t *pool, bundle_context_t context, driver_loader_t *loader);
+celix_status_t driverLoader_create(apr_pool_t *pool, bundle_context_pt context, driver_loader_pt *loader);
 
-celix_status_t driverLoader_findDrivers(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, properties_t properties, array_list_t *driversIds);
-celix_status_t driverLoader_findDriversForLocator(driver_loader_t loader, apr_pool_t *pool, driver_locator_service_t locator, properties_t properties, array_list_t *driversIds);
+celix_status_t driverLoader_findDrivers(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, properties_pt properties, array_list_pt *driversIds);
+celix_status_t driverLoader_findDriversForLocator(driver_loader_pt loader, apr_pool_t *pool, driver_locator_service_pt locator, properties_pt properties, array_list_pt *driversIds);
 
-celix_status_t driverLoader_loadDrivers(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, array_list_t driverIds, array_list_t *references);
-celix_status_t driverLoader_loadDriver(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, char *driverId, array_list_t *references);
-celix_status_t driverLoader_loadDriverForLocator(driver_loader_t loader, apr_pool_t *pool, driver_locator_service_t locator, char *driverId, array_list_t *references);
+celix_status_t driverLoader_loadDrivers(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, array_list_pt driverIds, array_list_pt *references);
+celix_status_t driverLoader_loadDriver(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, char *driverId, array_list_pt *references);
+celix_status_t driverLoader_loadDriverForLocator(driver_loader_pt loader, apr_pool_t *pool, driver_locator_service_pt locator, char *driverId, array_list_pt *references);
 
-celix_status_t driverLoader_unloadDrivers(driver_loader_t loader, driver_attributes_t finalDriver);
+celix_status_t driverLoader_unloadDrivers(driver_loader_pt loader, driver_attributes_pt finalDriver);
 
 #endif /* DRIVER_LOADER_H_ */

Modified: incubator/celix/trunk/device_access/device_access/private/include/driver_matcher.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/include/driver_matcher.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/include/driver_matcher.h (original)
+++ incubator/celix/trunk/device_access/device_access/private/include/driver_matcher.h Wed Jun 12 19:08:50 2013
@@ -30,12 +30,12 @@
 #include "driver_selector.h"
 #include "driver_attributes.h"
 
-typedef struct driver_matcher *driver_matcher_t;
+typedef struct driver_matcher *driver_matcher_pt;
 
-celix_status_t driverMatcher_create(apr_pool_t *pool, bundle_context_t context, driver_matcher_t *matcher);
+celix_status_t driverMatcher_create(apr_pool_t *pool, bundle_context_pt context, driver_matcher_pt *matcher);
 
-celix_status_t driverMatcher_add(driver_matcher_t matcher, int match, driver_attributes_t attributes);
+celix_status_t driverMatcher_add(driver_matcher_pt matcher, int match, driver_attributes_pt attributes);
 
-celix_status_t driverMatcher_getBestMatch(driver_matcher_t matcher, apr_pool_t *pool, service_reference_t reference, match_t *match);
+celix_status_t driverMatcher_getBestMatch(driver_matcher_pt matcher, apr_pool_t *pool, service_reference_pt reference, match_pt *match);
 
 #endif /* DRIVER_MATCHER_H_ */

Modified: incubator/celix/trunk/device_access/device_access/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/src/activator.c (original)
+++ incubator/celix/trunk/device_access/device_access/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -35,24 +35,24 @@
 #include "device_manager.h"
 
 struct device_manager_bundle_instance {
-	bundle_context_t context;
+	bundle_context_pt context;
 	apr_pool_t *pool;
-	device_manager_t deviceManager;
-	service_tracker_t driverLocatorTracker;
-	service_tracker_t driverTracker;
-	service_tracker_t deviceTracker;
+	device_manager_pt deviceManager;
+	service_tracker_pt driverLocatorTracker;
+	service_tracker_pt driverTracker;
+	service_tracker_pt deviceTracker;
 };
 
-typedef struct device_manager_bundle_instance *device_manager_bundle_instance_t;
+typedef struct device_manager_bundle_instance *device_manager_bundle_instance_pt;
 
-static celix_status_t deviceManagerBundle_createDriverLocatorTracker(device_manager_bundle_instance_t bundleData);
-static celix_status_t deviceManagerBundle_createDriverTracker(device_manager_bundle_instance_t bundleData);
-static celix_status_t deviceManagerBundle_createDeviceTracker(device_manager_bundle_instance_t bundleData);
+static celix_status_t deviceManagerBundle_createDriverLocatorTracker(device_manager_bundle_instance_pt bundleData);
+static celix_status_t deviceManagerBundle_createDriverTracker(device_manager_bundle_instance_pt bundleData);
+static celix_status_t deviceManagerBundle_createDeviceTracker(device_manager_bundle_instance_pt bundleData);
 
-celix_status_t addingService_dummy_func(void * handle, service_reference_t reference, void **service) {
+celix_status_t addingService_dummy_func(void * handle, service_reference_pt reference, void **service) {
 	celix_status_t status = CELIX_SUCCESS;
-	device_manager_t dm = handle;
-	bundle_context_t context = NULL;
+	device_manager_pt dm = handle;
+	bundle_context_pt context = NULL;
 	status = deviceManager_getBundleContext(dm, &context);
 	if (status == CELIX_SUCCESS) {
 		status = bundleContext_getService(context, reference, service);
@@ -60,12 +60,12 @@ celix_status_t addingService_dummy_func(
 	return status;
 }
 
-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;
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
-		device_manager_bundle_instance_t bi = apr_palloc(pool, sizeof(struct device_manager_bundle_instance));
+		device_manager_bundle_instance_pt bi = apr_palloc(pool, sizeof(struct device_manager_bundle_instance));
 		if (bi == NULL) {
 			status = CELIX_ENOMEM;
 		} else {
@@ -78,9 +78,9 @@ 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;
-	device_manager_bundle_instance_t bundleData = userData;
+	device_manager_bundle_instance_pt bundleData = userData;
 	apr_pool_t *pool;
 	status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
@@ -110,16 +110,16 @@ celix_status_t bundleActivator_start(voi
 	return status;
 }
 
-static celix_status_t deviceManagerBundle_createDriverLocatorTracker(device_manager_bundle_instance_t bundleData) {
+static celix_status_t deviceManagerBundle_createDriverLocatorTracker(device_manager_bundle_instance_pt bundleData) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	service_tracker_customizer_t customizer = NULL;
+	service_tracker_customizer_pt customizer = NULL;
 
 	status = serviceTrackerCustomizer_create(bundleData->pool, bundleData->deviceManager, addingService_dummy_func,
 			deviceManager_locatorAdded, deviceManager_locatorModified, deviceManager_locatorRemoved, &customizer);
 
 	if (status == CELIX_SUCCESS) {
-		service_tracker_t tracker = NULL;
+		service_tracker_pt tracker = NULL;
 		status = serviceTracker_create(bundleData->pool, bundleData->context, "driver_locator", customizer, &tracker);
 		if (status == CELIX_SUCCESS) {
 			bundleData->driverLocatorTracker=tracker;
@@ -130,16 +130,16 @@ static celix_status_t deviceManagerBundl
 	return status;
 }
 
-static celix_status_t deviceManagerBundle_createDriverTracker(device_manager_bundle_instance_t bundleData) {
+static celix_status_t deviceManagerBundle_createDriverTracker(device_manager_bundle_instance_pt bundleData) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	service_tracker_customizer_t customizer = NULL;
+	service_tracker_customizer_pt customizer = NULL;
 
 	status = serviceTrackerCustomizer_create(bundleData->pool, bundleData->deviceManager, addingService_dummy_func,
 			deviceManager_locatorAdded, deviceManager_locatorModified, deviceManager_locatorRemoved, &customizer);
 
 	if (status == CELIX_SUCCESS) {
-		service_tracker_t tracker = NULL;
+		service_tracker_pt tracker = NULL;
 		status = serviceTracker_createWithFilter(bundleData->pool, bundleData->context, "(objectClass=driver)", customizer, &tracker);
 		if (status == CELIX_SUCCESS) {
 			bundleData->driverTracker=tracker;
@@ -150,16 +150,16 @@ static celix_status_t deviceManagerBundl
 	return status;
 }
 
-static celix_status_t deviceManagerBundle_createDeviceTracker(device_manager_bundle_instance_t bundleData) {
+static celix_status_t deviceManagerBundle_createDeviceTracker(device_manager_bundle_instance_pt bundleData) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	service_tracker_customizer_t customizer = NULL;
+	service_tracker_customizer_pt customizer = NULL;
 
 	status = serviceTrackerCustomizer_create(bundleData->pool, bundleData->deviceManager, addingService_dummy_func,
 			deviceManager_locatorAdded, deviceManager_locatorModified, deviceManager_locatorRemoved, &customizer);
 
 	if (status == CELIX_SUCCESS) {
-		service_tracker_t tracker = NULL;
+		service_tracker_pt tracker = NULL;
 		status = serviceTracker_createWithFilter(bundleData->pool, bundleData->context, "(|(objectClass=device)(DEVICE_CATEGORY=*))", customizer, &tracker);
 		if (status == CELIX_SUCCESS) {
 			bundleData->deviceTracker=tracker;
@@ -170,9 +170,9 @@ static celix_status_t deviceManagerBundl
 	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;
-	device_manager_bundle_instance_t bundleData = userData;
+	device_manager_bundle_instance_pt bundleData = userData;
 //	status = serviceTracker_close(bundleData->driverLocatorTracker);
 	if (status == CELIX_SUCCESS) {
 		status = serviceTracker_close(bundleData->driverTracker);
@@ -183,9 +183,9 @@ 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;
-	device_manager_bundle_instance_t bundleData = userData;
+	device_manager_bundle_instance_pt bundleData = userData;
 	deviceManager_destroy(bundleData->deviceManager);
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/device_access/device_access/private/src/device_manager.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/src/device_manager.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/src/device_manager.c (original)
+++ incubator/celix/trunk/device_access/device_access/private/src/device_manager.c Wed Jun 12 19:08:50 2013
@@ -43,18 +43,18 @@
 
 struct device_manager {
 	apr_pool_t *pool;
-	bundle_context_t context;
-	hash_map_t devices;
-	hash_map_t drivers;
-	array_list_t locators;
-	driver_selector_service_t selector;
+	bundle_context_pt context;
+	hash_map_pt devices;
+	hash_map_pt drivers;
+	array_list_pt locators;
+	driver_selector_service_pt selector;
 };
 
-static celix_status_t deviceManager_attachAlgorithm(device_manager_t manager, service_reference_t ref, void *service);
-static celix_status_t deviceManager_getIdleDevices(device_manager_t manager, apr_pool_t *pool, array_list_t *idleDevices);
-static celix_status_t deviceManager_isDriverBundle(device_manager_t manager, bundle_t bundle, bool *isDriver);
+static celix_status_t deviceManager_attachAlgorithm(device_manager_pt manager, service_reference_pt ref, void *service);
+static celix_status_t deviceManager_getIdleDevices(device_manager_pt manager, apr_pool_t *pool, array_list_pt *idleDevices);
+static celix_status_t deviceManager_isDriverBundle(device_manager_pt manager, bundle_pt bundle, bool *isDriver);
 
-celix_status_t deviceManager_create(apr_pool_t *pool, bundle_context_t context, device_manager_t *manager) {
+celix_status_t deviceManager_create(apr_pool_t *pool, bundle_context_pt context, device_manager_pt *manager) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*manager = apr_palloc(pool, sizeof(**manager));
@@ -77,7 +77,7 @@ celix_status_t deviceManager_create(apr_
 	return status;
 }
 
-celix_status_t deviceManager_destroy(device_manager_t manager) {
+celix_status_t deviceManager_destroy(device_manager_pt manager) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	printf("DEVICE_MANAGER: Stop\n");
@@ -88,55 +88,55 @@ celix_status_t deviceManager_destroy(dev
 	return status;
 }
 
-celix_status_t deviceManager_selectorAdded(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_selectorAdded(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Add selector\n");
-	device_manager_t manager = handle;
-	manager->selector = (driver_selector_service_t) service;
+	device_manager_pt manager = handle;
+	manager->selector = (driver_selector_service_pt) service;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_selectorModified(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_selectorModified(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Modify selector\n");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_selectorRemoved(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_selectorRemoved(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Remove selector\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	manager->selector = NULL;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_locatorAdded(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_locatorAdded(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Add locator\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	arrayList_add(manager->locators, service);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_locatorModified(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_locatorModified(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Modify locator\n");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_locatorRemoved(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_locatorRemoved(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Remove locator\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	arrayList_removeElement(manager->locators, service);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_deviceAdded(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_deviceAdded(void * handle, service_reference_pt ref, void * service) {
 	celix_status_t status = CELIX_SUCCESS;
 	printf("DEVICE_MANAGER: Add device\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 
 	status = deviceManager_attachAlgorithm(manager, ref, service);
 
 	return status;
 }
 
-static celix_status_t deviceManager_attachAlgorithm(device_manager_t manager, service_reference_t ref, void *service) {
+static celix_status_t deviceManager_attachAlgorithm(device_manager_pt manager, service_reference_pt ref, void *service) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	apr_pool_t *attachPool = NULL;
@@ -144,13 +144,13 @@ static celix_status_t deviceManager_atta
 	if (aprStatus != APR_SUCCESS) {
 		status = CELIX_ILLEGAL_STATE;
 	} else {
-		driver_loader_t loader = NULL;
+		driver_loader_pt loader = NULL;
 		status = driverLoader_create(attachPool, manager->context, &loader);
 		if (status == CELIX_SUCCESS) {
-			array_list_t included = NULL;
-			array_list_t excluded = NULL;
+			array_list_pt included = NULL;
+			array_list_pt excluded = NULL;
 
-			array_list_t driverIds = NULL;
+			array_list_pt driverIds = NULL;
 
 			hashMap_put(manager->devices, ref, service);
 
@@ -158,17 +158,17 @@ static celix_status_t deviceManager_atta
 			if (status == CELIX_SUCCESS) {
 				status = arrayList_create(attachPool, &excluded);
 				if (status == CELIX_SUCCESS) {
-					service_registration_t registration = NULL;
+					service_registration_pt registration = NULL;
 					status = serviceReference_getServiceRegistration(ref, &registration);
 					if (status == CELIX_SUCCESS) {
-						properties_t properties = NULL;
+						properties_pt properties = NULL;
 						status = serviceRegistration_getProperties(registration, &properties);
 						if (status == CELIX_SUCCESS) {
 							status = driverLoader_findDrivers(loader, attachPool, manager->locators, properties, &driverIds);
 							if (status == CELIX_SUCCESS) {
-								hash_map_iterator_t iter = hashMapIterator_create(manager->drivers);
+								hash_map_iterator_pt iter = hashMapIterator_create(manager->drivers);
 								while (hashMapIterator_hasNext(iter)) {
-									driver_attributes_t driverAttributes = hashMapIterator_nextValue(iter);
+									driver_attributes_pt driverAttributes = hashMapIterator_nextValue(iter);
 									arrayList_add(included, driverAttributes);
 
 									// Each driver that already is installed can be removed from the list
@@ -176,7 +176,7 @@ static celix_status_t deviceManager_atta
 									celix_status_t substatus = driverAttributes_getDriverId(driverAttributes, &id);
 									if (substatus == CELIX_SUCCESS) {
 										// arrayList_removeElement(driverIds, id);
-										array_list_iterator_t idsIter = arrayListIterator_create(driverIds);
+										array_list_iterator_pt idsIter = arrayListIterator_create(driverIds);
 										while (arrayListIterator_hasNext(idsIter)) {
 											char *value = arrayListIterator_next(idsIter);
 											if (strcmp(value, id) == 0) {
@@ -206,11 +206,11 @@ static celix_status_t deviceManager_atta
 	return status;
 }
 
-celix_status_t deviceManager_matchAttachDriver(device_manager_t manager, apr_pool_t *attachPool, driver_loader_t loader,
-		array_list_t driverIds, array_list_t included, array_list_t excluded, void *service, service_reference_t reference) {
+celix_status_t deviceManager_matchAttachDriver(device_manager_pt manager, apr_pool_t *attachPool, driver_loader_pt loader,
+		array_list_pt driverIds, array_list_pt included, array_list_pt excluded, void *service, service_reference_pt reference) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	array_list_t references = NULL;
+	array_list_pt references = NULL;
 
 	int i;
 	for (i = 0; i < arrayList_size(excluded); i++) {
@@ -226,18 +226,18 @@ celix_status_t deviceManager_matchAttach
 	status = driverLoader_loadDrivers(loader, attachPool, manager->locators, driverIds, &references);
 	if (status == CELIX_SUCCESS) {
 		for (i = 0; i < arrayList_size(references); i++) {
-			service_reference_t reference = arrayList_get(references, i);
-			driver_attributes_t attributes = hashMap_get(manager->drivers, reference);
+			service_reference_pt reference = arrayList_get(references, i);
+			driver_attributes_pt attributes = hashMap_get(manager->drivers, reference);
 			if (attributes != NULL) {
 				arrayList_add(included, attributes);
 			}
 		}
 
-		driver_matcher_t matcher = NULL;
+		driver_matcher_pt matcher = NULL;
 		status = driverMatcher_create(attachPool, manager->context, &matcher);
 		if (status == CELIX_SUCCESS) {
 			for (i = 0; i < arrayList_size(included); i++) {
-				driver_attributes_t attributes = arrayList_get(included, i);
+				driver_attributes_pt attributes = arrayList_get(included, i);
 
 				int match = 0;
 				celix_status_t substatus = driverAttributes_match(attributes, reference, &match);
@@ -252,20 +252,20 @@ celix_status_t deviceManager_matchAttach
 				}
 			}
 
-			match_t match = NULL;
+			match_pt match = NULL;
 			status = driverMatcher_getBestMatch(matcher, attachPool, reference, &match);
 			if (status == CELIX_SUCCESS) {
 				if (match == NULL) {
 					status = deviceManager_noDriverFound(manager, service, reference);
 				} else {
-					service_registration_t registration = NULL;
+					service_registration_pt registration = NULL;
 					status = serviceReference_getServiceRegistration(match->reference, &registration);
 					if (status == CELIX_SUCCESS) {
-						properties_t properties = NULL;
+						properties_pt properties = NULL;
 						status = serviceRegistration_getProperties(registration, &properties);
 						if (status == CELIX_SUCCESS) {
 							char *driverId = properties_get(properties, (char *) DRIVER_ID);
-							driver_attributes_t finalAttributes = hashMap_get(manager->drivers, match->reference);
+							driver_attributes_pt finalAttributes = hashMap_get(manager->drivers, match->reference);
 							if (finalAttributes == NULL) {
 								status = deviceManager_noDriverFound(manager, service, reference);
 							} else {
@@ -273,7 +273,7 @@ celix_status_t deviceManager_matchAttach
 								status = driverAttributes_attach(finalAttributes, reference, &newDriverId);
 								if (status == CELIX_SUCCESS) {
 									if (newDriverId != NULL) {
-										array_list_t ids = NULL;
+										array_list_pt ids = NULL;
 										arrayList_create(attachPool, &ids);
 										arrayList_add(ids, newDriverId);
 										arrayList_add(excluded, finalAttributes);
@@ -299,17 +299,17 @@ celix_status_t deviceManager_matchAttach
 	return status;
 }
 
-celix_status_t deviceManager_noDriverFound(device_manager_t manager, void *service, service_reference_t reference) {
+celix_status_t deviceManager_noDriverFound(device_manager_pt manager, void *service, service_reference_pt reference) {
 	celix_status_t status = CELIX_SUCCESS;
-	service_registration_t registration = NULL;
+	service_registration_pt registration = NULL;
 	status = serviceReference_getServiceRegistration(reference, &registration);
 	if (status == CELIX_SUCCESS) {
-		properties_t properties = NULL;
+		properties_pt properties = NULL;
 		status = serviceRegistration_getProperties(registration, &properties);
 		if (status == CELIX_SUCCESS) {
 			char *objectClass = properties_get(properties, (char *) OBJECTCLASS);
 			if (strcmp(objectClass, DRIVER_SERVICE_NAME) == 0) {
-				device_service_t device = service;
+				device_service_pt device = service;
 				status = device->noDriverFound(device->device);
 			}
 		}
@@ -317,28 +317,28 @@ celix_status_t deviceManager_noDriverFou
 	return status;
 }
 
-celix_status_t deviceManager_deviceModified(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_deviceModified(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Modify device\n");
 	// #TODO the device properties could be changed
-	//device_manager_t manager = handle;
+	//device_manager_pt manager = handle;
 	//hashMap_put(manager->devices, ref, service);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Remove device\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	hashMap_remove(manager->devices, ref);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_driverAdded(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_driverAdded(void * handle, service_reference_pt ref, void * service) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	printf("DEVICE_MANAGER: Add driver\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	apr_pool_t *pool = NULL;
-	driver_attributes_t attributes = NULL;
+	driver_attributes_pt attributes = NULL;
 
 	status = apr_pool_create(&pool, manager->pool);
 	if (status == CELIX_SUCCESS) {
@@ -350,17 +350,17 @@ celix_status_t deviceManager_driverAdded
 	return status;
 }
 
-celix_status_t deviceManager_driverModified(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_driverModified(void * handle, service_reference_pt ref, void * service) {
 	printf("DEVICE_MANAGER: Modify driver\n");
 	// #TODO the driver properties could be changed?
 	return CELIX_SUCCESS;
 }
 
-celix_status_t deviceManager_driverRemoved(void * handle, service_reference_t ref, void * service) {
+celix_status_t deviceManager_driverRemoved(void * handle, service_reference_pt ref, void * service) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	printf("DEVICE_MANAGER: Remove driver\n");
-	device_manager_t manager = handle;
+	device_manager_pt manager = handle;
 	hashMap_remove(manager->drivers, ref);
 
 	apr_pool_t *idleCheckPool;
@@ -368,18 +368,18 @@ celix_status_t deviceManager_driverRemov
 	if (aprStatus != APR_SUCCESS) {
 		status = CELIX_ILLEGAL_ARGUMENT;
 	} else {
-		array_list_t idleDevices = NULL;
+		array_list_pt idleDevices = NULL;
 		status = deviceManager_getIdleDevices(manager, idleCheckPool, &idleDevices);
 		if (status == CELIX_SUCCESS) {
 			int i;
 			for (i = 0; i < arrayList_size(idleDevices); i++) {
 				celix_status_t forStatus = CELIX_SUCCESS;
-				service_reference_t ref = arrayList_get(idleDevices, i);
+				service_reference_pt ref = arrayList_get(idleDevices, i);
 				char *bsn = NULL;
-				bundle_t bundle = NULL;
+				bundle_pt bundle = NULL;
 				forStatus = serviceReference_getBundle(ref, &bundle);
 				if (forStatus == CELIX_SUCCESS) {
-					module_t module = NULL;
+					module_pt module = NULL;
 					forStatus = bundle_getCurrentModule(bundle, &module);
 					if (forStatus == CELIX_SUCCESS) {
 						forStatus = module_getSymbolicName(module, &bsn);
@@ -404,9 +404,9 @@ celix_status_t deviceManager_driverRemov
 			}
 
 
-			hash_map_iterator_t iter = hashMapIterator_create(manager->drivers);
+			hash_map_iterator_pt iter = hashMapIterator_create(manager->drivers);
 			while (hashMapIterator_hasNext(iter)) {
-				driver_attributes_t da = hashMapIterator_nextValue(iter);
+				driver_attributes_pt da = hashMapIterator_nextValue(iter);
 				//driverAttributes_tryUninstall(da);
 			}
 			hashMapIterator_destroy(iter);
@@ -421,42 +421,42 @@ celix_status_t deviceManager_driverRemov
 }
 
 
-celix_status_t deviceManager_getIdleDevices(device_manager_t manager, apr_pool_t *pool, array_list_t *idleDevices) {
+celix_status_t deviceManager_getIdleDevices(device_manager_pt manager, apr_pool_t *pool, array_list_pt *idleDevices) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = arrayList_create(pool, idleDevices);
 	if (status == CELIX_SUCCESS) {
-		hash_map_iterator_t iter = hashMapIterator_create(manager->devices);
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->devices);
 		while (hashMapIterator_hasNext(iter)) {
 			celix_status_t substatus = CELIX_SUCCESS;
-			service_reference_t ref = hashMapIterator_nextKey(iter);
+			service_reference_pt ref = hashMapIterator_nextKey(iter);
 			char *bsn = NULL;
-			module_t module = NULL;
-			bundle_t bundle = NULL;
+			module_pt module = NULL;
+			bundle_pt bundle = NULL;
 			substatus = serviceReference_getBundle(ref, &bundle);
 			if (substatus == CELIX_SUCCESS) {
 				substatus = bundle_getCurrentModule(bundle, &module);
 				if (substatus == CELIX_SUCCESS) {
 					substatus = module_getSymbolicName(module, &bsn);
 					if (substatus == CELIX_SUCCESS) {
-						service_registration_t registration = NULL;
+						service_registration_pt registration = NULL;
 						substatus = serviceReference_getServiceRegistration(ref, &registration);
 						if (substatus == CELIX_SUCCESS) {
-							service_registry_t registry = NULL;
+							service_registry_pt registry = NULL;
 							substatus = serviceRegistration_getRegistry(registration, &registry);
 							if (substatus == CELIX_SUCCESS) {
 								printf("DEVICE_MANAGER: Check idle device: %s\n", bsn);
-								array_list_t bundles = serviceRegistry_getUsingBundles(registry, pool, ref);
+								array_list_pt bundles = serviceRegistry_getUsingBundles(registry, pool, ref);
 								bool inUse = false;
 								int i;
 								for (i = 0; i < arrayList_size(bundles); i++) {
-									bundle_t bundle = arrayList_get(bundles, i);
+									bundle_pt bundle = arrayList_get(bundles, i);
 									bool isDriver;
 									celix_status_t sstatus = deviceManager_isDriverBundle(manager, bundle, &isDriver);
 									if (sstatus == CELIX_SUCCESS) {
 										if (isDriver) {
 											char *bsn = NULL;
-											module_t module = NULL;
+											module_pt module = NULL;
 											bundle_getCurrentModule(bundle, &module);
 											module_getSymbolicName(module, &bsn);
 
@@ -485,20 +485,20 @@ celix_status_t deviceManager_getIdleDevi
 
 //TODO examply for discussion only, remove after discussion
 #define DO_IF_SUCCESS(status, call_func) ((status) == CELIX_SUCCESS) ? (call_func) : (status)
-celix_status_t deviceManager_getIdleDevices_exmaple(device_manager_t manager, apr_pool_t *pool, array_list_t *idleDevices) {
+celix_status_t deviceManager_getIdleDevices_exmaple(device_manager_pt manager, apr_pool_t *pool, array_list_pt *idleDevices) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = arrayList_create(pool, idleDevices);
 	if (status == CELIX_SUCCESS) {
-		hash_map_iterator_t iter = hashMapIterator_create(manager->devices);
+		hash_map_iterator_pt iter = hashMapIterator_create(manager->devices);
 		while (hashMapIterator_hasNext(iter)) {
 			celix_status_t substatus = CELIX_SUCCESS;
-			service_reference_t ref = hashMapIterator_nextKey(iter);
+			service_reference_pt ref = hashMapIterator_nextKey(iter);
 			char *bsn = NULL;
-			module_t module = NULL;
-			bundle_t bundle = NULL;
-			service_registration_t registration = NULL;
-			service_registry_t registry = NULL;
+			module_pt module = NULL;
+			bundle_pt bundle = NULL;
+			service_registration_pt registration = NULL;
+			service_registry_pt registry = NULL;
 			substatus = serviceReference_getBundle(ref, &bundle);
 			substatus = DO_IF_SUCCESS(substatus, bundle_getCurrentModule(bundle, &module));
 			substatus = DO_IF_SUCCESS(substatus, module_getSymbolicName(module, &bsn));
@@ -506,18 +506,18 @@ celix_status_t deviceManager_getIdleDevi
 			substatus = DO_IF_SUCCESS(substatus, serviceRegistration_getRegistry(registration, &registry));
 
 			if (substatus == CELIX_SUCCESS) {
-				array_list_t bundles = serviceRegistry_getUsingBundles(registry, pool, ref);
+				array_list_pt bundles = serviceRegistry_getUsingBundles(registry, pool, ref);
 				printf("DEVICE_MANAGER: Check idle device: %s\n", bsn);
 				bool inUse = false;
 				int i;
 				for (i = 0; i < arrayList_size(bundles); i++) {
-					bundle_t bundle = arrayList_get(bundles, i);
+					bundle_pt bundle = arrayList_get(bundles, i);
 					bool isDriver;
 					celix_status_t sstatus = deviceManager_isDriverBundle(manager, bundle, &isDriver);
 					if (sstatus == CELIX_SUCCESS) {
 						if (isDriver) {
 							char *bsn = NULL;
-							module_t module = NULL;
+							module_pt module = NULL;
 							bundle_getCurrentModule(bundle, &module);
 							module_getSymbolicName(module, &bsn);
 
@@ -538,11 +538,11 @@ celix_status_t deviceManager_getIdleDevi
 	return status;
 }
 
-celix_status_t deviceManager_isDriverBundle(device_manager_t manager, bundle_t bundle, bool *isDriver) {
+celix_status_t deviceManager_isDriverBundle(device_manager_pt manager, bundle_pt bundle, bool *isDriver) {
 	celix_status_t status = CELIX_SUCCESS;
 	(*isDriver) = false;
 
-	array_list_t refs = NULL;
+	array_list_pt refs = NULL;
 	apr_pool_t *pool = NULL;
 	status = bundle_getMemoryPool(bundle, &pool);
 	if (status == CELIX_SUCCESS) {
@@ -552,11 +552,11 @@ celix_status_t deviceManager_isDriverBun
 				int i;
 				for (i = 0; i < arrayList_size(refs); i++) {
 					celix_status_t substatus = CELIX_SUCCESS;
-					service_reference_t ref = arrayList_get(refs, i);
-					service_registration_t registration = NULL;
+					service_reference_pt ref = arrayList_get(refs, i);
+					service_registration_pt registration = NULL;
 					substatus = serviceReference_getServiceRegistration(ref, &registration);
 					if (substatus == CELIX_SUCCESS) {
-						properties_t properties = NULL;
+						properties_pt properties = NULL;
 						substatus = serviceRegistration_getProperties(registration, &properties);
 						if (substatus == CELIX_SUCCESS) {
 							char *object = properties_get(properties, (char *) OBJECTCLASS);
@@ -578,7 +578,7 @@ celix_status_t deviceManager_isDriverBun
 }
 
 
-celix_status_t deviceManager_getBundleContext(device_manager_t manager, bundle_context_t *context) {
+celix_status_t deviceManager_getBundleContext(device_manager_pt manager, bundle_context_pt *context) {
 	celix_status_t status = CELIX_SUCCESS;
 	if (manager->context != NULL) {
 		(*context) = manager->context;

Modified: incubator/celix/trunk/device_access/device_access/private/src/driver_attributes.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/src/driver_attributes.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/src/driver_attributes.c (original)
+++ incubator/celix/trunk/device_access/device_access/private/src/driver_attributes.c Wed Jun 12 19:08:50 2013
@@ -36,21 +36,21 @@
 struct driver_attributes {
 	apr_pool_t *pool;
 
-	bundle_t bundle;
-	service_reference_t reference;
-	driver_service_t driver;
+	bundle_pt bundle;
+	service_reference_pt reference;
+	driver_service_pt driver;
 	bool dynamic;
 };
 
-celix_status_t driverAttributes_create(apr_pool_t *pool, service_reference_t reference, driver_service_t driver, driver_attributes_t *attributes) {
+celix_status_t driverAttributes_create(apr_pool_t *pool, service_reference_pt reference, driver_service_pt driver, driver_attributes_pt *attributes) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*attributes = apr_palloc(pool, sizeof(**attributes));
 	if (!*attributes) {
 		status = CELIX_ENOMEM;
 	} else {
-		bundle_t bundle = NULL;
-		bundle_archive_t bundleArchive = NULL;
+		bundle_pt bundle = NULL;
+		bundle_archive_pt bundleArchive = NULL;
 		status = serviceReference_getBundle(reference, &bundle);
 
 		if (status == CELIX_SUCCESS) {
@@ -75,19 +75,19 @@ celix_status_t driverAttributes_create(a
 	return status;
 }
 
-celix_status_t driverAttributes_getReference(driver_attributes_t driverAttributes, service_reference_t *reference) {
+celix_status_t driverAttributes_getReference(driver_attributes_pt driverAttributes, service_reference_pt *reference) {
 	*reference = driverAttributes->reference;
 
 	return CELIX_SUCCESS;
 }
 
-celix_status_t driverAttributes_getDriverId(driver_attributes_t driverAttributes, char **driverId) {
+celix_status_t driverAttributes_getDriverId(driver_attributes_pt driverAttributes, char **driverId) {
 	celix_status_t status = CELIX_SUCCESS;
-	service_registration_t registration = NULL;
+	service_registration_pt registration = NULL;
 	status = serviceReference_getServiceRegistration(driverAttributes->reference, &registration);
 
 	if (status == CELIX_SUCCESS) {
-		properties_t properties = NULL;
+		properties_pt properties = NULL;
 		status = serviceRegistration_getProperties(registration, &properties);
 
 		if (status == CELIX_SUCCESS) {
@@ -108,7 +108,7 @@ celix_status_t driverAttributes_getDrive
 	return status;
 }
 
-celix_status_t driverAttributes_match(driver_attributes_t driverAttributes, service_reference_t reference, int *match) {
+celix_status_t driverAttributes_match(driver_attributes_pt driverAttributes, service_reference_pt reference, int *match) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = driverAttributes->driver->match(driverAttributes->driver->driver, reference, match);
@@ -116,13 +116,13 @@ celix_status_t driverAttributes_match(dr
 	return status;
 }
 
-celix_status_t static get_property_from_registration(service_reference_t ref, char *key, char **prop_value)  {
+celix_status_t static get_property_from_registration(service_reference_pt ref, char *key, char **prop_value)  {
 	celix_status_t status = CELIX_SUCCESS;
-	service_registration_t registration = NULL;
+	service_registration_pt registration = NULL;
 	status = serviceReference_getServiceRegistration(ref, &registration);
 
 	if (status == CELIX_SUCCESS) {
-		properties_t properties = NULL;
+		properties_pt properties = NULL;
 		status = serviceRegistration_getProperties(registration, &properties);
 
 		if (status == CELIX_SUCCESS) {
@@ -138,10 +138,10 @@ celix_status_t static get_property_from_
 }
 
 
-celix_status_t driverAttributes_isInUse(driver_attributes_t driverAttributes, bool *inUse) {
+celix_status_t driverAttributes_isInUse(driver_attributes_pt driverAttributes, bool *inUse) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	array_list_t references = NULL;
+	array_list_pt references = NULL;
 	status = bundle_getServicesInUse(driverAttributes->bundle, &references);
 	if (status == CELIX_SUCCESS) {
 		if (references == NULL || arrayList_size(references) == 0) {
@@ -149,7 +149,7 @@ celix_status_t driverAttributes_isInUse(
 		} else {
 			int i;
 			for (i = 0; i < arrayList_size(references); i++) {
-				service_reference_t ref = arrayList_get(references, i);
+				service_reference_pt ref = arrayList_get(references, i);
 				char *object = NULL;
 				status = get_property_from_registration(ref, (char *) OBJECTCLASS, &object);
 
@@ -170,7 +170,7 @@ celix_status_t driverAttributes_isInUse(
 	return status;
 }
 
-celix_status_t driverAttributes_attach(driver_attributes_t driverAttributes, service_reference_t reference, char **attach) {
+celix_status_t driverAttributes_attach(driver_attributes_pt driverAttributes, service_reference_pt reference, char **attach) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = driverAttributes->driver->attach(driverAttributes->driver->driver, reference, attach);
@@ -178,7 +178,7 @@ celix_status_t driverAttributes_attach(d
 	return status;
 }
 
-celix_status_t driverAttributes_tryUninstall(driver_attributes_t driverAttributes) {
+celix_status_t driverAttributes_tryUninstall(driver_attributes_pt driverAttributes) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	bool inUse = false;

Modified: incubator/celix/trunk/device_access/device_access/private/src/driver_loader.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/src/driver_loader.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/src/driver_loader.c (original)
+++ incubator/celix/trunk/device_access/device_access/private/src/driver_loader.c Wed Jun 12 19:08:50 2013
@@ -34,13 +34,13 @@
 struct driver_loader {
 	apr_pool_t *pool;
 
-	bundle_context_t context;
-	array_list_t loadedDrivers;
+	bundle_context_pt context;
+	array_list_pt loadedDrivers;
 };
 
 static apr_status_t driverLoader_destroy(void *loaderP);
 
-celix_status_t driverLoader_create(apr_pool_t *pool, bundle_context_t context, driver_loader_t *loader) {
+celix_status_t driverLoader_create(apr_pool_t *pool, bundle_context_pt context, driver_loader_pt *loader) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*loader = apr_palloc(pool, sizeof(**loader));
@@ -59,19 +59,19 @@ celix_status_t driverLoader_create(apr_p
 }
 
 apr_status_t driverLoader_destroy(void *loaderP) {
-	driver_loader_t matcher = loaderP;
+	driver_loader_pt matcher = loaderP;
 	arrayList_destroy(matcher->loadedDrivers);
 	return APR_SUCCESS;
 }
 
-celix_status_t driverLoader_findDrivers(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, properties_t properties, array_list_t *driversIds) {
+celix_status_t driverLoader_findDrivers(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, properties_pt properties, array_list_pt *driversIds) {
 	celix_status_t status = CELIX_SUCCESS;
 	arrayList_create(pool, driversIds);
 
 	int i;
 	for (i = 0; i < arrayList_size(locators); i++) {
-		array_list_t drivers;
-		driver_locator_service_t locator = arrayList_get(locators, i);
+		array_list_pt drivers;
+		driver_locator_service_pt locator = arrayList_get(locators, i);
 
 		apr_pool_t *spool;
 		apr_status_t aprStatus = apr_pool_create(&spool, pool);
@@ -90,7 +90,7 @@ celix_status_t driverLoader_findDrivers(
 	return status;
 }
 
-celix_status_t driverLoader_findDriversForLocator(driver_loader_t loader, apr_pool_t *pool, driver_locator_service_t locator, properties_t properties, array_list_t *driversIds) {
+celix_status_t driverLoader_findDriversForLocator(driver_loader_pt loader, apr_pool_t *pool, driver_locator_service_pt locator, properties_pt properties, array_list_pt *driversIds) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = locator->findDrivers(locator->locator, pool, properties, driversIds);
@@ -98,13 +98,13 @@ celix_status_t driverLoader_findDriversF
 	return status;
 }
 
-celix_status_t driverLoader_loadDrivers(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, array_list_t driverIds, array_list_t *references) {
+celix_status_t driverLoader_loadDrivers(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, array_list_pt driverIds, array_list_pt *references) {
 	celix_status_t status = CELIX_SUCCESS;
 	status = arrayList_create(pool, references);
 	if (status == CELIX_SUCCESS) {
 		int i;
 		for (i = 0; i < arrayList_size(driverIds); i++) {
-			array_list_t refs = NULL;
+			array_list_pt refs = NULL;
 			char *id = arrayList_get(driverIds, i);
 
 			apr_pool_t *spool;
@@ -127,14 +127,14 @@ celix_status_t driverLoader_loadDrivers(
 	return status;
 }
 
-celix_status_t driverLoader_loadDriver(driver_loader_t loader, apr_pool_t *pool, array_list_t locators, char *driverId, array_list_t *references) {
+celix_status_t driverLoader_loadDriver(driver_loader_pt loader, apr_pool_t *pool, array_list_pt locators, char *driverId, array_list_pt *references) {
 	celix_status_t status = CELIX_SUCCESS;
 	status = arrayList_create(pool, references);
 	if (status == CELIX_SUCCESS) {
 		int i;
 		for (i = 0; i < arrayList_size(locators); i++) {
-			array_list_t refs = NULL;
-			driver_locator_service_t locator = arrayList_get(locators, i);
+			array_list_pt refs = NULL;
+			driver_locator_service_pt locator = arrayList_get(locators, i);
 
 			apr_pool_t *spool;
 			apr_status_t aprStatus = apr_pool_create(&spool, pool);
@@ -158,7 +158,7 @@ celix_status_t driverLoader_loadDriver(d
 	return status;
 }
 
-celix_status_t driverLoader_loadDriverForLocator(driver_loader_t loader, apr_pool_t *pool, driver_locator_service_t locator, char *driverId, array_list_t *references) {
+celix_status_t driverLoader_loadDriverForLocator(driver_loader_pt loader, apr_pool_t *pool, driver_locator_service_pt locator, char *driverId, array_list_pt *references) {
 	celix_status_t status = CELIX_SUCCESS;
 	arrayList_create(loader->pool, references);
 
@@ -170,7 +170,7 @@ celix_status_t driverLoader_loadDriverFo
 		char *filename = NULL;
 		status = locator->loadDriver(locator->locator, loadPool, driverId, &filename);
 		if (status == CELIX_SUCCESS) {
-			bundle_t bundle = NULL;
+			bundle_pt bundle = NULL;
 			apr_pool_t *bundlePool;
 			status = bundleContext_getMemoryPool(loader->context, &bundlePool);
 			if (status == CELIX_SUCCESS) {
@@ -193,21 +193,21 @@ celix_status_t driverLoader_loadDriverFo
 	return status;
 }
 
-celix_status_t driverLoader_unloadDrivers(driver_loader_t loader, driver_attributes_t finalDriver) {
+celix_status_t driverLoader_unloadDrivers(driver_loader_pt loader, driver_attributes_pt finalDriver) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	service_reference_t finalReference = NULL;
+	service_reference_pt finalReference = NULL;
 	if (finalDriver != NULL) {
 		status = driverAttributes_getReference(finalDriver, &finalReference);
 	}
 	if (status == CELIX_SUCCESS) {
 		int i;
 		for (i = 0; i < arrayList_size(loader->loadedDrivers); i++) {
-			service_reference_t reference = arrayList_get(loader->loadedDrivers, i);
+			service_reference_pt reference = arrayList_get(loader->loadedDrivers, i);
 			bool equal = false;
 			status = serviceReference_equals(reference, finalReference, &equal);
 			if (status == CELIX_SUCCESS && !equal) {
-				bundle_t bundle = NULL;
+				bundle_pt bundle = NULL;
 				status = serviceReference_getBundle(reference, &bundle);
 				if (status == CELIX_SUCCESS) {
 					bundle_uninstall(bundle); // Ignore status

Modified: incubator/celix/trunk/device_access/device_access/private/src/driver_matcher.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/private/src/driver_matcher.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/private/src/driver_matcher.c (original)
+++ incubator/celix/trunk/device_access/device_access/private/src/driver_matcher.c Wed Jun 12 19:08:50 2013
@@ -32,10 +32,10 @@
 
 struct driver_matcher {
 	apr_pool_t *pool;
-	hash_map_t attributes;
-	 array_list_t matches;
+	hash_map_pt attributes;
+	 array_list_pt matches;
 
-	 bundle_context_t context;
+	 bundle_context_pt context;
 };
 
 typedef struct match_key {
@@ -43,8 +43,8 @@ typedef struct match_key {
 } *match_key_t;
 
 static apr_status_t driverMatcher_destroy(void *matcherP);
-static celix_status_t driverMatcher_get(driver_matcher_t matcher, int key, array_list_t *attributesV);
-static celix_status_t driverMatcher_getBestMatchInternal(driver_matcher_t matcher, apr_pool_t *pool, match_t *match);
+static celix_status_t driverMatcher_get(driver_matcher_pt matcher, int key, array_list_pt *attributesV);
+static celix_status_t driverMatcher_getBestMatchInternal(driver_matcher_pt matcher, apr_pool_t *pool, match_pt *match);
 
 unsigned int driverMatcher_matchKeyHash(void * match_key) {
 	match_key_t key = match_key;
@@ -56,7 +56,7 @@ int driverMatcher_matchKeyEquals(void * 
 	return ((match_key_t) key)->matchValue == ((match_key_t) toCompare)->matchValue;
 }
 
-celix_status_t driverMatcher_create(apr_pool_t *pool, bundle_context_t context, driver_matcher_t *matcher) {
+celix_status_t driverMatcher_create(apr_pool_t *pool, bundle_context_pt context, driver_matcher_pt *matcher) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	*matcher = apr_palloc(pool, sizeof(**matcher));
@@ -77,11 +77,11 @@ celix_status_t driverMatcher_create(apr_
 }
 
 apr_status_t driverMatcher_destroy(void *matcherP) {
-	driver_matcher_t matcher = matcherP;
+	driver_matcher_pt matcher = matcherP;
 	arrayList_destroy(matcher->matches);
-	hash_map_iterator_t iter = hashMapIterator_create(matcher->attributes);
+	hash_map_iterator_pt iter = hashMapIterator_create(matcher->attributes);
 	while (hashMapIterator_hasNext(iter)) {
-		array_list_t list = hashMapIterator_nextValue(iter);
+		array_list_pt list = hashMapIterator_nextValue(iter);
 		if (list != NULL) {
 			arrayList_destroy(list);
 		}
@@ -91,15 +91,15 @@ apr_status_t driverMatcher_destroy(void 
 	return APR_SUCCESS;
 }
 
-celix_status_t driverMatcher_add(driver_matcher_t matcher, int matchValue, driver_attributes_t attributes) {
+celix_status_t driverMatcher_add(driver_matcher_pt matcher, int matchValue, driver_attributes_pt attributes) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	array_list_t da = NULL;
+	array_list_pt da = NULL;
 	status = driverMatcher_get(matcher, matchValue, &da);
 	if (status == CELIX_SUCCESS) {
 		arrayList_add(da, attributes);
 
-		match_t match = NULL;
+		match_pt match = NULL;
 		match = apr_palloc(matcher->pool, sizeof(*match));
 		if (!match) {
 			status = CELIX_ENOMEM;
@@ -114,7 +114,7 @@ celix_status_t driverMatcher_add(driver_
 	return status;
 }
 
-celix_status_t driverMatcher_get(driver_matcher_t matcher, int key, array_list_t *attributes) {
+celix_status_t driverMatcher_get(driver_matcher_pt matcher, int key, array_list_pt *attributes) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	apr_pool_t *spool = NULL;
@@ -136,18 +136,18 @@ celix_status_t driverMatcher_get(driver_
 	return status;
 }
 
-celix_status_t driverMatcher_getBestMatch(driver_matcher_t matcher, apr_pool_t *pool, service_reference_t reference, match_t *match) {
+celix_status_t driverMatcher_getBestMatch(driver_matcher_pt matcher, apr_pool_t *pool, service_reference_pt reference, match_pt *match) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (*match != NULL) {
 		status = CELIX_ILLEGAL_ARGUMENT;
 	} else {
-		service_reference_t selectorRef = NULL;
+		service_reference_pt selectorRef = NULL;
 		status = bundleContext_getServiceReference(matcher->context, DRIVER_SELECTOR_SERVICE_NAME, &selectorRef);
 		if (status == CELIX_SUCCESS) {
 			int index = -1;
 			if (selectorRef != NULL) {
-				driver_selector_service_t selector = NULL;
+				driver_selector_service_pt selector = NULL;
 				status = bundleContext_getService(matcher->context, selectorRef, (void **) &selector);
 				if (status == CELIX_SUCCESS) {
 					if (selector != NULL) {
@@ -171,14 +171,14 @@ celix_status_t driverMatcher_getBestMatc
 	return status;
 }
 
-celix_status_t driverMatcher_getBestMatchInternal(driver_matcher_t matcher, apr_pool_t *pool, match_t *match) {
+celix_status_t driverMatcher_getBestMatchInternal(driver_matcher_pt matcher, apr_pool_t *pool, match_pt *match) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (!hashMap_isEmpty(matcher->attributes)) {
 		match_key_t matchKey = NULL;
-		hash_map_iterator_t iter = hashMapIterator_create(matcher->attributes);
+		hash_map_iterator_pt iter = hashMapIterator_create(matcher->attributes);
 		while (hashMapIterator_hasNext(iter)) {
-			hash_map_entry_t entry = hashMapIterator_nextEntry(iter);
+			hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
 			match_key_t key = hashMapEntry_getKey(entry);
 			if (matchKey == NULL || matchKey->matchValue < key->matchValue) {
 				matchKey = key;
@@ -186,12 +186,12 @@ celix_status_t driverMatcher_getBestMatc
 		}
 		hashMapIterator_destroy(iter);
 
-		array_list_t das = hashMap_get(matcher->attributes, matchKey);
-		service_reference_t best = NULL;
+		array_list_pt das = hashMap_get(matcher->attributes, matchKey);
+		service_reference_pt best = NULL;
 		int i;
 		for (i = 0; i < arrayList_size(das); i++) {
-			driver_attributes_t attributes = arrayList_get(das, i);
-			service_reference_t reference = NULL;
+			driver_attributes_pt attributes = arrayList_get(das, i);
+			service_reference_pt reference = NULL;
 
 			celix_status_t substatus = driverAttributes_getReference(attributes, &reference);
 			if (substatus == CELIX_SUCCESS) {
@@ -199,10 +199,10 @@ celix_status_t driverMatcher_getBestMatc
 					printf("DRIVER_MATCHER: Compare ranking\n");
 					char *rank1Str, *rank2Str;
 					int rank1, rank2;
-					service_registration_t registration = NULL;
+					service_registration_pt registration = NULL;
 					substatus = serviceReference_getServiceRegistration(reference, &registration);
 					if (substatus == CELIX_SUCCESS) {
-						properties_t properties = NULL;
+						properties_pt properties = NULL;
 						status = serviceRegistration_getProperties(registration, &properties);
 						if (status == CELIX_SUCCESS) {
 

Modified: incubator/celix/trunk/device_access/device_access/public/include/device.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/public/include/device.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/public/include/device.h (original)
+++ incubator/celix/trunk/device_access/device_access/public/include/device.h Wed Jun 12 19:08:50 2013
@@ -35,13 +35,13 @@
 
 static const int DEVICE_MATCH_NONE	= 0;
 
-typedef struct device * device_t;
+typedef struct device * device_pt;
 
 struct device_service {
-	device_t device;
-	celix_status_t (*noDriverFound)(device_t device);
+	device_pt device;
+	celix_status_t (*noDriverFound)(device_pt device);
 };
 
-typedef struct device_service * device_service_t;
+typedef struct device_service * device_service_pt;
 
 #endif /* DEVICE_H_ */

Modified: incubator/celix/trunk/device_access/device_access/public/include/driver.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/public/include/driver.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/public/include/driver.h (original)
+++ incubator/celix/trunk/device_access/device_access/public/include/driver.h Wed Jun 12 19:08:50 2013
@@ -35,11 +35,11 @@
 
 struct driver_service {
 	void *driver;
-	celix_status_t (*attach)(void *driver, service_reference_t reference, char **result);
-	celix_status_t (*match)(void *driver, service_reference_t reference, int *value);
+	celix_status_t (*attach)(void *driver, service_reference_pt reference, char **result);
+	celix_status_t (*match)(void *driver, service_reference_pt reference, int *value);
 };
 
-typedef struct driver_service *driver_service_t;
+typedef struct driver_service *driver_service_pt;
 
 
 #endif /* DRIVER_H_ */

Modified: incubator/celix/trunk/device_access/device_access/public/include/driver_locator.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/public/include/driver_locator.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/public/include/driver_locator.h (original)
+++ incubator/celix/trunk/device_access/device_access/public/include/driver_locator.h Wed Jun 12 19:08:50 2013
@@ -32,15 +32,15 @@
 
 #define DRIVER_LOCATOR_SERVICE_NAME "driver_locator"
 
-typedef struct driver_locator *driver_locator_t;
+typedef struct driver_locator *driver_locator_pt;
 
 struct driver_locator_service {
-	driver_locator_t locator;
-	celix_status_t(*findDrivers)(driver_locator_t loc, apr_pool_t *pool, properties_t props, array_list_t *drivers);
-	celix_status_t(*loadDriver)(driver_locator_t loc, apr_pool_t *pool, char *id, char **driver);
+	driver_locator_pt locator;
+	celix_status_t(*findDrivers)(driver_locator_pt loc, apr_pool_t *pool, properties_pt props, array_list_pt *drivers);
+	celix_status_t(*loadDriver)(driver_locator_pt loc, apr_pool_t *pool, char *id, char **driver);
 };
 
-typedef struct driver_locator_service *driver_locator_service_t;
+typedef struct driver_locator_service *driver_locator_service_pt;
 
 
 #endif /* DRIVER_LOCATOR_H_ */

Modified: incubator/celix/trunk/device_access/device_access/public/include/driver_selector.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/public/include/driver_selector.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/public/include/driver_selector.h (original)
+++ incubator/celix/trunk/device_access/device_access/public/include/driver_selector.h Wed Jun 12 19:08:50 2013
@@ -28,14 +28,14 @@
 
 #define DRIVER_SELECTOR_SERVICE_NAME "driver_selector"
 
-typedef struct driver_selector *driver_selector_t;
+typedef struct driver_selector *driver_selector_pt;
 
 struct driver_selector_service {
-	driver_selector_t selector;
-	celix_status_t (*driverSelector_select)(driver_selector_t selector, service_reference_t reference, array_list_t matches, int *select);
+	driver_selector_pt selector;
+	celix_status_t (*driverSelector_select)(driver_selector_pt selector, service_reference_pt reference, array_list_pt matches, int *select);
 };
 
-typedef struct driver_selector_service *driver_selector_service_t;
+typedef struct driver_selector_service *driver_selector_service_pt;
 
 
 #endif /* DRIVER_SELECTOR_H_ */

Modified: incubator/celix/trunk/device_access/device_access/public/include/match.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/device_access/public/include/match.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/device_access/public/include/match.h (original)
+++ incubator/celix/trunk/device_access/device_access/public/include/match.h Wed Jun 12 19:08:50 2013
@@ -29,10 +29,10 @@
 #include <service_reference.h>
 
 struct match {
-	service_reference_t reference;
+	service_reference_pt reference;
 	int matchValue;
 };
 
-typedef struct match *match_t;
+typedef struct match *match_pt;
 
 #endif /* MATCH_H_ */

Modified: incubator/celix/trunk/device_access/driver_locator/private/include/driver_locator_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/driver_locator/private/include/driver_locator_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/driver_locator/private/include/driver_locator_private.h (original)
+++ incubator/celix/trunk/device_access/driver_locator/private/include/driver_locator_private.h Wed Jun 12 19:08:50 2013
@@ -31,10 +31,10 @@
 struct driver_locator {
     apr_pool_t *pool;
     char *path;
-    array_list_t drivers;
+    array_list_pt drivers;
 };
 
-celix_status_t driverLocator_findDrivers(driver_locator_t locator, apr_pool_t *pool, properties_t props, array_list_t *drivers);
-celix_status_t driverLocator_loadDriver(driver_locator_t locator, apr_pool_t *pool, char *id, char **driver);
+celix_status_t driverLocator_findDrivers(driver_locator_pt locator, apr_pool_t *pool, properties_pt props, array_list_pt *drivers);
+celix_status_t driverLocator_loadDriver(driver_locator_pt locator, apr_pool_t *pool, char *id, char **driver);
 
 #endif /* DRIVER_LOCATOR_PRIVATE_H_ */

Modified: incubator/celix/trunk/device_access/driver_locator/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/driver_locator/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/driver_locator/private/src/activator.c (original)
+++ incubator/celix/trunk/device_access/driver_locator/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -33,19 +33,19 @@
 static const char *DEFAULT_LOCATOR_PATH = "drivers";
 
 struct bundle_instance {
-	driver_locator_service_t service;
-	driver_locator_t locator;
-	service_registration_t locatorRegistration;
+	driver_locator_service_pt service;
+	driver_locator_pt locator;
+	service_registration_pt locatorRegistration;
 };
 
-typedef struct bundle_instance *bundle_instance_t;
+typedef struct bundle_instance *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) {
 	celix_status_t status = CELIX_SUCCESS;
     apr_pool_t *pool;
     status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
-    	bundle_instance_t bi = apr_palloc(pool, sizeof(struct bundle_instance));
+    	bundle_instance_pt bi = apr_palloc(pool, sizeof(struct bundle_instance));
         if (userData != NULL) {
         	bi->service=NULL;
         	bi->locator=NULL;
@@ -58,11 +58,11 @@ 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;
     apr_pool_t *pool;
     status = bundleContext_getMemoryPool(context, &pool);
-    bundle_instance_t bi = (bundle_instance_t)userData;
+    bundle_instance_pt bi = (bundle_instance_pt)userData;
     if (status == CELIX_SUCCESS) {
         struct activatorData * data = (struct activatorData *) userData;
         bi->service = apr_palloc(pool, sizeof(*(bi->service)));
@@ -85,14 +85,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;
-    bundle_instance_t bi = (bundle_instance_t)userData;
+    bundle_instance_pt bi = (bundle_instance_pt)userData;
     serviceRegistration_unregister(bi->locatorRegistration);
     arrayList_destroy(bi->locator->drivers);
     return status;
 }
 
-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/device_access/driver_locator/private/src/driver_locator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/driver_locator/private/src/driver_locator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/driver_locator/private/src/driver_locator.c (original)
+++ incubator/celix/trunk/device_access/driver_locator/private/src/driver_locator.c Wed Jun 12 19:08:50 2013
@@ -34,7 +34,7 @@
 #include "driver_locator_private.h"
 #include "device.h"
 
-celix_status_t driverLocator_findDrivers(driver_locator_t locator, apr_pool_t *pool, properties_t props, array_list_t *drivers) {
+celix_status_t driverLocator_findDrivers(driver_locator_pt locator, apr_pool_t *pool, properties_pt props, array_list_pt *drivers) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	char *category = properties_get(props, DEVICE_CATEGORY);
@@ -71,7 +71,7 @@ celix_status_t driverLocator_findDrivers
 	return status;
 }
 
-celix_status_t driverLocator_loadDriver(driver_locator_t locator, apr_pool_t *pool, char *id, char **stream) {
+celix_status_t driverLocator_loadDriver(driver_locator_pt locator, apr_pool_t *pool, char *id, char **stream) {
 	celix_status_t status = CELIX_SUCCESS;
 	*stream = NULL;
 

Modified: incubator/celix/trunk/device_access/example/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/CMakeLists.txt?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/CMakeLists.txt (original)
+++ incubator/celix/trunk/device_access/example/CMakeLists.txt Wed Jun 12 19:08:50 2013
@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-celix_subproject(DEVICE_ACCESS_EXAMPLE "Option to enable building the Device Access example bundles" OFF DEPS LAUNCHER LOG_SERVICE SHELL shell_tui)
+celix_subproject(DEVICE_ACCESS_EXAMPLE "Option to enable building the Device Access example bundles" OFF DEPS LAUNCHER LOG_SERVICE shell_pt shell_tui)
 if(DEVICE_ACCESS_EXAMPLE)
 	add_subdirectory(base_driver)
 	add_subdirectory(consuming_driver)

Modified: incubator/celix/trunk/device_access/example/base_driver/private/include/base_driver_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/device_access/example/base_driver/private/include/base_driver_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/device_access/example/base_driver/private/include/base_driver_private.h (original)
+++ incubator/celix/trunk/device_access/example/base_driver/private/include/base_driver_private.h Wed Jun 12 19:08:50 2013
@@ -28,11 +28,11 @@
 
 #include "base_driver_device.h"
 
-celix_status_t baseDriver_create(apr_pool_t *pool, base_driver_device_t *service);
-celix_status_t baseDriver_createService(base_driver_device_t device, base_driver_device_service_t *service);
+celix_status_t baseDriver_create(apr_pool_t *pool, base_driver_device_pt *service);
+celix_status_t baseDriver_createService(base_driver_device_pt device, base_driver_device_service_pt *service);
 
-celix_status_t baseDriver_noDriverFound(device_t device);
+celix_status_t baseDriver_noDriverFound(device_pt device);
 
-celix_status_t baseDriver_getNextChar(base_driver_device_t service, char *c);
+celix_status_t baseDriver_getNextChar(base_driver_device_pt service, char *c);
 
 #endif /* BASE_DRIVER_PRIVATE_H_ */



Mime
View raw message