celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [3/4] celix git commit: CELIX-438: Add a dependency manager API with the celix prefix. Also add a compile options to enable deprecated compiler warning for the 'old' api.
Date Mon, 26 Nov 2018 19:59:28 GMT
http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix/dm/Component_Impl.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix/dm/Component_Impl.h b/libs/framework/include/celix/dm/Component_Impl.h
index 7848c6a..54914be 100644
--- a/libs/framework/include/celix/dm/Component_Impl.h
+++ b/libs/framework/include/celix/dm/Component_Impl.h
@@ -30,7 +30,7 @@
 using namespace celix::dm;
 
 template<class T>
-Component<T>::Component(const bundle_context_pt context, std::string name) : BaseComponent(context, name) {}
+Component<T>::Component(celix_bundle_context_t *context, std::string name) : BaseComponent(context, name) {}
 
 template<class T>
 Component<T>::~Component() {
@@ -42,7 +42,7 @@ template<class I>
 Component<T>& Component<T>::addInterfaceWithName(const std::string serviceName, const std::string version, const Properties properties) {
     if (!serviceName.empty()) {
         //setup c properties
-        properties_pt cProperties = properties_create();
+        celix_properties_t *cProperties = properties_create();
         properties_set(cProperties, CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_CXX_LANGUAGE);
         for (const auto& pair : properties) {
             properties_set(cProperties, (char *) pair.first.c_str(), (char *) pair.second.c_str());
@@ -52,7 +52,7 @@ Component<T>& Component<T>::addInterfaceWithName(const std::string serviceName,
         I* intfPtr = static_cast<I*>(cmpPtr); //NOTE T should implement I
 
         const char *cVersion = version.empty() ? nullptr : version.c_str();
-        component_addInterface(this->cComponent(), (char *) serviceName.c_str(), (char *) cVersion,
+        celix_dmComponent_addInterface(this->cComponent(), (char *) serviceName.c_str(), (char *) cVersion,
                                intfPtr, cProperties);
     } else {
         std::cerr << "Cannot add interface with a empty name\n";
@@ -78,14 +78,14 @@ template<class T>
 template<class I>
 Component<T>& Component<T>::addCInterface(const I* svc, const std::string serviceName, const std::string version, const Properties properties) {
     static_assert(std::is_pod<I>::value, "Service I must be a 'Plain Old Data' object");
-    properties_pt cProperties = properties_create();
+    celix_properties_t *cProperties = properties_create();
     properties_set(cProperties, CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_C_LANGUAGE);
     for (const auto& pair : properties) {
         properties_set(cProperties, (char*)pair.first.c_str(), (char*)pair.second.c_str());
     }
 
     const char *cVersion = version.empty() ? nullptr : version.c_str();
-    component_addInterface(this->cComponent(), (char*)serviceName.c_str(), (char*)cVersion, svc, cProperties);
+    celix_dmComponent_addInterface(this->cComponent(), (char*)serviceName.c_str(), (char*)cVersion, svc, cProperties);
 
     return *this;
 };
@@ -94,7 +94,7 @@ template<class T>
 template<class I>
 Component<T>& Component<T>::removeCInterface(const I* svc){
     static_assert(std::is_pod<I>::value, "Service I must be a 'Plain Old Data' object");
-    component_removeInterface(this->cComponent(), svc);
+    celix_dmComponent_removeInterface(this->cComponent(), svc);
     return *this;
 };
 
@@ -111,7 +111,7 @@ ServiceDependency<T,I>& Component<T>::createServiceDependency(const std::string
     }
 #endif
     this->dependencies.push_back(dep);
-    component_addServiceDependency(cComponent(), dep->cServiceDependency());
+    celix_dmComponent_addServiceDependency(cComponent(), dep->cServiceDependency());
     dep->setComponentInstance(&getInstance());
     return *dep;
 }
@@ -137,7 +137,7 @@ CServiceDependency<T,I>& Component<T>::createCServiceDependency(const std::strin
     }
 #endif
     this->dependencies.push_back(dep);
-    component_addServiceDependency(cComponent(), dep->cServiceDependency());
+    celix_dmComponent_addServiceDependency(cComponent(), dep->cServiceDependency());
     dep->setComponentInstance(&getInstance());
     return *dep;
 }
@@ -151,13 +151,13 @@ Component<T>& Component<T>::remove(CServiceDependency<T,I>& dep) {
 }
 
 template<class T>
-Component<T>* Component<T>::create(bundle_context_pt context) {
+Component<T>* Component<T>::create(celix_bundle_context_t *context) {
     std::string name = typeName<T>();
     return Component<T>::create(context, name);
 }
 
 template<class T>
-Component<T>* Component<T>::create(bundle_context_pt context, std::string name) {
+Component<T>* Component<T>::create(celix_bundle_context_t *context, std::string name) {
 #ifdef __EXCEPTIONS
     Component<T>* cmp = new Component<T>{context, name};
 #else
@@ -268,7 +268,7 @@ Component<T>& Component<T>::setCallbacks(
         return 0;
     };
 
-    component_setCallbacks(this->cComponent(), cInit, cStart, cStop, cDeinit);
+    celix_dmComponent_setCallbacks(this->cComponent(), cInit, cStart, cStop, cDeinit);
 
     return *this;
 }
@@ -322,7 +322,7 @@ Component<T>& Component<T>::setCallbacks(
         return 0;
     };
 
-    component_setCallbacks(this->cComponent(), cInit, cStart, cStop, cDeinit);
+    celix_dmComponent_setCallbacks(this->cComponent(), cInit, cStart, cStop, cDeinit);
 
     return *this;
 }
@@ -330,7 +330,7 @@ Component<T>& Component<T>::setCallbacks(
 template<class T>
 Component<T>& Component<T>::removeCallbacks() {
 
-    component_setCallbacks(this->cComponent(), nullptr, nullptr, nullptr, nullptr);
+    celix_dmComponent_setCallbacks(this->cComponent(), nullptr, nullptr, nullptr, nullptr);
 
     return *this;
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix/dm/DependencyManager.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix/dm/DependencyManager.h b/libs/framework/include/celix/dm/DependencyManager.h
index f90a03c..0f77da7 100644
--- a/libs/framework/include/celix/dm/DependencyManager.h
+++ b/libs/framework/include/celix/dm/DependencyManager.h
@@ -24,7 +24,7 @@
 
 #include "bundle_context.h"
 #include "celix_bundle_context.h"
-#include "dm_dependency_manager.h"
+#include "celix_dependency_manager.h"
 
 #include <vector>
 #include <mutex>
@@ -36,7 +36,7 @@ namespace celix { namespace dm {
 
     class DependencyManager {
     public:
-        DependencyManager(bundle_context_pt ctx) : context(ctx) {
+        DependencyManager(celix_bundle_context_t *ctx) : context(ctx) {
                 this->cDepMan = celix_bundleContext_getDependencyManager(ctx);
         }
 
@@ -58,8 +58,8 @@ namespace celix { namespace dm {
         DependencyManager(const DependencyManager&) = delete;
         DependencyManager& operator=(const DependencyManager&) = delete;
 
-        bundle_context_pt bundleContext() const { return context; }
-        dm_dependency_manager_pt cDependencyManager() const { return cDepMan; }
+        celix_bundle_context_t* bundleContext() const { return context; }
+        celix_dependency_manager_t *cDependencyManager() const { return cDepMan; }
 
 
         /**
@@ -111,7 +111,7 @@ namespace celix { namespace dm {
                 }
                 for (auto it = toBeStartedComponents.begin(); it != toBeStartedComponents.end(); ++it) {
 
-                        dependencyManager_add(cDepMan, (*it)->cComponent());
+                        celix_dependencyManager_add(cDepMan, (*it)->cComponent());
                         {
                                 std::lock_guard<std::recursive_mutex> lock(componentsMutex);
                                 startedComponents.push_back(std::move(*it));
@@ -131,15 +131,15 @@ namespace celix { namespace dm {
          * Stops the Dependency Manager
          */
         void stop() {
-                dependencyManager_removeAllComponents(cDepMan);
+                celix_dependencyManager_removeAllComponents(cDepMan);
                 queuedComponents.clear();
                 startedComponents.clear();
         }
     private:
-        bundle_context_pt context {nullptr};
+        celix_bundle_context_t *context {nullptr};
         std::vector<std::unique_ptr<BaseComponent>> queuedComponents {};
         std::vector<std::unique_ptr<BaseComponent>> startedComponents {};
-        dm_dependency_manager_pt cDepMan {nullptr};
+        celix_dependency_manager_t* cDepMan {nullptr};
         std::recursive_mutex componentsMutex{};
     };
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix/dm/DmActivator.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix/dm/DmActivator.h b/libs/framework/include/celix/dm/DmActivator.h
index d7aac3c..55a7573 100644
--- a/libs/framework/include/celix/dm/DmActivator.h
+++ b/libs/framework/include/celix/dm/DmActivator.h
@@ -38,7 +38,7 @@ namespace celix { namespace dm {
 
         DependencyManager& manager() const { return this->mng; }
 
-        bundle_context_pt context() const { return this->ctx; }
+        celix_bundle_context_t* context() const { return this->ctx; }
 
         /**
          * The init of the DM Activator. Should be overridden by the bundle specific DM activator.
@@ -66,7 +66,7 @@ namespace celix { namespace dm {
 
     protected:
         DependencyManager& mng;
-        bundle_context_pt ctx;
+        celix_bundle_context_t *ctx;
     private:
         int start() {
             celix_status_t status = CELIX_SUCCESS;
@@ -82,15 +82,15 @@ namespace celix { namespace dm {
             this->deinit();
 
             // Remove all components
-            dependencyManager_removeAllComponents(this->mng.cDependencyManager());
+            celix_dependencyManager_removeAllComponents(this->mng.cDependencyManager());
 
             return status;
         }
 
-        friend int ::bundleActivator_create(::bundle_context_pt, void**);
-        friend int ::bundleActivator_start(void*, ::bundle_context_pt);
-        friend int ::bundleActivator_stop(void*, ::bundle_context_pt);
-        friend int ::bundleActivator_destroy(void*, ::bundle_context_pt);
+        friend int ::bundleActivator_create(::celix_bundle_context_t*, void**);
+        friend int ::bundleActivator_start(void*, ::celix_bundle_context_t*);
+        friend int ::bundleActivator_stop(void*, ::celix_bundle_context_t*);
+        friend int ::bundleActivator_destroy(void*, ::celix_bundle_context_t*);
     };
 }}
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix/dm/ServiceDependency.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix/dm/ServiceDependency.h b/libs/framework/include/celix/dm/ServiceDependency.h
index f439b82..59d43f0 100644
--- a/libs/framework/include/celix/dm/ServiceDependency.h
+++ b/libs/framework/include/celix/dm/ServiceDependency.h
@@ -43,16 +43,16 @@ namespace celix { namespace dm {
     class BaseServiceDependency {
     protected:
         const bool valid;
-        dm_service_dependency_pt cServiceDep {nullptr};
+        celix_dm_service_dependency_t *cServiceDep {nullptr};
 
         void setDepStrategy(DependencyUpdateStrategy strategy) {
             if (!valid) {
                 return;
             }
             if (strategy == DependencyUpdateStrategy::locking) {
-                serviceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
+                celix_dmServiceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
             } else if (strategy == DependencyUpdateStrategy::suspend) {
-                serviceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
+                celix_dmServiceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
             } else {
                 std::cerr << "Unexpected dependency update strategy. Cannot convert for dm_depdendency\n";
             }
@@ -60,9 +60,9 @@ namespace celix { namespace dm {
     public:
         BaseServiceDependency(bool v)  : valid{v} {
             if (this->valid) {
-                serviceDependency_create(&this->cServiceDep);
+                this->cServiceDep = celix_dmServiceDependency_create();
                 //NOTE using suspend as default strategy
-                serviceDependency_setStrategy(this->cServiceDep,  DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
+                celix_dmServiceDependency_setStrategy(this->cServiceDep,  DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
             }
         }
 
@@ -79,7 +79,7 @@ namespace celix { namespace dm {
         /**
          * Returns the C DM service dependency
          */
-        dm_service_dependency_pt cServiceDependency() const { return cServiceDep; }
+        celix_dm_service_dependency_t *cServiceDependency() const { return cServiceDep; }
     };
 
     template<class T>
@@ -202,7 +202,7 @@ namespace celix { namespace dm {
         std::function<void(const I* service, Properties&& properties)> removeFp{nullptr};
 
         void setupCallbacks();
-        int invokeCallback(std::function<void(const I*, Properties&&)> fp, service_reference_pt  ref, const void* service);
+        int invokeCallback(std::function<void(const I*, Properties&&)> fp, const celix_properties_t *props, const void* service);
 
         void setupService();
     };
@@ -316,7 +316,7 @@ namespace celix { namespace dm {
 
         void setupService();
         void setupCallbacks();
-        int invokeCallback(std::function<void(I*, Properties&&)> fp, service_reference_pt  ref, const void* service);
+        int invokeCallback(std::function<void(I*, Properties&&)> fp, const celix_properties_t *props, const void* service);
     };
 }}
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix/dm/ServiceDependency_Impl.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix/dm/ServiceDependency_Impl.h b/libs/framework/include/celix/dm/ServiceDependency_Impl.h
index 0f0dc26..5254728 100644
--- a/libs/framework/include/celix/dm/ServiceDependency_Impl.h
+++ b/libs/framework/include/celix/dm/ServiceDependency_Impl.h
@@ -20,6 +20,7 @@
 #include <vector>
 #include <iostream>
 #include "constants.h"
+#include "celix_properties.h"
 
 using namespace celix::dm;
 
@@ -50,7 +51,7 @@ void CServiceDependency<T,I>::setupService() {
     }
     const char* cversion = this->versionRange.empty() ? nullptr : versionRange.c_str();
     const char* cfilter = filter.empty() ? nullptr : filter.c_str();
-    serviceDependency_setService(this->cServiceDependency(), this->name.c_str(), cversion, cfilter);
+    celix_dmServiceDependency_setService(this->cServiceDependency(), this->name.c_str(), cversion, cfilter);
 };
 
 template<class T, typename I>
@@ -68,7 +69,7 @@ CServiceDependency<T,I>& CServiceDependency<T,I>::setRequired(bool req) {
     if (!this->valid) {
         return *this;
     }
-    serviceDependency_setRequired(this->cServiceDependency(), req);
+    celix_dmServiceDependency_setRequired(this->cServiceDependency(), req);
     return *this;
 }
 
@@ -158,49 +159,47 @@ void CServiceDependency<T,I>::setupCallbacks() {
         return;
     }
 
-    int(*cset)(void*, service_reference_pt, const void*) {nullptr};
-    int(*cadd)(void*, service_reference_pt, const void*) {nullptr};
-    int(*crem)(void*, service_reference_pt, const void*) {nullptr};
+    int(*cset)(void*, void *, const celix_properties_t*) {nullptr};
+    int(*cadd)(void*, void *, const celix_properties_t*) {nullptr};
+    int(*crem)(void*, void *, const celix_properties_t*) {nullptr};
 
     if (setFp != nullptr) {
-        cset = [](void* handle, service_reference_pt ref, const void* service) -> int {
+        cset = [](void* handle, void *service, const celix_properties_t *props) -> int {
             auto dep = (CServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->setFp, ref, service);
+            return dep->invokeCallback(dep->setFp, props, service);
         };
     }
     if (addFp != nullptr) {
-        cadd = [](void* handle, service_reference_pt ref, const void* service) -> int {
+        cadd = [](void* handle, void *service, const celix_properties_t *props) -> int {
             auto dep = (CServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->addFp, ref, service);
+            return dep->invokeCallback(dep->addFp, props, service);
         };
     }
     if (removeFp != nullptr) {
-        crem= [](void* handle, service_reference_pt ref, const void* service) -> int {
+        crem= [](void* handle, void *service, const celix_properties_t *props) -> int {
             auto dep = (CServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->removeFp, ref, service);
+            return dep->invokeCallback(dep->removeFp, props, service);
         };
     }
-    serviceDependency_setCallbackHandle(this->cServiceDependency(), this);
-    serviceDependency_setCallbacksWithServiceReference(this->cServiceDependency(), cset, cadd, nullptr, crem, nullptr);
+    celix_dmServiceDependency_setCallbackHandle(this->cServiceDependency(), this);
+    celix_dm_service_dependency_callback_options_t opts{};
+    opts.addWithProps = cadd;
+    opts.removeWithProps = crem;
+    opts.setWithProps = cset;
+    celix_dmServiceDependency_setCallbacksWithOptions(this->cServiceDependency(), &opts);
 }
 
 template<class T, typename I>
-int CServiceDependency<T,I>::invokeCallback(std::function<void(const I*, Properties&&)> fp, service_reference_pt  ref, const void* service) {
-    service_registration_pt reg {nullptr};
-    properties_pt props {nullptr};
-
+int CServiceDependency<T,I>::invokeCallback(std::function<void(const I*, Properties&&)> fp, const celix_properties_t *props, const void* service) {
     Properties properties {};
     const char* key {nullptr};
     const char* value {nullptr};
 
-    if (ref != nullptr) {
-        serviceReference_getServiceRegistration(ref, &reg);
-        serviceRegistration_getProperties(reg, &props);
-        
+    if (props != nullptr) {
         hash_map_iterator_t iter = hashMapIterator_construct((hash_map_pt)props);
         while(hashMapIterator_hasNext(&iter)) {
             key = (const char*) hashMapIterator_nextKey(&iter);
-            value = properties_get(props, key);
+            value = celix_properties_get(props, key, NULL);
             //std::cout << "got property " << key << "=" << value << "\n";
             properties[key] = value;
         }
@@ -271,7 +270,7 @@ void ServiceDependency<T,I>::setupService() {
         this->modifiedFilter = this->filter;
     }
 
-    serviceDependency_setService(this->cServiceDependency(), n.c_str(), v, this->modifiedFilter.c_str());
+    celix_dmServiceDependency_setService(this->cServiceDependency(), n.c_str(), v, this->modifiedFilter.c_str());
 }
 
 template<class T, class I>
@@ -377,7 +376,7 @@ ServiceDependency<T,I>& ServiceDependency<T,I>::setCallbacks(
 
 template<class T, class I>
 ServiceDependency<T,I>& ServiceDependency<T,I>::setRequired(bool req) {
-    serviceDependency_setRequired(this->cServiceDependency(), req);
+    celix_dmServiceDependency_setRequired(this->cServiceDependency(), req);
     return *this;
 }
 
@@ -388,28 +387,22 @@ ServiceDependency<T,I>& ServiceDependency<T,I>::setStrategy(DependencyUpdateStra
 };
 
 template<class T, class I>
-int ServiceDependency<T,I>::invokeCallback(std::function<void(I*, Properties&&)> fp, service_reference_pt  ref, const void* service) {
-    service_registration_pt reg {nullptr};
-    properties_pt props {nullptr};
+int ServiceDependency<T,I>::invokeCallback(std::function<void(I*, Properties&&)> fp, const celix_properties_t *props, const void* service) {
     I *svc = (I*)service;
 
     Properties properties {};
     const char* key {nullptr};
     const char* value {nullptr};
 
-    if (ref != nullptr) {
-        serviceReference_getServiceRegistration(ref, &reg);
-        serviceRegistration_getProperties(reg, &props);
 	if (props != nullptr) {
             hash_map_iterator_t iter = hashMapIterator_construct((hash_map_pt)props);
             while(hashMapIterator_hasNext(&iter)) {
                 key = (const char*) hashMapIterator_nextKey(&iter);
-                value = properties_get(props, key);
+                value = celix_properties_get(props, key, NULL);
                 //std::cout << "got property " << key << "=" << value << "\n";
                 properties[key] = value;
             }
 	}
-    }
 
     fp(svc, std::move(properties)); //explicit move of lvalue properties.
     return 0;
@@ -421,29 +414,33 @@ void ServiceDependency<T,I>::setupCallbacks() {
         return;
     }
 
-    int(*cset)(void*, service_reference_pt, const void*) {nullptr};
-    int(*cadd)(void*, service_reference_pt, const void*) {nullptr};
-    int(*crem)(void*, service_reference_pt, const void*) {nullptr};
+    int(*cset)(void*, void *, const celix_properties_t*) {nullptr};
+    int(*cadd)(void*, void *, const celix_properties_t*) {nullptr};
+    int(*crem)(void*, void *, const celix_properties_t*) {nullptr};
 
     if (setFp != nullptr) {
-        cset = [](void* handle, service_reference_pt ref, const void* service) -> int {
+        cset = [](void* handle, void *service, const celix_properties_t* props) -> int {
             auto dep = (ServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->setFp, ref, service);
+            return dep->invokeCallback(dep->setFp, props, service);
         };
     }
     if (addFp != nullptr) {
-        cadd = [](void* handle, service_reference_pt ref, const void* service) -> int {
+        cadd = [](void* handle, void *service, const celix_properties_t* props) -> int {
             auto dep = (ServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->addFp, ref, service);
+            return dep->invokeCallback(dep->addFp, props, service);
         };
     }
     if (removeFp != nullptr) {
-        crem = [](void* handle, service_reference_pt ref, const void* service) -> int {
+        crem = [](void* handle, void *service, const celix_properties_t*props) -> int {
             auto dep = (ServiceDependency<T,I>*) handle;
-            return dep->invokeCallback(dep->removeFp, ref, service);
+            return dep->invokeCallback(dep->removeFp, props, service);
         };
     }
 
-    serviceDependency_setCallbackHandle(this->cServiceDependency(), this);
-    serviceDependency_setCallbacksWithServiceReference(this->cServiceDependency(), cset, cadd, nullptr, crem, nullptr);
+    celix_dmServiceDependency_setCallbackHandle(this->cServiceDependency(), this);
+    celix_dm_service_dependency_callback_options_t opts{};
+    opts.setWithProps = cset;
+    opts.addWithProps = cadd;
+    opts.removeWithProps = crem;
+    celix_dmServiceDependency_setCallbacksWithOptions(this->cServiceDependency(), &opts);
 };

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_api.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_api.h b/libs/framework/include/celix_api.h
index b941a78..bb1fd01 100644
--- a/libs/framework/include/celix_api.h
+++ b/libs/framework/include/celix_api.h
@@ -38,7 +38,8 @@
 #include "celix_framework_factory.h"
 #include "celix_launcher.h"
 
-#include "dm_dependency_manager.h"
+#include "celix_dependency_manager.h"
+#include "celix_dm_component.h"
 #include "dm_service_dependency.h"
 
 #include "celix_bundle_activator.h"

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_bundle_context.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_bundle_context.h b/libs/framework/include/celix_bundle_context.h
index 6ecc445..fc7d978 100644
--- a/libs/framework/include/celix_bundle_context.h
+++ b/libs/framework/include/celix_bundle_context.h
@@ -770,7 +770,7 @@ long celix_bundleContext_trackServiceTrackers(
  *
  * @return the dependency manager or NULL if unsuccessful.
  */
-dm_dependency_manager_t* celix_bundleContext_getDependencyManager(celix_bundle_context_t *ctx);
+celix_dependency_manager_t* celix_bundleContext_getDependencyManager(celix_bundle_context_t *ctx);
 
 
 /**

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_dependency_manager.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_dependency_manager.h b/libs/framework/include/celix_dependency_manager.h
new file mode 100644
index 0000000..e850d0a
--- /dev/null
+++ b/libs/framework/include/celix_dependency_manager.h
@@ -0,0 +1,86 @@
+/**
+ *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 CELIX_DEPENDENCY_MANAGER_H_
+#define CELIX_DEPENDENCY_MANAGER_H_
+
+#include "celix_types.h"
+
+#include "celix_errno.h"
+#include "celix_array_list.h"
+#include "celix_dm_info.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Adds a DM component to the dependency manager
+ */
+celix_status_t celix_dependencyManager_add(celix_dependency_manager_t *manager, celix_dm_component_t *component);
+
+/**
+ * Removes a DM component from the dependency manager and destroys it
+ */
+celix_status_t celix_dependencyManager_remove(celix_dependency_manager_t *manager, celix_dm_component_t *component);
+
+/**
+ * Removes all DM components from the dependency manager
+ */
+celix_status_t celix_dependencyManager_removeAllComponents(celix_dependency_manager_t *manager);
+
+/**
+ * Create and returns a dependency manager info struct for the specified bundle.
+ * The dependency manager info contains information about the state of the dependency manager components
+ *
+ * Caller has ownership of the return value (use celix_dependencyManager_destroyInfo to free the memory).
+ *
+ * @param manager The dependency manager
+ * @param bndId The bundle id to get the info from.
+ * @returns The dependency manager info for the provided bundle id or NULL if the bundle id is invalid.
+ */
+celix_dependency_manager_info_t* celix_dependencyManager_createInfo(celix_dependency_manager_t *manager, long bndId);
+
+/**
+ * Create and returns a dependency manager info structd for all started bundles.
+ * The dependency manager info contains information about the state of the dependency manager components
+ *
+ * Caller has ownership of the return values (use celix_dependencyManager_destroyInfos to free the memory).
+ *
+ * @param manager The dependency manager
+ * @returns A celix array of dependency manager infos for the provided bundle id or NULL if the bundle id is invalid.
+ */
+celix_array_list_t * /*celix_dependency_manager_info_t entries*/ celix_dependencyManager_createInfos(celix_dependency_manager_t *manager);
+
+/**
+ * Destroys a DM info struct.
+ */
+void celix_dependencyManager_destroyInfo(celix_dependency_manager_t *manager, celix_dependency_manager_info_t *info);
+
+/**
+ * Destroys a celix array list of  DM info structs.
+ */
+void celix_dependencyManager_destroyInfos(celix_dependency_manager_t *manager, celix_array_list_t * infos /*entries celix_dependency_manager_info_t*/);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CELIX_DEPENDENCY_MANAGER_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_dm_component.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_dm_component.h b/libs/framework/include/celix_dm_component.h
new file mode 100644
index 0000000..bcfaf52
--- /dev/null
+++ b/libs/framework/include/celix_dm_component.h
@@ -0,0 +1,154 @@
+/**
+ *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 CELIX_COMPONENT_H_
+#define CELIX_COMPONENT_H_
+
+#include <stdbool.h>
+
+#include "celix_types.h"
+#include "celix_errno.h"
+#include "properties.h"
+#include "array_list.h"
+#include "celix_dm_info.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum celix_dm_component_state_enum {
+    DM_CMP_STATE_INACTIVE = 1,
+    DM_CMP_STATE_WAITING_FOR_REQUIRED = 2,
+    DM_CMP_STATE_INSTANTIATED_AND_WAITING_FOR_REQUIRED = 3,
+    DM_CMP_STATE_TRACKING_OPTIONAL = 4,
+} celix_dm_component_state_t;
+
+#define CELIX_DM_COMPONENT_MAX_ID_LENGTH 64
+#define CELIX_DM_COMPONENT_MAX_NAME_LENGTH 128
+
+typedef int (*celix_dm_cmp_lifecycle_fpt)(void *userData);
+
+/**
+ * Creates a DM Component
+ * Caller has ownership.
+ */
+celix_dm_component_t* celix_dmComponent_create(celix_bundle_context_t *context, const char* name);
+
+/**
+ * Destroys a DM Component
+ */
+void celix_dmComponent_destroy(celix_dm_component_t *cmp);
+
+/**
+ * Specify if a default 'service.lang=C' should be added to the properties of interfaces if no 'service.lang' has been
+ * provided. Default is false. Note that this should be set before using component_addInterface.
+ */
+celix_status_t celix_dmComponent_setCLanguageProperty(celix_dm_component_t *component, bool setCLangProp);
+
+
+/**
+ * Adds a C interface to provide as service to the Celix framework.
+ *
+ * @param serviceName the service name.
+ * @param version The version of the interface (e.g. "1.0.0"), Can be a NULL pointer.
+ * @param properties To (meta) properties to provide with the service. Can be a NULL pointer.
+ */
+celix_status_t celix_dmComponent_addInterface(celix_dm_component_t *component, const char* serviceName, const char* serviceVersion, const void* service, celix_properties_t *properties);
+
+/**
+ * Removed  a C interface from a component the Celix framework.
+ *
+ * @param serviceName the service name.
+ * @return CELIX_SUCCESS when removed, CELIX_ILLEGAL_ARGUMENT when the component does not provide the interface
+ */
+celix_status_t celix_dmComponent_removeInterface(celix_dm_component_t *component, const void* service);
+/**
+ * Sets the implementation of the component. e.g. the component handle/self/this pointer.
+ */
+celix_status_t celix_dmComponent_setImplementation(celix_dm_component_t *component, void* implementation);
+
+/**
+ * Returns an arraylist of service names. The caller owns the arraylist and strings (char *)
+ */
+celix_status_t celix_dmComponent_getInterfaces(celix_dm_component_t *component, celix_array_list_t **servicesNames);
+
+/**
+ * Adds a C service dependency to the component
+ */
+celix_status_t celix_dmComponent_addServiceDependency(celix_dm_component_t *component, celix_dm_service_dependency_t *dep);
+
+/**
+ * Removes a C service dependency to the component
+ */
+celix_status_t celix_dmComponent_removeServiceDependency(celix_dm_component_t *component, celix_dm_service_dependency_t *dependency);
+
+/**
+ * Returns the current state of the component.
+ */
+celix_dm_component_state_t celix_dmComponent_currentState(celix_dm_component_t *cmp);
+
+/**
+ * Returns the implementation of the component. e.g. the component handle/self/this pointer.
+ */
+void * celix_dmComponent_getImplementation(celix_dm_component_t *cmp);
+
+/**
+ * Returns the DM component name. This is used when printing information about the component.
+ */
+const char* celix_dmComponent_getName(celix_dm_component_t *cmp);
+
+/**
+ * Returns bundle context for the bundle where this DM component is part of.
+ */
+celix_status_t celix_dmComponent_getBundleContext(celix_dm_component_t *component, celix_bundle_context_t **out);
+
+/**
+ * Set the component life cycle callbacks.
+ * The first argument will be the component implementation (@see component_getImplementation)
+ */
+celix_status_t celix_dmComponent_setCallbacks(celix_dm_component_t *component, celix_dm_cmp_lifecycle_fpt init, celix_dm_cmp_lifecycle_fpt start, celix_dm_cmp_lifecycle_fpt stop, celix_dm_cmp_lifecycle_fpt deinit);
+
+/**
+ * Set the component life cycle callbacks using a MACRO for improving the type safety.
+ */
+#define CELIX_DMCOMPONENT_SETCALLBACKS(dmCmp, type, init, start, stop, deinit) \
+    do {  \
+        int (*tmp_init)(type)   = (init); \
+        int (*tmp_start)(type)  = (start); \
+        int (*tmp_stop)(type)   = (stop); \
+        int (*tmp_deinit)(type) = (deinit); \
+        celix_dmComponent_setCallbacks((dmCmp), (celix_dm_cmp_lifecycle_fpt)tmp_init, (celix_dm_cmp_lifecycle_fpt)tmp_start, (celix_dm_cmp_lifecycle_fpt)tmp_stop, (celix_dm_cmp_lifecycle_fpt)tmp_deinit); \
+    } while(0)
+
+/**
+ * Create a DM Component info struct. Containing information about the component.
+ * Caller has ownership.
+ */
+celix_status_t celix_dmComponent_getComponentInfo(celix_dm_component_t *component, dm_component_info_pt *info);
+
+/**
+ * Destroys a DM Component info struct.
+ */
+void celix_dmComponent_destroyComponentInfo(dm_component_info_pt info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COMPONENT_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_dm_info.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_dm_info.h b/libs/framework/include/celix_dm_info.h
new file mode 100644
index 0000000..3010b9c
--- /dev/null
+++ b/libs/framework/include/celix_dm_info.h
@@ -0,0 +1,76 @@
+/**
+ *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 CELIX_DM_INFO_H_
+#define CELIX_DM_INFO_H_
+
+
+
+#include <stdbool.h>
+#include "celix_array_list.h"
+#include "celix_properties.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct celix_dm_interface_info_struct {
+    char* name;
+    celix_properties_t *properties;
+};
+typedef struct celix_dm_interface_info_struct *dm_interface_info_pt;  //deprecated
+typedef struct celix_dm_interface_info_struct dm_interface_info_t;  //deprecated
+typedef struct celix_dm_interface_info_struct celix_dm_interface_info_t;
+
+struct celix_dm_service_dependency_info_struct {
+    char *filter;
+    bool available;
+    bool required;
+    size_t count;
+};
+typedef struct celix_dm_service_dependency_info_struct *dm_service_dependency_info_pt;  //deprecated
+typedef struct celix_dm_service_dependency_info_struct dm_service_dependency_info_t;  //deprecated
+typedef struct celix_dm_service_dependency_info_struct celix_dm_service_dependency_info_t;
+
+struct celix_dm_component_info_struct {
+    char id[64];
+    char name[128];
+    bool active;
+    char * state;
+    celix_array_list_t *interfaces;   // type dm_interface_info_pt
+    celix_array_list_t *dependency_list;  // type dm_service_dependency_info_pt
+};
+typedef struct celix_dm_component_info_struct *dm_component_info_pt; //deprecated
+typedef struct celix_dm_component_info_struct dm_component_info_t; //deprecated
+typedef struct celix_dm_component_info_struct celix_dm_component_info_t;
+
+struct celix_dm_dependency_manager_info_struct {
+    long bndId;
+    celix_array_list_t *components;      // type dm_component_info
+};
+typedef struct celix_dm_dependency_manager_info_struct *dm_dependency_manager_info_pt; //deprecated
+typedef struct celix_dm_dependency_manager_info_struct dm_dependency_manager_info_t; //deprecated
+typedef struct celix_dm_dependency_manager_info_struct celix_dependency_manager_info_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //CELIX_DM_INFO_H_

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_dm_service_dependency.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_dm_service_dependency.h b/libs/framework/include/celix_dm_service_dependency.h
new file mode 100644
index 0000000..6908096
--- /dev/null
+++ b/libs/framework/include/celix_dm_service_dependency.h
@@ -0,0 +1,169 @@
+/**
+ *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 CELIX_DM_SERVICE_DEPENDENCY_H_
+#define CELIX_DM_SERVICE_DEPENDENCY_H_
+
+#include "celix_types.h"
+#include "celix_errno.h"
+#include "celix_threads.h"
+
+#include "celix_dm_info.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum celix_dm_service_dependency_strategy_enum {
+	DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING,
+	DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND
+} celix_dm_service_dependency_strategy_t;
+
+typedef int (*celix_dm_service_update_fp)(void *handle, void* service);
+typedef int (*celix_dm_service_swap_fp)(void *handle, void* oldService, void* newService);
+
+typedef int (*celix_dm_service_update_with_props_fp)(void *handle, void* service, const celix_properties_t *props);
+typedef int (*celix_dm_service_swap_with_props_fp)(void *handle, void* oldService, void* newService, const celix_properties_t *newProps);
+
+typedef struct celix_dm_service_dependency_callback_options {
+	celix_dm_service_update_fp set;
+	celix_dm_service_update_fp add;
+	celix_dm_service_update_fp remove;
+	celix_dm_service_swap_fp swap;
+
+	celix_dm_service_update_with_props_fp setWithProps;
+	celix_dm_service_update_with_props_fp addWithProps;
+	celix_dm_service_update_with_props_fp removeWithProps;
+	celix_dm_service_swap_with_props_fp swapWithProps;
+} celix_dm_service_dependency_callback_options_t;
+
+#define CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS { .set = NULL, \
+    .add = NULL, \
+    .remove = NULL, \
+    .swap = NULL, \
+    .setWithProps = NULL, \
+    .addWithProps = NULL, \
+    .removeWithProps = NULL, \
+    .swapWithProps = NULL }
+
+/**
+ * Create a service dependency.
+ * Caller has ownership.
+ */
+celix_dm_service_dependency_t* celix_dmServiceDependency_create(void);
+
+/**
+ * Destroys a service dependency.
+ * Caller has ownership.
+ */
+void celix_dmServiceDependency_destroy(celix_dm_service_dependency_t *dep);
+
+/**
+ * Specify if the service dependency is required. default is false
+ */
+celix_status_t celix_dmServiceDependency_setRequired(celix_dm_service_dependency_t *dependency, bool required);
+
+/**
+ * Specify if the servide dependency should add a C language filter for this dependency if no "service.lang" part if found the in the provided filter.
+ * Default is false
+ */
+celix_status_t celix_dmServiceDependency_setAddCLanguageFilter(celix_dm_service_dependency_t *dependency, bool addCLangFilter);
+
+
+/**
+ * Specify if the service dependency update strategy.
+ *
+ * The DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING strategy notifies the component in case the dependencies set
+ * changes (e.g. a dependency is added/removed): the component is responsible for protecting via locks
+ * the dependencies list and check (always under lock) if the service he's depending on is still available.
+ *
+ * The DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND (default when no strategy is explicitly set) reliefs the programmer
+ * from dealing with service dependencies' consistency issues: in case this strategy is adopted, the component
+ * is stopped and restarted (i.e. temporarily suspended) upon service dependencies' changes.
+ *
+ * Default strategy is DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND
+ */
+celix_status_t celix_dmServiceDependency_setStrategy(celix_dm_service_dependency_t *dependency, celix_dm_service_dependency_strategy_t strategy);
+
+/**
+ * Return the service dependency update strategy.
+ */
+celix_dm_service_dependency_strategy_t celix_dmServiceDependency_getStrategy(celix_dm_service_dependency_t *dependency);
+
+/**
+ * Set the service name, version range and filter.
+ *
+ * @param serviceName The service name. Must have a value.
+ * @param serviceVersionRange The service version range, can be a NULL pointer.
+ * @param filter The (additional) filter to use (e.g. "(location=front)"). Can be a NULL pointer.
+ */
+celix_status_t celix_dmServiceDependency_setService(celix_dm_service_dependency_t *dependency, const char* serviceName, const char* serviceVersionRange, const char* filter);
+
+/**
+ * Returns the service depenendy filter.
+ */
+const char* celix_dmServiceDependency_getFilter(celix_dm_service_dependency_t *dependency);
+
+/**
+ * Set the set callbacks when services specified by the service dependency
+ * The first argument of the callbacks will be the component implement (@see component_getImplementation)
+ * The second the argument a pointer to an instance of a service struct of the specified service dependency.
+ */
+celix_status_t celix_dmServiceDependency_setCallback(celix_dm_service_dependency_t *dependency, celix_dm_service_update_fp set);
+
+/**
+ * Set the set function callbacks when services specified by the service dependency
+ * The first argument of the callbacks will be the component implement (@see component_getImplementation)
+ * The second argument of th callbacks will be a pointer to an instance of a service struct of the specified service dependency.
+ * The third argument of th callbacks will be a pointer to a service properties of the a service instance of the specified service dependency.
+ */
+celix_status_t celix_dmServiceDependency_setCallbackWithProperties(celix_dm_service_dependency_t *dependency, celix_dm_service_update_with_props_fp set);
+
+/**
+ * Set the set, add, change, remove and swap function callbacks when services specified by the service dependency
+ * are (respectively) set, added, changed, removed or swapped.
+ *
+ * The version with the WithProps suffix will be called with as third argument the service properties.
+ */
+celix_status_t celix_dmServiceDependency_setCallbacksWithOptions(celix_dm_service_dependency_t *dependency, const celix_dm_service_dependency_callback_options_t *opts);
+
+/**
+ * Set the callback handle to be used in the callbacks. Note that this normally should not be set, because the
+ * result of component_getImplementation() is used
+ * This can be used in rare cases when the callbacks are actually interceptors. e.g. in the case of C++ support.
+ */
+celix_status_t celix_dmServiceDependency_setCallbackHandle(celix_dm_service_dependency_t *dependency, void* handle);
+
+/**
+ * Creates a service dependency info. The service dependency info struct contains information about the service dependency.
+ * The caller is the owner
+ */
+dm_service_dependency_info_t* celix_dmServiceDependency_createInfo(celix_dm_service_dependency_t* dep);
+
+/**
+ * Destroy a provided service dependency info struct.
+ */
+void celix_dmServiceDependency_destroyInfo(celix_dm_service_dependency_t *dep, dm_service_dependency_info_t *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CELIX_DM_SERVICE_DEPENDENCY_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_framework.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_framework.h b/libs/framework/include/celix_framework.h
index 39116f6..a4c784b 100644
--- a/libs/framework/include/celix_framework.h
+++ b/libs/framework/include/celix_framework.h
@@ -19,8 +19,6 @@
 #ifndef CELIX_FRAMEWORK_H_
 #define CELIX_FRAMEWORK_H_
 
-typedef struct framework celix_framework_t;
-
 
 #include "celix_types.h"
 #include "celix_properties.h"

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_framework_factory.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_framework_factory.h b/libs/framework/include/celix_framework_factory.h
index 70d2678..74e7c06 100644
--- a/libs/framework/include/celix_framework_factory.h
+++ b/libs/framework/include/celix_framework_factory.h
@@ -31,7 +31,7 @@ extern "C" {
  * @param config The framework configuration. Can be NULL.
  * @return a started framework or NULL
  */
-framework_t* frameworkFactory_newFramework(properties_t *config);
+celix_framework_t* frameworkFactory_newFramework(celix_properties_t *config);
 
 
 #ifdef __cplusplus

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_launcher.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_launcher.h b/libs/framework/include/celix_launcher.h
index 579eef7..19ab9f9 100644
--- a/libs/framework/include/celix_launcher.h
+++ b/libs/framework/include/celix_launcher.h
@@ -49,7 +49,7 @@ extern "C" {
  * @param embeddedConfig The optional embbeded config, will be overriden with the config.properties if found.
  * @return CELIX_SUCCESS if successful.
  */
-int celixLauncher_launchAndWaitForShutdown(int argc, char *argv[], properties_t *embeddedConfig);
+int celixLauncher_launchAndWaitForShutdown(int argc, char *argv[], celix_properties_t *embeddedConfig);
 
 
 /**
@@ -63,7 +63,7 @@ int celixLauncher_launchAndWaitForShutdown(int argc, char *argv[], properties_t
  * @param framework Output parameter for the framework.
  * @return CELIX_SUCCESS if successful. 
  */
-int celixLauncher_launch(const char *configFile, framework_t **framework);
+int celixLauncher_launch(const char *configFile, celix_framework_t **framework);
 
 /**
  * Launches the a celix framework and returns the framework.
@@ -76,7 +76,7 @@ int celixLauncher_launch(const char *configFile, framework_t **framework);
  * @param framework Output parameter for the framework.
  * @return CELIX_SUCCESS if successful.
  */
-int celixLauncher_launchWithStream(FILE *config, framework_t **framework);
+int celixLauncher_launchWithStream(FILE *config, celix_framework_t **framework);
 
 /**
  * Launches the a celix framework and returns the framework.
@@ -89,25 +89,25 @@ int celixLauncher_launchWithStream(FILE *config, framework_t **framework);
  * @param framework Output parameter for the framework.
  * @return CELIX_SUCCESS if successful.
  */
-int celixLauncher_launchWithProperties(properties_t *config, framework_t **framework);
+int celixLauncher_launchWithProperties(celix_properties_t *config, celix_framework_t **framework);
 
 /**
  * Wait (blocks) for the shutdown of the provided celix framework.
  * @param framework The framework to wait for.
  */
-void celixLauncher_waitForShutdown(framework_t *framework);
+void celixLauncher_waitForShutdown(celix_framework_t *framework);
 
 /**
  * Stop the provided celix framework.
  * @param framework The framework to stop.
  */
-void celixLauncher_stop(framework_t *framework);
+void celixLauncher_stop(celix_framework_t *framework);
 
 /**
  * Destroys the provided framework and if needed stops it first.
  * @param framework The framework to stop.
  */
-void celixLauncher_destroy(framework_t *framework);
+void celixLauncher_destroy(celix_framework_t *framework);
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/celix_types.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/celix_types.h b/libs/framework/include/celix_types.h
index 9f73a42..f59c8aa 100644
--- a/libs/framework/include/celix_types.h
+++ b/libs/framework/include/celix_types.h
@@ -25,30 +25,44 @@
  * These types are declared in a separate header for forward declaration
  */
 
-typedef struct bundle * bundle_pt;
-typedef struct bundle bundle_t;
-typedef struct bundle celix_bundle_t;
 
-typedef struct bundleArchive *bundle_archive_pt;
-typedef struct bundleArchive bundle_archive_t;
-
-typedef struct bundleRevision *bundle_revision_pt;
-typedef struct bundleRevision bundle_revision_t;
+#ifdef ADD_CELIX_DEPRECATED_WARNING
+#define CELIX_DEPRECATED_ATTR __attribute__ ((deprecated))
+#define CELIX_DEPRECATED_ATTR_MSG(msg) __attribute__ ((deprecated(msg)))
+#else
+#define CELIX_DEPRECATED_ATTR
+#define CELIX_DEPRECATED_ATTR_MSG(msg)
+#endif
 
-typedef struct bundleContext *bundle_context_pt;
-typedef struct bundleContext bundle_context_t;
-typedef struct bundleContext celix_bundle_context_t;
 
-typedef struct dm_dependency_manager *dm_dependency_manager_pt;
-typedef struct dm_dependency_manager dm_dependency_manager_t;
+typedef struct celix_framework celix_framework_t;
+typedef struct celix_bundle celix_bundle_t;
+typedef struct celix_bundle_context celix_bundle_context_t;
+typedef struct celix_dependency_manager celix_dependency_manager_t;
+typedef struct celix_dm_component_struct celix_dm_component_t;
+typedef struct celix_dm_service_dependency celix_dm_service_dependency_t;
 
-typedef struct dm_component_struct *dm_component_pt;
-typedef struct dm_component_struct dm_component_t;
+//deprecated
+typedef struct celix_dependency_manager dm_dependency_manager_t CELIX_DEPRECATED_ATTR;
+typedef struct celix_dependency_manager *dm_dependency_manager_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_dm_component_struct *dm_component_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_dm_component_struct dm_component_t CELIX_DEPRECATED_ATTR;
+typedef struct celix_dm_service_dependency *dm_service_dependency_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_dm_service_dependency dm_service_dependency_t CELIX_DEPRECATED_ATTR;
 
-typedef struct dm_service_dependency *dm_service_dependency_pt;
-typedef struct dm_service_dependency dm_service_dependency_t;
+typedef struct celix_bundle_context *bundle_context_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_bundle_context bundle_context_t CELIX_DEPRECATED_ATTR;
+typedef struct celix_framework *framework_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_framework framework_t CELIX_DEPRECATED_ATTR;
+typedef struct celix_bundle * bundle_pt CELIX_DEPRECATED_ATTR;
+typedef struct celix_bundle bundle_t CELIX_DEPRECATED_ATTR;
 
-typedef struct service_factory *service_factory_pt; //deprecated
+// will be deprecated in the future
+typedef struct bundleArchive *bundle_archive_pt;
+typedef struct bundleArchive bundle_archive_t;
+typedef struct bundleRevision *bundle_revision_pt;
+typedef struct bundleRevision bundle_revision_t;
+typedef struct service_factory *service_factory_pt;
 typedef struct serviceReference * service_reference_pt;
 
 #endif //CELIX_CELIX_TYPES_H

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/dm_activator.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/dm_activator.h b/libs/framework/include/dm_activator.h
index 1e06331..3b9d89a 100644
--- a/libs/framework/include/dm_activator.h
+++ b/libs/framework/include/dm_activator.h
@@ -29,10 +29,10 @@
 #ifndef DM_ACTIVATOR_BASE_H_
 #define DM_ACTIVATOR_BASE_H_
 
-
+#include "celix_types.h"
 #include "bundle_context.h"
 #include "celix_errno.h"
-#include "dm_dependency_manager.h"
+#include "celix_dependency_manager.h"
 #include "dm_component.h"
 #include "dm_service_dependency.h"
 #include "celix_bundle_activator.h"
@@ -41,6 +41,10 @@
 extern "C" {
 #endif
 
+#ifdef ADD_CELIX_DEPRECATED_WARNING
+#warning This header is deprecated, use the celix_bundle_activator instead. the Dependency manager can be retreived from the bundle context.
+#endif
+
 /**
  * Should be implemented by a bundle specific DM activator.
  * Should allocate and initialize a bundle specific activator struct.
@@ -52,13 +56,13 @@ celix_status_t dm_create(bundle_context_pt context, void ** userData);
  * Will be called after the dm_create function.
  * Can be used to specify with use of the provided dependency manager the bundle specific components.
  */
-celix_status_t dm_init(void * userData, bundle_context_pt context, dm_dependency_manager_pt manager);
+celix_status_t dm_init(void * userData, bundle_context_pt context, celix_dependency_manager_t *manager);
 
 /**
  * Should be implemented by a bundle specific DM activator.
  * Should deinitialize and deallocate the undle specific activator struct.
  */
-celix_status_t dm_destroy(void * userData, bundle_context_pt context, dm_dependency_manager_pt manager);
+celix_status_t dm_destroy(void * userData, bundle_context_pt context, celix_dependency_manager_t *manager);
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/dm_component.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/dm_component.h b/libs/framework/include/dm_component.h
index 0e5bd6b..88b9f37 100644
--- a/libs/framework/include/dm_component.h
+++ b/libs/framework/include/dm_component.h
@@ -33,44 +33,40 @@
 #include "celix_errno.h"
 #include "properties.h"
 #include "array_list.h"
-#include "dm_info.h"
+#include "celix_dm_info.h"
+#include "celix_dm_component.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef enum dm_component_state_enum {
-    DM_CMP_STATE_INACTIVE = 1,
-    DM_CMP_STATE_WAITING_FOR_REQUIRED = 2,
-    DM_CMP_STATE_INSTANTIATED_AND_WAITING_FOR_REQUIRED = 3,
-    DM_CMP_STATE_TRACKING_OPTIONAL = 4,
-} dm_component_state_t;
+typedef enum celix_dm_component_state_enum dm_component_state_t CELIX_DEPRECATED_ATTR; //deprecated
 
 #define DM_COMPONENT_MAX_ID_LENGTH 64
 #define DM_COMPONENT_MAX_NAME_LENGTH 128
 
-typedef int (*init_fpt)(void *userData);
-typedef int (*start_fpt)(void *userData);
-typedef int (*stop_fpt)(void *userData);
-typedef int (*deinit_fpt)(void *userData);
+typedef int (*init_fpt)(void *userData) CELIX_DEPRECATED_ATTR;
+typedef int (*start_fpt)(void *userData) CELIX_DEPRECATED_ATTR;
+typedef int (*stop_fpt)(void *userData) CELIX_DEPRECATED_ATTR;
+typedef int (*deinit_fpt)(void *userData) CELIX_DEPRECATED_ATTR;
 
 /**
  * Creates a DM Component
  * Caller has ownership.
  */
-celix_status_t component_create(bundle_context_t *context, const char* name, dm_component_t **component);
+celix_status_t component_create(celix_bundle_context_t *context, const char* name, celix_dm_component_t **component) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroys a DM Component
  */
-void component_destroy(dm_component_t *component);
+void component_destroy(celix_dm_component_t *component) CELIX_DEPRECATED_ATTR;
 
 
 /**
  * Specify if a default 'service.lang=C' should be added to the properties of interfaces if no 'service.lang' has been
  * provided. Default is false. Note that this should be set before using component_addInterface.
  */
-celix_status_t component_setCLanguageProperty(dm_component_t *component, bool setCLangProp);
+celix_status_t component_setCLanguageProperty(celix_dm_component_t *component, bool setCLangProp) CELIX_DEPRECATED_ATTR;
 
 
 /**
@@ -80,7 +76,7 @@ celix_status_t component_setCLanguageProperty(dm_component_t *component, bool se
  * @param version The version of the interface (e.g. "1.0.0"), Can be a NULL pointer.
  * @param properties To (meta) properties to provide with the service. Can be a NULL pointer.
  */
-celix_status_t component_addInterface(dm_component_t *component, const char* serviceName, const char* serviceVersion, const void* service, properties_t *properties);
+celix_status_t component_addInterface(celix_dm_component_t *component, const char* serviceName, const char* serviceVersion, const void* service, celix_properties_t *properties) CELIX_DEPRECATED_ATTR;
 
 /**
  * Removed  a C interface from a component the Celix framework.
@@ -88,52 +84,52 @@ celix_status_t component_addInterface(dm_component_t *component, const char* ser
  * @param serviceName the service name.
  * @return CELIX_SUCCESS when removed, CELIX_ILLEGAL_ARGUMENT when the component does not provide the interface
  */
-celix_status_t component_removeInterface(dm_component_pt component, const void* service);
+celix_status_t component_removeInterface(celix_dm_component_t *component, const void* service) CELIX_DEPRECATED_ATTR;
 /**
  * Sets the implementation of the component. e.g. the component handle/self/this pointer.
  */
-celix_status_t component_setImplementation(dm_component_t *component, void* implementation);
+celix_status_t component_setImplementation(celix_dm_component_t *component, void* implementation) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns an arraylist of service names. The caller owns the arraylist and strings (char *)
  */
-celix_status_t component_getInterfaces(dm_component_t *component, array_list_t **servicesNames);
+celix_status_t component_getInterfaces(celix_dm_component_t *component, celix_array_list_t **servicesNames) CELIX_DEPRECATED_ATTR;
 
 /**
  * Adds a C service dependency to the component
  */
-celix_status_t component_addServiceDependency(dm_component_t *component, dm_service_dependency_t *dep);
+celix_status_t component_addServiceDependency(celix_dm_component_t *component, celix_dm_service_dependency_t *dep) CELIX_DEPRECATED_ATTR;
 
 /**
  * Removes a C service dependency to the component
  */
-celix_status_t component_removeServiceDependency(dm_component_t *component, dm_service_dependency_t *dependency);
+celix_status_t component_removeServiceDependency(celix_dm_component_t *component, celix_dm_service_dependency_t *dependency) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns the current state of the component.
  */
-dm_component_state_t component_currentState(dm_component_t *cmp);
+celix_dm_component_state_t component_currentState(celix_dm_component_t *cmp) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns the implementation of the component. e.g. the component handle/self/this pointer.
  */
-void * component_getImplementation(dm_component_t *cmp);
+void * component_getImplementation(celix_dm_component_t *cmp) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns the DM component name. This is used when printing information about the component.
  */
-const char * component_getName(dm_component_t *cmp);
+const char * component_getName(celix_dm_component_t *cmp) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns bundle context for the bundle where this DM component is part of.
  */
-celix_status_t component_getBundleContext(dm_component_t *component, bundle_context_t **out);
+celix_status_t component_getBundleContext(celix_dm_component_t *component, celix_bundle_context_t **out) CELIX_DEPRECATED_ATTR;
 
 /**
  * Set the component life cycle callbacks.
  * The first argument will be the component implementation (@see component_getImplementation)
  */
-celix_status_t component_setCallbacks(dm_component_t *component, init_fpt init, start_fpt start, stop_fpt stop, deinit_fpt deinit);
+celix_status_t component_setCallbacks(celix_dm_component_t *component, celix_dm_cmp_lifecycle_fpt init, celix_dm_cmp_lifecycle_fpt start, celix_dm_cmp_lifecycle_fpt stop, celix_dm_cmp_lifecycle_fpt deinit) CELIX_DEPRECATED_ATTR;
 
 /**
  * Set the component life cycle callbacks using a MACRO for improving the type safety.
@@ -144,19 +140,19 @@ celix_status_t component_setCallbacks(dm_component_t *component, init_fpt init,
         int (*tmp_start)(type)  = (start); \
         int (*tmp_stop)(type)   = (stop); \
         int (*tmp_deinit)(type) = (deinit); \
-        component_setCallbacks((dmCmp), (init_fpt)tmp_init, (start_fpt)tmp_start, (stop_fpt)tmp_stop, (deinit_fpt)tmp_deinit); \
+        component_setCallbacks((dmCmp), (celix_dm_cmp_lifecycle_fpt)tmp_init, (celix_dm_cmp_lifecycle_fpt)tmp_start, (celix_dm_cmp_lifecycle_fpt)tmp_stop, (celix_dm_cmp_lifecycle_fpt)tmp_deinit); \
     } while(0)
 
 /**
  * Create a DM Component info struct. Containing information about the component.
  * Caller has ownership.
  */
-celix_status_t component_getComponentInfo(dm_component_t *component, dm_component_info_pt *info);
+celix_status_t component_getComponentInfo(celix_dm_component_t *component, dm_component_info_pt *info) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroys a DM Component info struct.
  */
-void component_destroyComponentInfo(dm_component_info_pt info);
+void component_destroyComponentInfo(dm_component_info_pt info) CELIX_DEPRECATED_ATTR;
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/dm_dependency_manager.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/dm_dependency_manager.h b/libs/framework/include/dm_dependency_manager.h
index 1fce27f..034a6bf 100644
--- a/libs/framework/include/dm_dependency_manager.h
+++ b/libs/framework/include/dm_dependency_manager.h
@@ -31,50 +31,48 @@
 
 #include "celix_errno.h"
 #include "array_list.h"
-#include "dm_info.h"
+#include "celix_dm_info.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 /**
  * Creates a dependency manager.
  * Caller has ownership.
  */
- //TODO make this private, dep man should always be retrieved from the bundle context
-celix_status_t dependencyManager_create(bundle_context_t *context, dm_dependency_manager_t **manager);
+celix_status_t dependencyManager_create(celix_bundle_context_t *context, celix_dependency_manager_t **manager) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroys the provided dependency manager
  */
-void dependencyManager_destroy(dm_dependency_manager_t *manager);
+void dependencyManager_destroy(celix_dependency_manager_t *manager) CELIX_DEPRECATED_ATTR;
 
 /**
  * Adds a DM component to the dependency manager
  */
-celix_status_t dependencyManager_add(dm_dependency_manager_t *manager, dm_component_t *component);
+celix_status_t dependencyManager_add(celix_dependency_manager_t *manager, celix_dm_component_t *component)CELIX_DEPRECATED_ATTR;
 
 /**
  * Removes a DM component from the dependency manager and destroys it
  */
-celix_status_t dependencyManager_remove(dm_dependency_manager_t *manager, dm_component_t *component);
+celix_status_t dependencyManager_remove(celix_dependency_manager_t *manager, celix_dm_component_t *component) CELIX_DEPRECATED_ATTR;
 
 /**
  * Removes all DM components from the dependency manager
  */
-celix_status_t dependencyManager_removeAllComponents(dm_dependency_manager_t *manager);
+celix_status_t dependencyManager_removeAllComponents(celix_dependency_manager_t *manager) CELIX_DEPRECATED_ATTR;
 
 /**
  * Create and returns a DM Info struct. Which contains information about the state of the DM components
  * Caller has ownership.
  */
-celix_status_t dependencyManager_getInfo(dm_dependency_manager_t *manager, dm_dependency_manager_info_t **info);
+celix_status_t dependencyManager_getInfo(celix_dependency_manager_t *manager, dm_dependency_manager_info_pt *info) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroys a DM info struct.
  */
-void dependencyManager_destroyInfo(dm_dependency_manager_t *manager, dm_dependency_manager_info_t *info);
+void dependencyManager_destroyInfo(celix_dependency_manager_t *manager, dm_dependency_manager_info_pt info) CELIX_DEPRECATED_ATTR;
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/dm_info.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/dm_info.h b/libs/framework/include/dm_info.h
deleted file mode 100644
index 8074ab6..0000000
--- a/libs/framework/include/dm_info.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.
- */
-/*
- * dm_server.h
- *
- *  \date       15 Oct 2015
- *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright  Apache License, Version 2.0
- */
-#ifndef CELIX_DM_INFO_SERVICE_H
-#define CELIX_DM_INFO_SERVICE_H
-
-
-
-#include <stdbool.h>
-#include "array_list.h"
-#include "properties.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define DM_INFO_SERVICE_NAME "dm_info"
-
-
-typedef struct dm_interface_info_struct {
-    char* name;
-    properties_pt properties;
-} dm_interface_info_t;
-typedef struct dm_interface_info_struct *dm_interface_info_pt;
-
-typedef struct dm_service_dependency_info_struct {
-    char *filter;
-    bool available;
-    bool required;
-    size_t count;
-} dm_service_dependency_info_t;
-typedef struct dm_service_dependency_info_struct *dm_service_dependency_info_pt;
-
-typedef struct dm_component_info_struct {
-    char id[64];
-    char name[128];
-    bool active;
-    char * state;
-    array_list_pt interfaces;   // type dm_interface_info_pt
-    array_list_pt dependency_list;  // type dm_service_dependency_info_pt
-} dm_component_info_t;
-typedef struct dm_component_info_struct *dm_component_info_pt;
-
-typedef struct dm_dependency_manager_info_struct {
-    array_list_pt  components;      // type dm_component_info
-} dm_dependency_manager_info_t;
-typedef struct dm_dependency_manager_info_struct *dm_dependency_manager_info_pt;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif //CELIX_DM_INFO_SERVICE_H

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/dm_service_dependency.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/dm_service_dependency.h b/libs/framework/include/dm_service_dependency.h
index 9ed78e3..0ff549e 100644
--- a/libs/framework/include/dm_service_dependency.h
+++ b/libs/framework/include/dm_service_dependency.h
@@ -32,17 +32,15 @@
 #include "celix_threads.h"
 #include "service_reference.h"
 
-#include "dm_info.h"
+#include "celix_dm_info.h"
+#include "celix_dm_service_dependency.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
-typedef enum dm_service_dependency_strategy_enum {
-	DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING,
-	DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND
-} dm_service_dependency_strategy_t;
+typedef enum celix_dm_service_dependency_strategy_enum dm_service_dependency_strategy_t CELIX_DEPRECATED_ATTR;
 
 typedef int (*service_set_fpt)(void *handle, const void* service);
 typedef int (*service_add_fpt)(void *handle, const void* service);
@@ -60,24 +58,24 @@ typedef celix_status_t (*service_swap_with_ref_fpt)(void *handle, service_refere
  * Create a service dependency.
  * Caller has ownership.
  */
-celix_status_t serviceDependency_create(dm_service_dependency_t **dep);
+celix_status_t serviceDependency_create(celix_dm_service_dependency_t **dep) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroys a service dependency.
  * Caller has ownership.
  */
-celix_status_t serviceDependency_destroy(dm_service_dependency_t **dep);
+celix_status_t serviceDependency_destroy(celix_dm_service_dependency_t **dep) CELIX_DEPRECATED_ATTR;
 
 /**
  * Specify if the service dependency is required. default is false
  */
-celix_status_t serviceDependency_setRequired(dm_service_dependency_t *dependency, bool required);
+celix_status_t serviceDependency_setRequired(celix_dm_service_dependency_t *dependency, bool required) CELIX_DEPRECATED_ATTR;
 
 /**
  * Specify if the servide dependency should add a C language filter for this dependency if no "service.lang" part if found the in the provided filter.
  * Default is false
  */
-celix_status_t serviceDependency_setAddCLanguageFilter(dm_service_dependency_t *dependency, bool addCLangFilter);
+celix_status_t serviceDependency_setAddCLanguageFilter(celix_dm_service_dependency_t *dependency, bool addCLangFilter) CELIX_DEPRECATED_ATTR;
 
 
 /**
@@ -93,12 +91,12 @@ celix_status_t serviceDependency_setAddCLanguageFilter(dm_service_dependency_t *
  *
  * Default strategy is DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND
  */
-celix_status_t serviceDependency_setStrategy(dm_service_dependency_t *dependency,dm_service_dependency_strategy_t strategy);
+celix_status_t serviceDependency_setStrategy(celix_dm_service_dependency_t *dependency, celix_dm_service_dependency_strategy_t strategy) CELIX_DEPRECATED_ATTR;
 
 /**
  * Return the service dependency update strategy.
  */
-celix_status_t serviceDependency_getStrategy(dm_service_dependency_t *dependency,dm_service_dependency_strategy_t* strategy);
+celix_status_t serviceDependency_getStrategy(celix_dm_service_dependency_t *dependency, celix_dm_service_dependency_strategy_t* strategy) CELIX_DEPRECATED_ATTR;
 
 /**
  * Set the service name, version range and filter.
@@ -107,12 +105,12 @@ celix_status_t serviceDependency_getStrategy(dm_service_dependency_t *dependency
  * @param serviceVersionRange The service version range, can be a NULL pointer.
  * @param filter The (additional) filter to use (e.g. "(location=front)"). Can be a NULL pointer.
  */
-celix_status_t serviceDependency_setService(dm_service_dependency_t *dependency, const char* serviceName, const char* serviceVersionRange, const char* filter);
+celix_status_t serviceDependency_setService(celix_dm_service_dependency_t *dependency, const char* serviceName, const char* serviceVersionRange, const char* filter) CELIX_DEPRECATED_ATTR;
 
 /**
  * Returns the service depenendy filter.
  */
-celix_status_t serviceDependency_getFilter(dm_service_dependency_t *dependency, const char** filter);
+celix_status_t serviceDependency_getFilter(celix_dm_service_dependency_t *dependency, const char** filter) CELIX_DEPRECATED_ATTR;
 
 /**
  * Set the set, add, change, remove and swap function callbacks when services specified by the service dependency
@@ -120,7 +118,7 @@ celix_status_t serviceDependency_getFilter(dm_service_dependency_t *dependency,
  * The first argument of the callbacks will be the component implement (@see component_getImplementation)
  * The second the argument a pointer to an instance of a service struct of the specified service dependency.
  */
-celix_status_t serviceDependency_setCallbacks(dm_service_dependency_t *dependency, service_set_fpt set, service_add_fpt add, service_change_fpt change, service_remove_fpt remove, service_swap_fpt swap);
+celix_status_t serviceDependency_setCallbacks(celix_dm_service_dependency_t *dependency, service_set_fpt set, service_add_fpt add, service_change_fpt change, service_remove_fpt remove, service_swap_fpt swap) CELIX_DEPRECATED_ATTR;
 
 /**
  * Set the set, add, change, remove and swap function callbacks when services specified by the service dependency
@@ -129,13 +127,13 @@ celix_status_t serviceDependency_setCallbacks(dm_service_dependency_t *dependenc
  * The second argument of th callbacks will be a pointer to an instance of a service struct of the specified service dependency.
  * The third argument of th callbacks will be a pointer to a service reference of the a service instance of the specified service dependency.
  */
-celix_status_t serviceDependency_setCallbacksWithServiceReference(dm_service_dependency_t *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 serviceDependency_setCallbacksWithServiceReference(celix_dm_service_dependency_t *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_DEPRECATED_ATTR;
 
 /**
  * Specifies which field member (pointer to) to update when a service dependencies is set.
  * If provided the provided service_lock will be used for locking when updating the service instance.
  */
-celix_status_t serviceDependency_setAutoConfigure(dm_service_dependency_t *dependency, celix_thread_mutex_t *service_lock, const void** field);
+celix_status_t serviceDependency_setAutoConfigure(celix_dm_service_dependency_t *dependency, celix_thread_mutex_t *service_lock, const void** field) CELIX_DEPRECATED_ATTR;
 
 #define serviceDependency_setCallbacksSafe(dep, cmpType, servType, set, add, change, remove, swap) \
 	do { \
@@ -152,18 +150,18 @@ celix_status_t serviceDependency_setAutoConfigure(dm_service_dependency_t *depen
  * result of component_getImplementation() is used
  * This can be used in rare cases when the callbacks are actually interceptors. e.g. in the case of C++ support.
  */
-celix_status_t serviceDependency_setCallbackHandle(dm_service_dependency_t *dependency, void* handle);
+celix_status_t serviceDependency_setCallbackHandle(celix_dm_service_dependency_t *dependency, void* handle) CELIX_DEPRECATED_ATTR;
 
 /**
  * Creates a service dependency info. The service dependency info struct contains information about the service dependency.
  * The caller is the owner
  */
-celix_status_t serviceDependency_getServiceDependencyInfo(dm_service_dependency_t* dep, dm_service_dependency_info_t **info);
+celix_status_t serviceDependency_getServiceDependencyInfo(celix_dm_service_dependency_t* dep, dm_service_dependency_info_t **info) CELIX_DEPRECATED_ATTR;
 
 /**
  * Destroy a provided service dependency info struct.
  */
-void dependency_destroyDependencyInfo(dm_service_dependency_info_t *info);
+void dependency_destroyDependencyInfo(dm_service_dependency_info_t *info) CELIX_DEPRECATED_ATTR;
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/framework.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/framework.h b/libs/framework/include/framework.h
index f02b784..6864da5 100644
--- a/libs/framework/include/framework.h
+++ b/libs/framework/include/framework.h
@@ -27,9 +27,6 @@
 #ifndef FRAMEWORK_H_
 #define FRAMEWORK_H_
 
-typedef struct framework *framework_pt;
-typedef struct framework framework_t;
-
 #include "celix_errno.h"
 #include "framework_exports.h"
 #include "bundle.h"
@@ -41,19 +38,19 @@ extern "C" {
 #endif
 
 // #TODO: Move to FrameworkFactory according the OSGi Spec
-FRAMEWORK_EXPORT celix_status_t framework_create(framework_t **framework, properties_t *config);
+FRAMEWORK_EXPORT celix_status_t framework_create(celix_framework_t **framework, celix_properties_t *config);
 
-FRAMEWORK_EXPORT celix_status_t framework_start(framework_t *framework);
+FRAMEWORK_EXPORT celix_status_t framework_start(celix_framework_t *framework);
 
-FRAMEWORK_EXPORT celix_status_t framework_stop(framework_t *framework);
+FRAMEWORK_EXPORT celix_status_t framework_stop(celix_framework_t *framework);
 
-FRAMEWORK_EXPORT celix_status_t framework_destroy(framework_t *framework);
+FRAMEWORK_EXPORT celix_status_t framework_destroy(celix_framework_t *framework);
 
-FRAMEWORK_EXPORT celix_status_t framework_waitForStop(framework_t *framework);
+FRAMEWORK_EXPORT celix_status_t framework_waitForStop(celix_framework_t *framework);
 
-FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(framework_t *framework, bundle_t **bundle);
+FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(celix_framework_t *framework, celix_bundle_t **bundle);
 
-bundle_context_t* framework_getContext(framework_t *framework);
+celix_bundle_context_t* framework_getContext(celix_framework_t *framework);
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/listener_hook_service.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/listener_hook_service.h b/libs/framework/include/listener_hook_service.h
index d80c09e..ce1befe 100644
--- a/libs/framework/include/listener_hook_service.h
+++ b/libs/framework/include/listener_hook_service.h
@@ -39,7 +39,7 @@ extern "C" {
 #endif
 
 struct listener_hook_info {
-	bundle_context_pt context;
+	celix_bundle_context_t *context;
 	const char *filter;
 	bool removed;
 };
@@ -47,9 +47,9 @@ struct listener_hook_info {
 struct listener_hook_service {
 	void *handle;
 
-	celix_status_t (*added)(void *hook, array_list_pt listeners);
+	celix_status_t (*added)(void *hook, celix_array_list_t *listeners);
 
-	celix_status_t (*removed)(void *hook, array_list_pt listeners);
+	celix_status_t (*removed)(void *hook, celix_array_list_t *listeners);
 };
 
 #ifdef __cplusplus

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/manifest.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/manifest.h b/libs/framework/include/manifest.h
index eeccfbc..a6b5d59 100644
--- a/libs/framework/include/manifest.h
+++ b/libs/framework/include/manifest.h
@@ -36,7 +36,7 @@ extern "C" {
 #endif
 
 struct manifest {
-	properties_pt mainAttributes;
+	celix_properties_t *mainAttributes;
 	hash_map_pt attributes;
 };
 
@@ -50,7 +50,7 @@ FRAMEWORK_EXPORT celix_status_t manifest_destroy(manifest_pt manifest);
 
 FRAMEWORK_EXPORT void manifest_clear(manifest_pt manifest);
 
-FRAMEWORK_EXPORT properties_pt manifest_getMainAttributes(manifest_pt manifest);
+FRAMEWORK_EXPORT celix_properties_t *manifest_getMainAttributes(manifest_pt manifest);
 
 FRAMEWORK_EXPORT celix_status_t manifest_getEntries(manifest_pt manifest, hash_map_pt *map);
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/module.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/module.h b/libs/framework/include/module.h
index 463fd86..446547a 100644
--- a/libs/framework/include/module.h
+++ b/libs/framework/include/module.h
@@ -41,9 +41,9 @@ typedef struct module *module_pt;
 extern "C" {
 #endif
 
-module_pt module_create(manifest_pt headerMap, const char *moduleId, bundle_pt bundle);
+module_pt module_create(manifest_pt headerMap, const char *moduleId, celix_bundle_t *bundle);
 
-module_pt module_createFrameworkModule(bundle_pt bundle);
+module_pt module_createFrameworkModule(celix_bundle_t *bundle);
 
 void module_destroy(module_pt module);
 
@@ -67,25 +67,25 @@ FRAMEWORK_EXPORT bool module_isResolved(module_pt module);
 
 FRAMEWORK_EXPORT void module_setResolved(module_pt module);
 
-FRAMEWORK_EXPORT bundle_pt module_getBundle(module_pt module);
+FRAMEWORK_EXPORT celix_bundle_t *module_getBundle(module_pt module);
 
 FRAMEWORK_EXPORT linked_list_pt module_getRequirements(module_pt module);
 
 FRAMEWORK_EXPORT linked_list_pt module_getCapabilities(module_pt module);
 
-FRAMEWORK_EXPORT array_list_pt module_getDependentImporters(module_pt module);
+FRAMEWORK_EXPORT celix_array_list_t *module_getDependentImporters(module_pt module);
 
 FRAMEWORK_EXPORT void module_addDependentImporter(module_pt module, module_pt importer);
 
 FRAMEWORK_EXPORT void module_removeDependentImporter(module_pt module, module_pt importer);
 
-FRAMEWORK_EXPORT array_list_pt module_getDependentRequirers(module_pt module);
+FRAMEWORK_EXPORT celix_array_list_t *module_getDependentRequirers(module_pt module);
 
 FRAMEWORK_EXPORT void module_addDependentRequirer(module_pt module, module_pt requirer);
 
 FRAMEWORK_EXPORT void module_removeDependentRequirer(module_pt module, module_pt requirer);
 
-FRAMEWORK_EXPORT array_list_pt module_getDependents(module_pt module);
+FRAMEWORK_EXPORT celix_array_list_t *module_getDependents(module_pt module);
 
 FRAMEWORK_EXPORT celix_status_t module_getGroup(module_pt module, const char **group);
 

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/service_reference.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/service_reference.h b/libs/framework/include/service_reference.h
index e094b4c..8c32106 100644
--- a/libs/framework/include/service_reference.h
+++ b/libs/framework/include/service_reference.h
@@ -31,10 +31,10 @@
 extern "C" {
 #endif
 
-FRAMEWORK_EXPORT celix_status_t serviceReference_getBundle(service_reference_pt reference, bundle_pt *bundle);
+FRAMEWORK_EXPORT celix_status_t serviceReference_getBundle(service_reference_pt reference, celix_bundle_t **bundle);
 
 FRAMEWORK_EXPORT bool
-serviceReference_isAssignableTo(service_reference_pt reference, bundle_pt requester, const char *serviceName);
+serviceReference_isAssignableTo(service_reference_pt reference, celix_bundle_t *requester, const char *serviceName);
 
 FRAMEWORK_EXPORT celix_status_t
 serviceReference_getProperty(service_reference_pt reference, const char *key, const char **value);
@@ -58,7 +58,7 @@ FRAMEWORK_EXPORT int serviceReference_equals2(const void *reference1, const void
 FRAMEWORK_EXPORT celix_status_t
 serviceReference_compareTo(service_reference_pt reference, service_reference_pt compareTo, int *compare);
 
-FRAMEWORK_EXPORT celix_status_t serviceReference_getUsingBundles(service_reference_pt ref, array_list_pt *out);
+FRAMEWORK_EXPORT celix_status_t serviceReference_getUsingBundles(service_reference_pt ref, celix_array_list_t **out);
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/2492416e/libs/framework/include/service_registration.h
----------------------------------------------------------------------
diff --git a/libs/framework/include/service_registration.h b/libs/framework/include/service_registration.h
index 8e661ec..ea44155 100644
--- a/libs/framework/include/service_registration.h
+++ b/libs/framework/include/service_registration.h
@@ -38,10 +38,10 @@ extern "C" {
 FRAMEWORK_EXPORT celix_status_t serviceRegistration_unregister(service_registration_t *registration);
 
 FRAMEWORK_EXPORT celix_status_t
-serviceRegistration_getProperties(service_registration_t *registration, properties_pt *properties);
+serviceRegistration_getProperties(service_registration_t *registration, celix_properties_t **properties);
 
 FRAMEWORK_EXPORT celix_status_t
-serviceRegistration_setProperties(service_registration_t *registration, properties_pt properties);
+serviceRegistration_setProperties(service_registration_t *registration, celix_properties_t *properties);
 
 FRAMEWORK_EXPORT celix_status_t
 serviceRegistration_getServiceName(service_registration_t *registration, const char **serviceName);


Mime
View raw message