celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [42/46] celix git commit: CELIX-417: Initial refactoring for CMake usage
Date Mon, 20 Nov 2017 20:33:39 GMT
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager/src/dm_service_dependency.c
----------------------------------------------------------------------
diff --git a/dependency_manager/src/dm_service_dependency.c b/dependency_manager/src/dm_service_dependency.c
new file mode 100644
index 0000000..65a0593
--- /dev/null
+++ b/dependency_manager/src/dm_service_dependency.c
@@ -0,0 +1,811 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * dm_service_dependency.c
+ *
+ *  \date       17 Oct 2014
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+
+#include "constants.h"
+
+#include "dm_service_dependency_impl.h"
+#include "dm_component_impl.h"
+
+#define DEFAULT_RANKING     0
+#define DM_SERVICE_DEPENDENCY_DEFAULT_STRATEGY DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND
+
+static celix_status_t serviceDependency_addedService(void *_ptr, service_reference_pt reference, void *service);
+static celix_status_t serviceDependency_modifiedService(void *_ptr, service_reference_pt reference, void *service);
+static celix_status_t serviceDependency_removedService(void *_ptr, service_reference_pt reference, void *service);
+static void* serviceDependency_getCallbackHandle(dm_service_dependency_pt dep);
+
+celix_status_t serviceDependency_create(dm_service_dependency_pt *dependency_ptr) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	*dependency_ptr = calloc(1, sizeof(**dependency_ptr));
+	if (!*dependency_ptr) {
+		status = CELIX_ENOMEM;
+	} else {
+		(*dependency_ptr)->component = NULL;
+		(*dependency_ptr)->available = false;
+		(*dependency_ptr)->instanceBound = false;
+		(*dependency_ptr)->required = false;
+		(*dependency_ptr)->strategy = DM_SERVICE_DEPENDENCY_DEFAULT_STRATEGY;
+
+		(*dependency_ptr)->callbackHandle = NULL;
+		(*dependency_ptr)->set = NULL;
+		(*dependency_ptr)->add = NULL;
+		(*dependency_ptr)->change = NULL;
+		(*dependency_ptr)->remove = NULL;
+		(*dependency_ptr)->swap = NULL;
+
+		(*dependency_ptr)->add_with_ref = NULL;
+		(*dependency_ptr)->change_with_ref = NULL;
+		(*dependency_ptr)->remove_with_ref = NULL;
+		(*dependency_ptr)->swap_with_ref = NULL;
+
+		(*dependency_ptr)->autoConfigure = NULL;
+
+		(*dependency_ptr)->isStarted = false;
+
+        (*dependency_ptr)->addCLanguageFilter = false;
+		(*dependency_ptr)->tracked_service = NULL;
+		(*dependency_ptr)->tracked_filter_unmodified = NULL;
+		(*dependency_ptr)->tracked_filter = NULL;
+
+		(*dependency_ptr)->tracker = NULL;
+		(*dependency_ptr)->tracker_customizer = NULL;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_destroy(dm_service_dependency_pt *dependency_ptr) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!*dependency_ptr) {
+		status = CELIX_ENOMEM;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		free((*dependency_ptr)->tracked_service);
+		free((*dependency_ptr)->tracked_filter);
+		free((*dependency_ptr)->tracked_filter_unmodified);
+		free(*dependency_ptr);
+		*dependency_ptr = NULL;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_lock(dm_service_dependency_pt dependency) {
+	celixThreadMutex_lock(&dependency->lock);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t serviceDependency_unlock(dm_service_dependency_pt dependency) {
+	celixThreadMutex_unlock(&dependency->lock);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t serviceDependency_setRequired(dm_service_dependency_pt dependency, bool required) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->required = required;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setAddCLanguageFilter(dm_service_dependency_pt dependency, bool addCLangFilter) {
+    dependency->addCLanguageFilter = addCLangFilter;
+    return CELIX_SUCCESS;
+}
+
+celix_status_t serviceDependency_setStrategy(dm_service_dependency_pt dependency, dm_service_dependency_strategy_t strategy) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		dependency->strategy = strategy;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_getStrategy(dm_service_dependency_pt dependency, dm_service_dependency_strategy_t* strategy) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		*strategy = dependency->strategy;
+	}
+
+	return status;
+
+}
+
+celix_status_t serviceDependency_setService(dm_service_dependency_pt dependency, const char* serviceName, const char* serviceVersionRange, const char* filter) {
+	celix_status_t status = CELIX_SUCCESS;
+	if (!dependency || !serviceName) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		array_list_pt filterElements = NULL;
+		arrayList_create(&filterElements);
+
+		free(dependency->tracked_service);
+		dependency->tracked_service = strdup(serviceName);
+
+		if (serviceVersionRange != NULL) {
+			version_range_pt versionRange = NULL;
+
+			if (versionRange_parse(serviceVersionRange, &versionRange) == CELIX_SUCCESS) {
+				version_pt lowVersion = NULL;
+				version_pt highVersion = NULL;
+
+				if ((versionRange_getHighVersion(versionRange, &highVersion) == CELIX_SUCCESS) && (highVersion != NULL)) {
+					bool isHighInclusive;
+					char* highOperator;
+					char* highVersionStr = NULL;
+
+					versionRange_isHighInclusive(versionRange, &isHighInclusive);
+					version_toString(highVersion, &highVersionStr);
+
+					highOperator = isHighInclusive ? "<=" : "<";
+
+					if(highVersionStr != NULL){
+						size_t len = strlen(CELIX_FRAMEWORK_SERVICE_VERSION) + strlen(highVersionStr) + strlen(highOperator) + 3;
+						char serviceVersionFilter[len];
+						snprintf(serviceVersionFilter, len, "(%s%s%s)", CELIX_FRAMEWORK_SERVICE_VERSION, highOperator, highVersionStr);
+						arrayList_add(filterElements, strdup(serviceVersionFilter));
+						free(highVersionStr);
+					}
+				}
+
+				if ((versionRange_getLowVersion(versionRange, &lowVersion) == CELIX_SUCCESS) && (lowVersion != NULL)) {
+					bool isLowInclusive;
+					char* lowOperator;
+					char* lowVersionStr = NULL;
+
+					versionRange_isLowInclusive(versionRange, &isLowInclusive);
+					version_toString(lowVersion, &lowVersionStr);
+
+					lowOperator = isLowInclusive ? ">=" : ">";
+
+					if(lowVersionStr != NULL){
+						size_t len = strlen(CELIX_FRAMEWORK_SERVICE_VERSION) + strlen(lowVersionStr) + strlen(lowOperator) + 3;
+						char serviceVersionFilter[len];
+						snprintf(serviceVersionFilter, len, "(%s%s%s)", CELIX_FRAMEWORK_SERVICE_VERSION, lowOperator, lowVersionStr);
+						arrayList_add(filterElements, strdup(serviceVersionFilter));
+						free(lowVersionStr);
+					}
+				}
+			}
+
+			if(versionRange!=NULL){
+				versionRange_destroy(versionRange);
+			}
+		}
+
+		if (filter != NULL) {
+			free(dependency->tracked_filter_unmodified);
+			dependency->tracked_filter_unmodified = strdup(filter);
+			arrayList_add(filterElements, strdup(filter));
+		}
+
+
+
+        bool needLangFilter = true;
+		if (filter != NULL) {
+            char needle[128];
+            snprintf(needle, sizeof(needle), "(%s=", CELIX_FRAMEWORK_SERVICE_LANGUAGE);
+            if (strstr(filter, needle) != NULL) {
+                needLangFilter = false;
+            }
+        }
+
+        if (needLangFilter && dependency->addCLanguageFilter) {
+			char langFilter[128];
+			snprintf(langFilter, sizeof(langFilter), "(%s=%s)", CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_C_LANGUAGE);
+            arrayList_add(filterElements, strdup(langFilter));
+		}
+
+		if (arrayList_size(filterElements) > 0) {
+			array_list_iterator_pt filterElementsIter = arrayListIterator_create(filterElements);
+
+			size_t len = strlen(serviceName) + strlen(OSGI_FRAMEWORK_OBJECTCLASS) + 4;
+			free(dependency->tracked_filter);
+			dependency->tracked_filter = calloc(len, sizeof(*dependency->tracked_filter));
+			snprintf(dependency->tracked_filter, len, "(%s=%s)", OSGI_FRAMEWORK_OBJECTCLASS, serviceName);
+
+			while (arrayListIterator_hasNext(filterElementsIter) == true) {
+				char* filterElement = (char*) arrayListIterator_next(filterElementsIter);
+				size_t len = strnlen(dependency->tracked_filter, 1024*1024) + strnlen(filterElement, 1024*1024) + 4;
+				char* newFilter = calloc(len, sizeof(*newFilter));
+
+				if (dependency->tracked_filter[0] == '(' && dependency->tracked_filter[1] == '&') {
+					//already have an & (AND) can combine with additional filter -> easier to read
+					size_t orgLen = strnlen(dependency->tracked_filter, 1024*1024);
+					snprintf(newFilter, len, "%.*s%s)", (int)orgLen -1, dependency->tracked_filter, filterElement);
+				} else {
+					snprintf(newFilter, len, "(&%s%s)", dependency->tracked_filter, filterElement);
+				}
+
+				free(dependency->tracked_filter);
+				free(filterElement);
+
+				dependency->tracked_filter = newFilter;
+			}
+
+			arrayListIterator_destroy(filterElementsIter);
+		}
+		else {
+			free(dependency->tracked_filter);
+			dependency->tracked_filter = NULL;
+		}
+
+		arrayList_destroy(filterElements);
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_getFilter(dm_service_dependency_pt dependency, const char** filter) {
+	*filter = (const char*)dependency->tracked_filter;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t serviceDependency_setCallbacks(dm_service_dependency_pt dependency, service_set_fpt set, service_add_fpt add, service_change_fpt change, service_remove_fpt remove, service_swap_fpt swap) {
+	celix_status_t status = CELIX_SUCCESS;
+
+    //printf("Setting callbacks set %p, add %p, change %p, remove %p and swap %p\n", set, add, change, remove, swap);
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->set = set;
+		dependency->add = add;
+		dependency->change = change;
+		dependency->remove = remove;
+		dependency->swap = swap;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setCallbacksWithServiceReference(dm_service_dependency_pt dependency, service_set_with_ref_fpt set, service_add_with_ref_fpt add, service_change_with_ref_fpt change, service_remove_with_ref_fpt remove,
+		service_swap_with_ref_fpt swap) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->set_with_ref = set;
+		dependency->add_with_ref = add;
+		dependency->change_with_ref = change;
+		dependency->remove_with_ref = remove;
+		dependency->swap_with_ref = swap;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setAutoConfigure(dm_service_dependency_pt dependency, celix_thread_mutex_t *service_lock, const void **field) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	celix_thread_mutex_t lock;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->autoConfigure = field;
+		celixThreadMutex_create(&lock, NULL);
+		*service_lock = lock;
+		dependency->lock = lock;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setComponent(dm_service_dependency_pt dependency, dm_component_pt component) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->component = component;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_start(dm_service_dependency_pt dependency) {
+	celix_status_t status = CELIX_SUCCESS;
+	bundle_context_pt context = NULL;
+
+	if (!dependency || !dependency->component || (!dependency->tracked_service && !dependency->tracked_filter)) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+	if (status == CELIX_SUCCESS) {
+		status = component_getBundleContext(dependency->component, &context);
+		if (!context) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+	if (status == CELIX_SUCCESS) {
+		dependency->tracker_customizer = NULL;
+		status = serviceTrackerCustomizer_create(dependency, NULL, serviceDependency_addedService, serviceDependency_modifiedService, serviceDependency_removedService, &dependency->tracker_customizer);
+	}
+	if (status == CELIX_SUCCESS) {
+		if (dependency->tracked_filter) {
+			status = serviceTracker_createWithFilter(context, dependency->tracked_filter, dependency->tracker_customizer, &dependency->tracker);
+		} else if (dependency->tracked_service) {
+			status = serviceTracker_create(context, dependency->tracked_service, dependency->tracker_customizer, &dependency->tracker);
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = serviceTracker_open(dependency->tracker);
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->isStarted = true;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_stop(dm_service_dependency_pt dependency) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->isStarted = false;
+	}
+
+	if (status == CELIX_SUCCESS && dependency->tracker) {
+		status = serviceTracker_close(dependency->tracker);
+		if (status == CELIX_SUCCESS) {
+			serviceTracker_destroy(dependency->tracker);
+			dependency->tracker = NULL;
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setInstanceBound(dm_service_dependency_pt dependency, bool instanceBound) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->instanceBound = instanceBound;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_setAvailable(dm_service_dependency_pt dependency, bool available) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		dependency->available = available;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_invokeSet(dm_service_dependency_pt dependency, dm_event_pt event) {
+	celix_status_t status = CELIX_SUCCESS;
+	assert(dependency->isStarted == true);
+	array_list_pt serviceReferences = NULL;
+	int i;
+	int curRanking = INT_MIN;
+	service_reference_pt curServRef = NULL;
+	void *service = NULL;
+
+	serviceReferences = serviceTracker_getServiceReferences(dependency->tracker);
+
+	/* Find the service with the higest ranking */
+	for (i = 0; i < arrayList_size(serviceReferences); i++) {
+		service_reference_pt serviceReference = arrayList_get(serviceReferences, i);
+		const char* ranking_value;
+		int ranking = 0;
+
+		status = serviceReference_getProperty(serviceReference, ((char *) OSGI_FRAMEWORK_SERVICE_RANKING), &ranking_value);
+
+		if (status == CELIX_SUCCESS) {
+			if (ranking_value == NULL) {
+				ranking = DEFAULT_RANKING;
+			} else {
+				char *end;
+				ranking = strtol(ranking_value, &end, 10);
+				if (end == ranking_value) {
+					ranking = DEFAULT_RANKING;
+				}
+			}
+
+			if (ranking > curRanking) {
+				curRanking = ranking;
+				curServRef = serviceReference;
+			}
+		} else {
+			break;
+		}
+
+	}
+
+	arrayList_destroy(serviceReferences);
+
+	if (status == CELIX_SUCCESS) {
+		if (curServRef) {
+			status = bundleContext_getService(event->context, curServRef, &service);
+		} else {
+			service = NULL;
+		}
+
+		if (dependency->set) {
+			dependency->set(serviceDependency_getCallbackHandle(dependency), service);
+		}
+		if (dependency->set_with_ref) {
+			dependency->set_with_ref(serviceDependency_getCallbackHandle(dependency), curServRef, service);
+		}
+
+		if (curServRef) {
+			bundleContext_ungetService(event->context, curServRef, NULL);
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_invokeAdd(dm_service_dependency_pt dependency, dm_event_pt event) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		if (dependency->add) {
+			dependency->add(serviceDependency_getCallbackHandle(dependency), event->service);
+		}
+		if (dependency->add_with_ref) {
+			dependency->add_with_ref(serviceDependency_getCallbackHandle(dependency), event->reference, event->service);
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_invokeChange(dm_service_dependency_pt dependency, dm_event_pt event) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		if (dependency->change) {
+			dependency->change(serviceDependency_getCallbackHandle(dependency), event->service);
+		}
+		if (dependency->change_with_ref) {
+			dependency->change_with_ref(serviceDependency_getCallbackHandle(dependency), event->reference, event->service);
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_invokeRemove(dm_service_dependency_pt dependency, dm_event_pt event) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		if (dependency->remove) {
+			dependency->remove(serviceDependency_getCallbackHandle(dependency), event->service);
+		}
+		if (dependency->remove_with_ref) {
+			dependency->remove_with_ref(serviceDependency_getCallbackHandle(dependency), event->reference, event->service);
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_invokeSwap(dm_service_dependency_pt dependency, dm_event_pt event, dm_event_pt newEvent) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		if (dependency->swap) {
+			dependency->swap(serviceDependency_getCallbackHandle(dependency), event->service, newEvent->service);
+		}
+		if (dependency->swap_with_ref) {
+			dependency->swap_with_ref(serviceDependency_getCallbackHandle(dependency), event->reference, event->service, newEvent->reference, newEvent->service);
+		}
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_isAvailable(dm_service_dependency_pt dependency, bool *available) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*available = dependency->available;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_isRequired(dm_service_dependency_pt dependency, bool *required) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*required = dependency->required;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_isInstanceBound(dm_service_dependency_pt dependency, bool *instanceBound) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*instanceBound = dependency->instanceBound;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_isAutoConfig(dm_service_dependency_pt dependency, bool *autoConfig) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*autoConfig = dependency->autoConfigure != NULL;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_getAutoConfig(dm_service_dependency_pt dependency, const void*** autoConfigure) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (!dependency) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*autoConfigure = dependency->autoConfigure;
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_addedService(void *_ptr, service_reference_pt reference, void *service) {
+	celix_status_t status = CELIX_SUCCESS;
+	bundle_context_pt context = NULL;
+	bundle_pt bundle = NULL;
+	dm_event_pt event = NULL;
+	dm_service_dependency_pt dependency = _ptr;
+
+	if (!dependency || !reference || !service) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = component_getBundleContext(dependency->component, &context);
+		if (!context) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = bundleContext_getBundle(context, &bundle);
+		if (!bundle) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = event_create(DM_EVENT_ADDED, bundle, context, reference, service, &event);
+	}
+
+	if (status == CELIX_SUCCESS) {
+		component_handleEvent(dependency->component, dependency, event);
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_modifiedService(void *_ptr, service_reference_pt reference, void *service) {
+	celix_status_t status = CELIX_SUCCESS;
+	bundle_context_pt context = NULL;
+	bundle_pt bundle = NULL;
+	dm_event_pt event = NULL;
+	dm_service_dependency_pt dependency = _ptr;
+
+	if (!dependency || !reference || !service) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = component_getBundleContext(dependency->component, &context);
+		if (!context) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = bundleContext_getBundle(context, &bundle);
+		if (!bundle) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = event_create(DM_EVENT_CHANGED, bundle, context, reference, service, &event);
+	}
+
+	if (status == CELIX_SUCCESS) {
+		component_handleEvent(dependency->component, dependency, event);
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_removedService(void *_ptr, service_reference_pt reference, void *service) {
+	celix_status_t status = CELIX_SUCCESS;
+	bundle_context_pt context = NULL;
+	bundle_pt bundle = NULL;
+	dm_event_pt event = NULL;
+	dm_service_dependency_pt dependency = _ptr;
+
+	if (!dependency || !reference || !service) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = component_getBundleContext(dependency->component, &context);
+		if (!context) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = bundleContext_getBundle(context, &bundle);
+		if (!bundle) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	if (status == CELIX_SUCCESS) {
+		status = event_create(DM_EVENT_REMOVED, bundle, context, reference, service, &event);
+	}
+
+	if (status == CELIX_SUCCESS) {
+		component_handleEvent(dependency->component, dependency, event);
+	}
+
+	return status;
+}
+
+celix_status_t serviceDependency_getServiceDependencyInfo(dm_service_dependency_pt dep, dm_service_dependency_info_pt *out) {
+	celix_status_t status = CELIX_SUCCESS;
+	dm_service_dependency_info_pt info = calloc(1, sizeof(*info));
+	if (info != NULL) {
+		celixThreadMutex_lock(&dep->lock);
+		info->available = dep->available;
+		info->filter = dep->tracked_filter != NULL ? strdup(dep->tracked_filter) : NULL;
+		if (info->filter == NULL) {
+			info->filter = dep->tracked_service != NULL ? strdup(dep->tracked_service) : NULL;
+		}
+		info->required = dep->required;
+
+		array_list_pt refs = serviceTracker_getServiceReferences(dep->tracker);
+		if (refs != NULL) {
+			info->count = arrayList_size(refs);
+		}
+		arrayList_destroy(refs);
+
+		celixThreadMutex_unlock(&dep->lock);
+	} else {
+		status = CELIX_ENOMEM;
+	}
+
+	if (status == CELIX_SUCCESS) {
+		*out = info;
+	}
+
+	return status;
+}
+
+void dependency_destroyDependencyInfo(dm_service_dependency_info_pt info) {
+	if (info != NULL) {
+		free(info->filter);
+	}
+	free(info);
+}
+
+celix_status_t serviceDependency_setCallbackHandle(dm_service_dependency_pt dependency, void* handle) {
+	dependency->callbackHandle = handle;
+    return CELIX_SUCCESS;
+}
+
+static void* serviceDependency_getCallbackHandle(dm_service_dependency_pt dependency) {
+    return dependency->callbackHandle == NULL ? component_getImplementation(dependency->component) : dependency->callbackHandle;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager/src/dm_service_dependency_impl.h
----------------------------------------------------------------------
diff --git a/dependency_manager/src/dm_service_dependency_impl.h b/dependency_manager/src/dm_service_dependency_impl.h
new file mode 100644
index 0000000..7026ebf
--- /dev/null
+++ b/dependency_manager/src/dm_service_dependency_impl.h
@@ -0,0 +1,104 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * dm_service_dependency_impl.h
+ *
+ *  \date       16 Oct 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+#ifndef DM_SERVICE_DEPENDENCY_IMPL_H_
+#define DM_SERVICE_DEPENDENCY_IMPL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+
+#include "dm_event.h"
+#include "service_tracker.h"
+#include "service_tracker_customizer.h"
+
+#include "dm_service_dependency.h"
+#include "dm_component.h"
+
+struct dm_service_dependency {
+	dm_component_pt component;
+	bool available;
+	bool instanceBound;
+	bool required;
+	dm_service_dependency_strategy_t strategy;
+
+	void* callbackHandle; //This handle can be set to be used instead of the component implementation
+	service_set_fpt set;
+	service_add_fpt add;
+	service_change_fpt change;
+	service_remove_fpt remove;
+	service_swap_fpt swap;
+
+	service_set_with_ref_fpt set_with_ref;
+	service_add_with_ref_fpt add_with_ref;
+	service_change_with_ref_fpt change_with_ref;
+	service_remove_with_ref_fpt remove_with_ref;
+	service_swap_with_ref_fpt swap_with_ref;
+
+	const void **autoConfigure;
+	celix_thread_mutex_t lock;
+
+	bool isStarted;
+
+	bool addCLanguageFilter;
+	char *tracked_service;
+	char *tracked_filter_unmodified;
+	char *tracked_filter;
+
+	service_tracker_pt tracker;
+	service_tracker_customizer_pt tracker_customizer;
+};
+
+celix_status_t serviceDependency_start(dm_service_dependency_pt dependency);
+celix_status_t serviceDependency_stop(dm_service_dependency_pt dependency);
+celix_status_t serviceDependency_setInstanceBound(dm_service_dependency_pt dependency, bool instanceBound);
+celix_status_t serviceDependency_setAutoConfig(dm_service_dependency_pt dependency, void **autoConfigure);
+celix_status_t serviceDependency_setAvailable(dm_service_dependency_pt dependency, bool available);
+
+celix_status_t serviceDependency_setComponent(dm_service_dependency_pt dependency, dm_component_pt component);
+//celix_status_t serviceDependency_removeComponent(dm_service_dependency_pt dependency, dm_component_pt component);
+
+celix_status_t serviceDependency_invokeSet(dm_service_dependency_pt dependency, dm_event_pt event);
+celix_status_t serviceDependency_invokeAdd(dm_service_dependency_pt dependency, dm_event_pt event);
+celix_status_t serviceDependency_invokeChange(dm_service_dependency_pt dependency, dm_event_pt event);
+celix_status_t serviceDependency_invokeRemove(dm_service_dependency_pt dependency, dm_event_pt event);
+celix_status_t serviceDependency_invokeSwap(dm_service_dependency_pt dependency, dm_event_pt event, dm_event_pt newEvent);
+celix_status_t serviceDependency_isAvailable(dm_service_dependency_pt dependency, bool *available);
+celix_status_t serviceDependency_isRequired(dm_service_dependency_pt dependency, bool *required);
+celix_status_t serviceDependency_isInstanceBound(dm_service_dependency_pt dependency, bool *instanceBound);
+celix_status_t serviceDependency_isAutoConfig(dm_service_dependency_pt dependency, bool *autoConfig);
+
+celix_status_t serviceDependency_getAutoConfig(dm_service_dependency_pt dependency, const void*** autoConfigure);
+celix_status_t serviceDependency_unlock(dm_service_dependency_pt dependency);
+celix_status_t serviceDependency_lock(dm_service_dependency_pt dependency);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DM_SERVICE_DEPENDENCY_IMPL_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager/src/dm_shell_activator.c
----------------------------------------------------------------------
diff --git a/dependency_manager/src/dm_shell_activator.c b/dependency_manager/src/dm_shell_activator.c
new file mode 100644
index 0000000..4d6f507
--- /dev/null
+++ b/dependency_manager/src/dm_shell_activator.c
@@ -0,0 +1,94 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * dm_shell_activator.c
+ *
+ *  \date       16 Oct 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+#include <constants.h>
+#include "bundle_context.h"
+#include "command.h"
+
+#include "dm_shell_list_command.h"
+#include "shell_constants.h"
+
+struct bundle_instance {
+    service_registration_pt reg;
+    command_service_t  dmCommand;
+    dm_command_handle_t dmHandle;
+};
+
+typedef struct bundle_instance * bundle_instance_pt;
+
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
+
+	if(userData==NULL){
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+    struct bundle_instance *bi = calloc(sizeof (struct bundle_instance), 1);
+
+    if (bi==NULL) {
+        return CELIX_ENOMEM;
+    }
+
+    bi->dmHandle.context = context;
+    const char* config = NULL;
+    bundleContext_getPropertyWithDefault(context, SHELL_USE_ANSI_COLORS, SHELL_USE_ANSI_COLORS_DEFAULT_VALUE, &config);
+    bi->dmHandle.useColors = config != NULL && strncmp("true", config, 5) == 0;
+
+    (*userData) = bi;
+
+    return CELIX_SUCCESS;
+}
+
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
+    celix_status_t status = CELIX_SUCCESS;
+    bundle_instance_pt bi = (bundle_instance_pt) userData;
+
+    bi->dmCommand.handle = &bi->dmHandle;
+    bi->dmCommand.executeCommand = (void *)dmListCommand_execute;
+
+    properties_pt props = properties_create();
+    properties_set(props, CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_C_LANGUAGE);
+    properties_set(props, OSGI_SHELL_COMMAND_NAME, "dm");
+    properties_set(props, OSGI_SHELL_COMMAND_USAGE, "dm");
+    properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION,
+                   "Gives an overview of the component managemend by a dependency manager.");
+
+    status = bundleContext_registerService(context, OSGI_SHELL_COMMAND_SERVICE_NAME, &bi->dmCommand, props, &bi->reg);
+
+    return status;
+}
+
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
+    bundle_instance_pt bi = (bundle_instance_pt) userData;
+    serviceRegistration_unregister(bi->reg);
+    return CELIX_SUCCESS;
+}
+
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
+    bundle_instance_pt bi = (bundle_instance_pt) userData;
+    free(bi);
+    return CELIX_SUCCESS;
+}
+

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager/src/dm_shell_list_command.c
----------------------------------------------------------------------
diff --git a/dependency_manager/src/dm_shell_list_command.c b/dependency_manager/src/dm_shell_list_command.c
new file mode 100644
index 0000000..1600710
--- /dev/null
+++ b/dependency_manager/src/dm_shell_list_command.c
@@ -0,0 +1,126 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * dm_shell_list_command.c
+ *
+ *  \date       Oct 16, 2015
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <dm_dependency_manager.h>
+#include <dm_shell_list_command.h>
+#include "dm_info.h"
+#include "service_reference.h"
+#include "array_list.h"
+#include "bundle_context.h"
+#include "bundle.h"
+#include "shell.h"
+
+
+static const char * const OK_COLOR = "\033[92m";
+static const char * const WARNING_COLOR = "\033[93m";
+static const char * const NOK_COLOR = "\033[91m";
+static const char * const END_COLOR = "\033[m";
+
+void dmListCommand_execute(dm_command_handle_t* handle, char * line, FILE *out, FILE *err) {
+
+    array_list_pt servRefs = NULL;
+    int i;
+    bundleContext_getServiceReferences(handle->context, DM_INFO_SERVICE_NAME ,NULL, &servRefs);
+
+    if(servRefs==NULL){
+	fprintf(out, "Invalid dm_info ServiceReferences List\n");
+	return;
+    }
+
+    bool colors = handle->useColors;
+
+    for(i = 0; i < arrayList_size(servRefs); i++) {
+        dm_dependency_manager_info_pt info = NULL;
+        dm_info_service_pt infoServ = NULL;
+        service_reference_pt servRef = NULL;
+        servRef = arrayList_get(servRefs, i);
+        bundleContext_getService(handle->context,  servRef, (void**)&infoServ);
+        infoServ->getInfo(infoServ->handle, &info);
+
+        int cmpCnt;
+        for (cmpCnt = 0; cmpCnt < arrayList_size(info->components); cmpCnt++) {
+            dm_component_info_pt compInfo = arrayList_get(info->components, cmpCnt);
+            const char *startColors = "";
+            const char *endColors = "";
+            if (colors) {
+                startColors = compInfo->active ? OK_COLOR : NOK_COLOR;
+                endColors = END_COLOR;
+            }
+            fprintf(out, "Component: Name=%s\n|- ID=%s, %sActive=%s%s, State=%s\n", compInfo->name, compInfo->id, startColors, compInfo->active ?  "true " : "false", endColors, compInfo->state);
+
+            int interfCnt;
+            fprintf(out, "|- Interfaces (%d):\n", arrayList_size(compInfo->interfaces));
+            for(interfCnt = 0 ;interfCnt < arrayList_size(compInfo->interfaces); interfCnt++) {
+                dm_interface_info_pt intfInfo= arrayList_get(compInfo->interfaces, interfCnt);
+                fprintf(out, "   |- Interface: %s\n", intfInfo->name);
+
+                hash_map_iterator_t iter = hashMapIterator_construct((hash_map_pt) intfInfo->properties);
+                char* key = NULL;
+                while((key = hashMapIterator_nextKey(&iter)) != NULL) {
+                    fprintf(out, "      | %15s = %s\n", key, properties_get(intfInfo->properties, key));
+                }
+            }
+
+            int depCnt;
+            fprintf(out, "|- Dependencies (%d):\n", arrayList_size(compInfo->dependency_list));
+            for(depCnt = 0 ;depCnt < arrayList_size(compInfo->dependency_list); depCnt++) {
+                dm_service_dependency_info_pt dependency;
+                dependency = arrayList_get(compInfo->dependency_list, depCnt);
+                const char *startColors = "";
+                const char *endColors = "";
+                if (colors) {
+                    if (dependency->required) {
+                        startColors = dependency->available ? OK_COLOR : NOK_COLOR;
+                    } else {
+                        startColors = dependency->available ? OK_COLOR : WARNING_COLOR;
+                    }
+
+                    endColors = END_COLOR;
+                }
+                fprintf(out, "   |- Dependency: %sAvailable = %s%s, Required = %s, Filter = %s\n",
+                        startColors,
+                        dependency->available ? "true " : "false" ,
+                        endColors,
+                        dependency->required ? "true " : "false",
+                        dependency->filter
+                );
+            }
+            fprintf(out, "\n");
+
+		}
+
+            infoServ->destroyInfo(infoServ->handle, info);
+
+		bundleContext_ungetService(handle->context, servRef, NULL);
+		bundleContext_ungetServiceReference(handle->context, servRef);
+
+    }
+
+	if(servRefs!=NULL){
+		arrayList_destroy(servRefs);
+    }
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager/src/dm_shell_list_command.h
----------------------------------------------------------------------
diff --git a/dependency_manager/src/dm_shell_list_command.h b/dependency_manager/src/dm_shell_list_command.h
new file mode 100644
index 0000000..6ab0581
--- /dev/null
+++ b/dependency_manager/src/dm_shell_list_command.h
@@ -0,0 +1,42 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+
+#ifndef DM_SHELL_LIST_COMMAND_H_
+#define DM_SHELL_LIST_COMMAND_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include "command.h"
+
+typedef struct dm_command_handle {
+    bundle_context_pt context;
+    bool useColors;
+} dm_command_handle_t;
+
+void dmListCommand_execute(dm_command_handle_t* handle, char * line, FILE *out, FILE *err);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //DM_SHELL_LSIT_COMMAND_H_
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager_cxx/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/dependency_manager_cxx/CMakeLists.txt b/dependency_manager_cxx/CMakeLists.txt
index c113fa3..65c158d 100644
--- a/dependency_manager_cxx/CMakeLists.txt
+++ b/dependency_manager_cxx/CMakeLists.txt
@@ -24,31 +24,26 @@ if (DEPENDENCY_MANAGER_CXX)
             exec_program(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR)
             set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_SYSTEM_PROCESSOR} CACHE INTERNAL "processor type (i386 and x86_64)")
             if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
-                add_definitions(-fPIC)
+                set(DM_COMP_OPT -fPIC)
             endif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
         endif(CMAKE_UNAME)
     endif(UNIX AND NOT WIN32)
 
-    include_directories(
-            include
-            ${PROJECT_SOURCE_DIR}/dependency_manager/public/include
-            ${PROJECT_SOURCE_DIR}/dependency_manager/private/include
-            ${PROJECT_SOURCE_DIR}/utils/public/include
-    )
-
-    add_library( dependency_manager_cxx_static STATIC
-            ${CMAKE_SOURCE_DIR}/dependency_manager/private/src/dm_component_impl
-            ${CMAKE_SOURCE_DIR}/dependency_manager/private/src/dm_service_dependency
-            ${CMAKE_SOURCE_DIR}/dependency_manager/private/src/dm_event
-            ${CMAKE_SOURCE_DIR}/dependency_manager/private/src/dm_dependency_manager_impl
+    add_library(dependency_manager_cxx_static STATIC
+            ${CMAKE_SOURCE_DIR}/dependency_manager/src/dm_component_impl
+            ${CMAKE_SOURCE_DIR}/dependency_manager/src/dm_service_dependency
+            ${CMAKE_SOURCE_DIR}/dependency_manager/src/dm_event
+            ${CMAKE_SOURCE_DIR}/dependency_manager/src/dm_dependency_manager_impl
             src/dm_activator.cc
     )
-    #set_target_properties(dependency_manager_cxx_static PROPERTIES SOVERSION 1)
+    target_include_directories(dependency_manager_cxx_static PUBLIC include ${CMAKE_SOURCE_DIR}/dependency_manager/api)
+    target_include_directories(dependency_manager_cxx_static PRIVATE src)
+    target_compile_options(dependency_manager_cxx_static PRIVATE ${DM_COMP_OPT})
 
     if (APPLE)
-        target_link_libraries(dependency_manager_cxx_static celix_framework "-undefined dynamic_lookup")
+        target_link_libraries(dependency_manager_cxx_static Celix::framework "-undefined dynamic_lookup")
     else()
-        target_link_libraries(dependency_manager_cxx_static celix_framework)
+        target_link_libraries(dependency_manager_cxx_static Celix::framework)
     endif()
 
     install(
@@ -61,4 +56,9 @@ if (DEPENDENCY_MANAGER_CXX)
     )
     install(TARGETS dependency_manager_cxx_static DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT dependency_manager_cxx)
 
+    unset(DM_COMP_OPT)
+
+
+    #Setup target aliases to match external usage
+    add_library(Celix::dependency_manager_cxx_static ALIAS dependency_manager_cxx_static)
 endif (DEPENDENCY_MANAGER_CXX)

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/dependency_manager_cxx/readme.md
----------------------------------------------------------------------
diff --git a/dependency_manager_cxx/readme.md b/dependency_manager_cxx/readme.md
index 80de7af..63dc5b3 100644
--- a/dependency_manager_cxx/readme.md
+++ b/dependency_manager_cxx/readme.md
@@ -59,3 +59,9 @@ For more information examples please see
 - [The C++ Dependency Manager API](include/celix/dm): The c++ dependency manager header files
 - [Dm C++ example](../examples/dm_example_cxx): A DM C++ example.
 - [Getting Started: Using Services with C++](../documents/getting_started/using_services_with_cxx.md): A introduction how to work with services using the C++ dependency manager
+
+## Using info
+
+If the Celix C++ Dependency Manager is installed The `FindCelix.cmake` will set:
+ - The `Celix::shell_api` interface (i.e. headers only) library target
+ - The `Celix::shell` bundle target

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/deployment_admin/CMakeLists.txt b/deployment_admin/CMakeLists.txt
index a6094ad..4a06be5 100644
--- a/deployment_admin/CMakeLists.txt
+++ b/deployment_admin/CMakeLists.txt
@@ -20,55 +20,48 @@ if (DEPLOYMENT_ADMIN)
 	
     find_package(CURL REQUIRED)
     find_package(UUID REQUIRED)
+    find_package(ZLIB REQUIRED)
 
-    add_definitions(-DUSE_FILE32API)
+    add_library(deployment_admin_api INTERFACE)
+    target_include_directories(deployment_admin_api INTERFACE api)
 
-    include_directories("${CURL_INCLUDE_DIR}")
-    include_directories("${UUID_INCLUDE_DIR}")
-    include_directories("${PROJECT_SOURCE_DIR}/utils/public/include")
-    include_directories("${PROJECT_SOURCE_DIR}/deployment_admin/private/include")
-    include_directories("${PROJECT_SOURCE_DIR}/deployment_admin/public/include")
-    
     add_bundle(deployment_admin
         SYMBOLIC_NAME "apache_celix_deployment_admin"
         VERSION "0.0.2"
         NAME "Apache Celix Deployment Admin"
         SOURCES
-            private/src/deployment_package
-            private/src/deployment_admin
-            private/src/deployment_admin_activator
-            private/src/ioapi
-            private/src/miniunz
-            private/src/unzip
-            private/src/log
-            private/src/log_store
-            private/src/log_sync
+            src/deployment_package
+            src/deployment_admin
+            src/deployment_admin_activator
+            src/ioapi
+            src/miniunz
+            src/unzip
+            src/log
+            src/log_store
+            src/log_sync
+    )
 
-            private/include/deployment_admin.h
-            private/include/deployment_package.h
-            private/include/ioapi.h
-            private/include/log.h
-            private/include/log_event.h
-            private/include/log_store.h
-            private/include/log_sync.h
-            private/include/miniunz.h
-            private/include/unzip.h
+    target_compile_definitions(deployment_admin PRIVATE -DUSE_FILE32API)
+    target_include_directories(deployment_admin PRIVATE
+            src
+            ${CURL_INCLUDE_DIRS}
+            ${UUID_INCLUDE_DIRS}
+            ${ZLIB_INCLUDE_DIRS}
     )
+    target_link_libraries(deployment_admin PRIVATE ${CURL_LIBRARIES} ${UUID_LIBRARIES} ${ZLIB_LIBRARIES} deployment_admin_api)
 
-    
-    install_bundle(deployment_admin
-    	HEADERS
-    		public/include/resource_processor.h
-	)
-    
-    target_link_libraries(deployment_admin celix_framework ${CURL_LIBRARIES})
+    install_bundle(deployment_admin)
 
+    #Setup target aliases to match external usage
+    add_library(Celix::deployment_admin_api ALIAS deployment_admin_api)
+    add_library(Celix::deployment_admin ALIAS deployment_admin)
 
     add_deploy(deployment-admin
-        BUNDLES deployment_admin shell shell_tui log_service log_writer
+        BUNDLES Celix::deployment_admin Celix::shell Celix::shell_tui log_service log_writer
         PROPERTIES
     		"deployment_admin_url=http://localhost:8080"
     		"deployment_admin_identification=celix"
     		"org.osgi.framework.storage.clean=onFirstInit"
     )
+
 endif (DEPLOYMENT_ADMIN)

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/README.md
----------------------------------------------------------------------
diff --git a/deployment_admin/README.md b/deployment_admin/README.md
index d28559c..6716415 100644
--- a/deployment_admin/README.md
+++ b/deployment_admin/README.md
@@ -5,10 +5,20 @@ The Celix Deployment Admin implements the OSGi Deployment Admin specification, w
 It can be used for example with Apache Ace, which allows you to centrally manage and distribute software components, configuration data and other artifacts.
 
 ###### Properties
-    deployment_admin_identification     id used by the deployment admin to identify itself
-    deployment_admin_url                url of the deployment server
-    deployment_cache_dir                possible cache dir for the deployment admin update
-    deployment_tags                     tags used by the deployment admin
+                  tags used by the deployment admin
 
-###### CMake option
+## CMake option
     BUILD_DEPLOYMENT_ADMIN=ON
+
+## Deployment Admin Config Options
+
+- deployment_admin_identification     id used by the deployment admin to identify itself
+- deployment_admin_url                url of the deployment server
+- deployment_cache_dir                possible cache dir for the deployment admin update
+- deployment_tags
+
+## Using info
+
+If the Celix Deployment Admin is installed The `FindCelix.cmake` will set:
+ - The `Celix::deployment_admin_api` interface (i.e. headers only) library target
+ - The `Celix::deployment_admin` bundle target

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/api/resource_processor.h
----------------------------------------------------------------------
diff --git a/deployment_admin/api/resource_processor.h b/deployment_admin/api/resource_processor.h
new file mode 100644
index 0000000..f91e13b
--- /dev/null
+++ b/deployment_admin/api/resource_processor.h
@@ -0,0 +1,54 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * resource_processor.h
+ *
+ *  \date       Feb 13, 2012
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef RESOURCE_PROCESSOR_H_
+#define RESOURCE_PROCESSOR_H_
+
+#include "celix_errno.h"
+
+#define DEPLOYMENTADMIN_RESOURCE_PROCESSOR_SERVICE "resource_processor"
+
+typedef struct resource_processor *resource_processor_pt;
+
+typedef struct resource_processor_service *resource_processor_service_pt;
+
+struct resource_processor_service {
+	resource_processor_pt processor;
+	celix_status_t (*begin)(resource_processor_pt processor, char *packageName);
+
+	celix_status_t (*process)(resource_processor_pt processor, char *name, char *path);
+
+	celix_status_t (*dropped)(resource_processor_pt processor, char *name);
+	celix_status_t (*dropAllResources)(resource_processor_pt 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_pt processor);
+};
+
+#endif /* RESOURCE_PROCESSOR_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/deployment_admin.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/deployment_admin.h b/deployment_admin/private/include/deployment_admin.h
deleted file mode 100644
index a7e3a39..0000000
--- a/deployment_admin/private/include/deployment_admin.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * deployment_admin.h
- *
- *  \date       Nov 7, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef DEPLOYMENT_ADMIN_H_
-#define DEPLOYMENT_ADMIN_H_
-
-#include "bundle_context.h"
-
-typedef struct deployment_admin *deployment_admin_pt;
-
-struct deployment_admin {
-	celix_thread_t poller;
-	bundle_context_pt context;
-
-	bool running;
-	char *current;
-	hash_map_pt packages;
-	char *targetIdentification;
-	char *pollUrl;
-	char *auditlogUrl;
-	unsigned long long auditlogId;
-	unsigned int aditlogSeqNr;
-};
-
-typedef enum {
-	DEPLOYMENT_ADMIN_AUDIT_EVENT__FRAMEWORK_STARTED = 1005,
-	DEPLOYMENT_ADMIN_AUDIT_EVENT__TARGETPROPERTIES_SET = 4001
-
-} DEPLOYMENT_ADMIN_AUDIT_EVENT;
-
-celix_status_t deploymentAdmin_create(bundle_context_pt context, deployment_admin_pt *admin);
-celix_status_t deploymentAdmin_destroy(deployment_admin_pt admin);
-
-#endif /* DEPLOYMENT_ADMIN_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/deployment_package.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/deployment_package.h b/deployment_admin/private/include/deployment_package.h
deleted file mode 100644
index 06c1767..0000000
--- a/deployment_admin/private/include/deployment_package.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * deployment_package.h
- *
- *  \date       Nov 8, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef DEPLOYMENT_PACKAGE_H_
-#define DEPLOYMENT_PACKAGE_H_
-
-#include "version.h"
-#include "bundle_context.h"
-
-#include "array_list.h"
-
-struct bundle_info {
-	char *path;
-	version_pt version;
-	char *symbolicName;
-	bool customizer;
-
-	properties_pt attributes;
-};
-
-typedef struct bundle_info *bundle_info_pt;
-
-struct resource_info {
-	char *path;
-	properties_pt attributes;
-
-	char *resourceProcessor;
-};
-
-typedef struct resource_info *resource_info_pt;
-
-struct deployment_package {
-	bundle_context_pt context;
-	manifest_pt manifest;
-	array_list_pt bundleInfos;
-	array_list_pt resourceInfos;
-	hash_map_pt nameToBundleInfo;
-	hash_map_pt pathToEntry;
-};
-
-typedef struct deployment_package *deployment_package_pt;
-
-celix_status_t deploymentPackage_create(bundle_context_pt context, manifest_pt manifest, deployment_package_pt *package);
-celix_status_t deploymentPackage_destroy(deployment_package_pt package);
-celix_status_t deploymentPackage_getName(deployment_package_pt package, const char** name);
-celix_status_t deploymentPackage_getBundleInfos(deployment_package_pt package, array_list_pt *infos);
-celix_status_t deploymentPackage_getBundleInfoByName(deployment_package_pt package, const char* name, bundle_info_pt *info);
-celix_status_t deploymentPackage_getResourceInfos(deployment_package_pt package, array_list_pt *infos);
-celix_status_t deploymentPackage_getResourceInfoByPath(deployment_package_pt package, const char* path, resource_info_pt *info);
-celix_status_t deploymentPackage_getBundle(deployment_package_pt package, const char* name, bundle_pt *bundle);
-celix_status_t deploymentPackage_getVersion(deployment_package_pt package, version_pt *version);
-
-#endif /* DEPLOYMENT_PACKAGE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/ioapi.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/ioapi.h b/deployment_admin/private/include/ioapi.h
deleted file mode 100644
index 8309c4c..0000000
--- a/deployment_admin/private/include/ioapi.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/* ioapi.h -- IO base function header for compress/uncompress .zip
-   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
-
-         Modifications for Zip64 support
-         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
-
-         For more info read MiniZip_info.txt
-
-         Changes
-
-    Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
-    Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
-               More if/def section may be needed to support other platforms
-    Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
-                          (but you should use iowin32.c for windows instead)
-
-*/
-
-#ifndef _ZLIBIOAPI64_H
-#define _ZLIBIOAPI64_H
-
-#if (!defined(_WIN32)) && (!defined(WIN32))
-
-  // Linux needs this to support file operation on files larger then 4+GB
-  // But might need better if/def to select just the platforms that needs them.
-
-        #ifndef __USE_FILE_OFFSET64
-                #define __USE_FILE_OFFSET64
-        #endif
-        #ifndef __USE_LARGEFILE64
-                #define __USE_LARGEFILE64
-        #endif
-        #ifndef _LARGEFILE64_SOURCE
-                #define _LARGEFILE64_SOURCE
-        #endif
-        #ifndef _FILE_OFFSET_BIT
-                #define _FILE_OFFSET_BIT 64
-        #endif
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "zlib.h"
-
-#if defined(USE_FILE32API)
-#define fopen64 fopen
-#define ftello64 ftell
-#define fseeko64 fseek
-#else
-#ifdef _MSC_VER
- #define fopen64 fopen
- #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
-  #define ftello64 _ftelli64
-  #define fseeko64 _fseeki64
- #else // old MSC
-  #define ftello64 ftell
-  #define fseeko64 fseek
- #endif
-#endif
-#endif
-
-/*
-#ifndef ZPOS64_T
-  #ifdef _WIN32
-                #define ZPOS64_T fpos_t
-  #else
-    #include <stdint.h>
-    #define ZPOS64_T uint64_t
-  #endif
-#endif
-*/
-
-#ifdef HAVE_MINIZIP64_CONF_H
-#include "mz64conf.h"
-#endif
-
-/* a type choosen by DEFINE */
-#ifdef HAVE_64BIT_INT_CUSTOM
-typedef  64BIT_INT_CUSTOM_TYPE ZPOS64_T;
-#else
-#ifdef HAS_STDINT_H
-#include "stdint.h"
-typedef uint64_t ZPOS64_T;
-#else
-
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-typedef unsigned __int64 ZPOS64_T;
-#else
-typedef unsigned long long int ZPOS64_T;
-#endif
-#endif
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#define ZLIB_FILEFUNC_SEEK_CUR (1)
-#define ZLIB_FILEFUNC_SEEK_END (2)
-#define ZLIB_FILEFUNC_SEEK_SET (0)
-
-#define ZLIB_FILEFUNC_MODE_READ      (1)
-#define ZLIB_FILEFUNC_MODE_WRITE     (2)
-#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
-
-#define ZLIB_FILEFUNC_MODE_EXISTING (4)
-#define ZLIB_FILEFUNC_MODE_CREATE   (8)
-
-
-#ifndef ZCALLBACK
- #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
-   #define ZCALLBACK CALLBACK
- #else
-   #define ZCALLBACK
- #endif
-#endif
-
-
-
-
-typedef voidpf   (ZCALLBACK *open_file_func)      OF((voidpf opaque, const char* filename, int mode));
-typedef uLong    (ZCALLBACK *read_file_func)      OF((voidpf opaque, voidpf stream, void* buf, uLong size));
-typedef uLong    (ZCALLBACK *write_file_func)     OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
-typedef int      (ZCALLBACK *close_file_func)     OF((voidpf opaque, voidpf stream));
-typedef int      (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
-
-typedef long     (ZCALLBACK *tell_file_func)      OF((voidpf opaque, voidpf stream));
-typedef long     (ZCALLBACK *seek_file_func)      OF((voidpf opaque, voidpf stream, uLong offset, int origin));
-
-
-/* here is the "old" 32 bits structure structure */
-typedef struct zlib_filefunc_def_s
-{
-    open_file_func      zopen_file;
-    read_file_func      zread_file;
-    write_file_func     zwrite_file;
-    tell_file_func      ztell_file;
-    seek_file_func      zseek_file;
-    close_file_func     zclose_file;
-    testerror_file_func zerror_file;
-    voidpf              opaque;
-} zlib_filefunc_def;
-
-typedef ZPOS64_T (ZCALLBACK *tell64_file_func)    OF((voidpf opaque, voidpf stream));
-typedef long     (ZCALLBACK *seek64_file_func)    OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
-typedef voidpf   (ZCALLBACK *open64_file_func)    OF((voidpf opaque, const void* filename, int mode));
-
-typedef struct zlib_filefunc64_def_s
-{
-    open64_file_func    zopen64_file;
-    read_file_func      zread_file;
-    write_file_func     zwrite_file;
-    tell64_file_func    ztell64_file;
-    seek64_file_func    zseek64_file;
-    close_file_func     zclose_file;
-    testerror_file_func zerror_file;
-    voidpf              opaque;
-} zlib_filefunc64_def;
-
-void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
-void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
-
-/* now internal definition, only for zip.c and unzip.h */
-typedef struct zlib_filefunc64_32_def_s
-{
-    zlib_filefunc64_def zfile_func64;
-    open_file_func      zopen32_file;
-    tell_file_func      ztell32_file;
-    seek_file_func      zseek32_file;
-} zlib_filefunc64_32_def;
-
-
-#define ZREAD64(filefunc,filestream,buf,size)     ((*((filefunc).zfile_func64.zread_file))   ((filefunc).zfile_func64.opaque,filestream,buf,size))
-#define ZWRITE64(filefunc,filestream,buf,size)    ((*((filefunc).zfile_func64.zwrite_file))  ((filefunc).zfile_func64.opaque,filestream,buf,size))
-//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
-//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
-#define ZCLOSE64(filefunc,filestream)             ((*((filefunc).zfile_func64.zclose_file))  ((filefunc).zfile_func64.opaque,filestream))
-#define ZERROR64(filefunc,filestream)             ((*((filefunc).zfile_func64.zerror_file))  ((filefunc).zfile_func64.opaque,filestream))
-
-voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
-long    call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
-ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
-
-void    fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
-
-#define ZOPEN64(filefunc,filename,mode)         (call_zopen64((&(filefunc)),(filename),(mode)))
-#define ZTELL64(filefunc,filestream)            (call_ztell64((&(filefunc)),(filestream)))
-#define ZSEEK64(filefunc,filestream,pos,mode)   (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/log.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/log.h b/deployment_admin/private/include/log.h
deleted file mode 100644
index fa77911..0000000
--- a/deployment_admin/private/include/log.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * log.h
- *
- *  \date       Apr 18, 2012
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef LOG_H_
-#define LOG_H_
-
-#include "log_event.h"
-#include "log_store.h"
-
-#include "bundle_event.h"
-#include "framework_event.h"
-
-typedef struct log *log_pt;
-
-celix_status_t log_create(log_store_pt store, log_pt *log);
-celix_status_t log_log(log_pt log, unsigned int type, properties_pt properties);
-
-celix_status_t log_bundleChanged(void * listener, bundle_event_pt event);
-celix_status_t log_frameworkEvent(void * listener, framework_event_pt event);
-
-#endif /* LOG_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/log_event.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/log_event.h b/deployment_admin/private/include/log_event.h
deleted file mode 100644
index c1a76a9..0000000
--- a/deployment_admin/private/include/log_event.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * log_event.h
- *
- *  \date       Apr 19, 2012
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef LOG_EVENT_H_
-#define LOG_EVENT_H_
-
-#include "properties.h"
-
-struct log_event {
-	char *targetId;
-	unsigned long logId;
-	unsigned long id;
-	unsigned long time;
-	unsigned int type;
-	properties_pt properties;
-};
-
-typedef struct log_event *log_event_pt;
-
-#endif /* LOG_EVENT_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/log_store.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/log_store.h b/deployment_admin/private/include/log_store.h
deleted file mode 100644
index 84299b3..0000000
--- a/deployment_admin/private/include/log_store.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * log_store.h
- *
- *  \date       Apr 18, 2012
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef LOG_STORE_H_
-#define LOG_STORE_H_
-
-#include "log_event.h"
-
-#include "properties.h"
-#include "array_list.h"
-
-typedef struct log_store *log_store_pt;
-
-celix_status_t logStore_create(log_store_pt *store);
-celix_status_t logStore_put(log_store_pt store, unsigned int type, properties_pt properties, log_event_pt *event);
-
-celix_status_t logStore_getLogId(log_store_pt store, unsigned long *id);
-celix_status_t logStore_getEvents(log_store_pt store, array_list_pt *events);
-
-celix_status_t logStore_getHighestId(log_store_pt store, long *id);
-
-#endif /* LOG_STORE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/log_sync.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/log_sync.h b/deployment_admin/private/include/log_sync.h
deleted file mode 100644
index 7cd10d9..0000000
--- a/deployment_admin/private/include/log_sync.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * log_sync.h
- *
- *  \date       Apr 19, 2012
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef LOG_SYNC_H_
-#define LOG_SYNC_H_
-
-#include "log_store.h"
-
-typedef struct log_sync *log_sync_pt;
-
-celix_status_t logSync_create(char *targetId, log_store_pt store, log_sync_pt *logSync);
-
-#endif /* LOG_SYNC_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/deployment_admin/private/include/miniunz.h
----------------------------------------------------------------------
diff --git a/deployment_admin/private/include/miniunz.h b/deployment_admin/private/include/miniunz.h
deleted file mode 100644
index f54b1fa..0000000
--- a/deployment_admin/private/include/miniunz.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * miniunz.h
- *
- *  \date       Aug 8, 2012
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef MINIUNZ_H_
-#define MINIUNZ_H_
-
-#include "celix_errno.h"
-
-celix_status_t unzip_extractDeploymentPackage(char * packageName, char * destination);
-
-#endif /* MINIUNZ_H_ */


Mime
View raw message