celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [1/2] celix git commit: CELIX-426: Initial commit for the C++ api
Date Sun, 06 May 2018 18:45:20 GMT
Repository: celix
Updated Branches:
  refs/heads/feature/CELIX-426-cxx-api [created] 764bd7f7a


http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/celix/impl/FrameworkImpl.h
----------------------------------------------------------------------
diff --git a/framework/include/celix/impl/FrameworkImpl.h b/framework/include/celix/impl/FrameworkImpl.h
new file mode 100644
index 0000000..4a68307
--- /dev/null
+++ b/framework/include/celix/impl/FrameworkImpl.h
@@ -0,0 +1,113 @@
+/**
+ *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_IMPL_FRAMEWORKIMPL_H
+#define CELIX_IMPL_FRAMEWORKIMPL_H
+
+#include "celix_framework_factory.h"
+#include "framework.h"
+
+#include "celix/impl/BundleImpl.h"
+
+namespace celix {
+
+    namespace impl {
+
+        class FrameworkImpl :public celix::Framework {
+        public:
+            FrameworkImpl(framework_t *c_fw) : owner{false} {
+                //wrapper framework
+                this->c_fwm = c_fw;
+                //assume started framework
+                this->setFrameworkContext();
+            }
+
+            FrameworkImpl(celix::Properties config) : owner{true} {
+                //framework which also owns the underlining c framework
+                auto c_config = properties_create();
+                for (auto &pair : config) {
+                    properties_set(c_config, pair.first.c_str(), pair.second.c_str());
+                }
+                this->c_fwm = frameworkFactory_newFramework(c_config); //should be started
+
+                this->setFrameworkContext();
+            };
+
+            virtual ~FrameworkImpl() {
+                if (this->owner && this->c_fwm != nullptr) {
+                    framework_stop(this->c_fwm);
+                    framework_waitForStop(this->c_fwm);
+                    framework_destroy(this->c_fwm);
+                }
+            }
+
+            virtual void start() noexcept override {
+                framework_start(this->c_fwm);
+            }
+
+            virtual void stop() noexcept override {
+                framework_stop(this->c_fwm);
+            }
+
+            virtual void waitForStop() noexcept override {
+                framework_waitForStop(this->c_fwm);
+            }
+            //TODO also in c virtual void breakWaitForStops() noexcept = 0;
+
+            virtual std::string getUUID() const noexcept override {
+                return std::string{framework_getUUID(this->c_fwm)};
+            }
+
+            celix::BundleContext& getFrameworkContext() noexcept override {
+                BundleContext &ctx = this->bundleContextsCache.at(0);
+                return ctx;
+            }
+
+            celix::Bundle& getFrameworkBundle() noexcept override {
+                if (this->fwBundle.size() == 0) {
+                    bundle_t* c_bnd = nullptr;
+                    framework_getFrameworkBundle(this->c_fwm, &c_bnd);
+                    this->fwBundle.emplace_back(celix::impl::BundleImpl{c_bnd});
+
+                }
+                return this->fwBundle[0];
+            }
+
+        private:
+
+            void setFrameworkContext() {
+                //create and set framework bundle context (replace invalid bundle context)
+                bundle_t *fwmBundle = nullptr;
+                bundle_context_t *fwmCtx = nullptr;
+                framework_getFrameworkBundle(this->c_fwm, &fwmBundle);
+                bundle_getContext(fwmBundle, &fwmCtx);
+                this->bundleContextsCache.emplace(0, fwmCtx);
+            }
+
+
+            bool owner;
+            framework_t *c_fwm{nullptr};
+            std::map<long,celix::impl::BundleContextImpl> bundleContextsCache{};
+            std::vector<celix::impl::BundleImpl> fwBundle{}; //optional entry
+
+        };
+    }
+}
+
+#endif //CELIX_IMPL_FRAMEWORKIMPL_H

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/celix_api.h
----------------------------------------------------------------------
diff --git a/framework/include/celix_api.h b/framework/include/celix_api.h
index b770876..12c87e0 100644
--- a/framework/include/celix_api.h
+++ b/framework/include/celix_api.h
@@ -21,7 +21,9 @@
 #define CELIX_CELIX_API_H_
 
 #include "celix_utils_api.h"
-#include "bundle.h"
+
+#include "celix_constants.h"
+#include "celix_bundle.h"
 #include "bundle_context.h"
 #include "service_registration.h"
 #include "service_factory.h"

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/celix_bundle.h
----------------------------------------------------------------------
diff --git a/framework/include/celix_bundle.h b/framework/include/celix_bundle.h
new file mode 100644
index 0000000..6013635
--- /dev/null
+++ b/framework/include/celix_bundle.h
@@ -0,0 +1,153 @@
+/**
+ *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_BUNDLE_H_
+#define CELIX_BUNDLE_H_
+
+#include "celix_types.h"
+
+#include "celix_errno.h"
+#include "bundle_state.h"
+#include "bundle_archive.h"
+#include "framework.h"
+#include "wire.h"
+#include "module.h"
+#include "service_reference.h"
+#include "bundle_context.h"
+#include "celix_log.h"
+#include "celix_threads.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+FRAMEWORK_EXPORT celix_status_t bundle_create(bundle_pt *bundle);
+
+FRAMEWORK_EXPORT celix_status_t
+bundle_createFromArchive(bundle_pt *bundle, framework_pt framework, bundle_archive_pt archive);
+
+FRAMEWORK_EXPORT celix_status_t bundle_destroy(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_isSystemBundle(bundle_pt bundle, bool *systemBundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getArchive(bundle_pt bundle, bundle_archive_pt *archive);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getCurrentModule(bundle_pt bundle, module_pt *module);
+
+FRAMEWORK_EXPORT array_list_pt bundle_getModules(bundle_pt bundle);
+
+FRAMEWORK_EXPORT void *bundle_getHandle(bundle_pt bundle);
+
+FRAMEWORK_EXPORT void bundle_setHandle(bundle_pt bundle, void *handle);
+
+FRAMEWORK_EXPORT activator_pt bundle_getActivator(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setActivator(bundle_pt bundle, activator_pt activator);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getContext(bundle_pt bundle, bundle_context_pt *context);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setContext(bundle_pt bundle, bundle_context_pt context);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getEntry(bundle_pt bundle, const char *name, char **entry);
+
+FRAMEWORK_EXPORT celix_status_t bundle_start(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_startWithOptions(bundle_pt bundle, int options);
+
+FRAMEWORK_EXPORT celix_status_t bundle_update(bundle_pt bundle, const char *inputFile);
+
+FRAMEWORK_EXPORT celix_status_t bundle_stop(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_stopWithOptions(bundle_pt bundle, int options);
+
+FRAMEWORK_EXPORT celix_status_t bundle_uninstall(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setState(bundle_pt bundle, bundle_state_e state);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateInactive(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setPersistentStateUninstalled(bundle_pt bundle);
+
+FRAMEWORK_EXPORT void uninstallBundle(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_revise(bundle_pt bundle, const char *location, const char *inputFile);
+
+FRAMEWORK_EXPORT celix_status_t bundle_addModule(bundle_pt bundle, module_pt module);
+
+FRAMEWORK_EXPORT celix_status_t bundle_closeModules(bundle_pt bundle);
+
+// Service Reference Functions
+FRAMEWORK_EXPORT array_list_pt getUsingBundles(service_reference_pt reference);
+
+FRAMEWORK_EXPORT int compareTo(service_reference_pt a, service_reference_pt b);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state);
+
+FRAMEWORK_EXPORT celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getLockingThread(bundle_pt bundle, celix_thread_t *thread);
+
+FRAMEWORK_EXPORT celix_status_t bundle_lock(bundle_pt bundle, bool *locked);
+
+FRAMEWORK_EXPORT celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked);
+
+FRAMEWORK_EXPORT celix_status_t bundle_closeAndDelete(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_close(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_refresh(bundle_pt bundle);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getBundleId(bundle_pt bundle, long *id);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getRegisteredServices(bundle_pt bundle, array_list_pt *list);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list);
+
+FRAMEWORK_EXPORT celix_status_t bundle_setFramework(bundle_pt bundle, framework_pt framework);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getFramework(bundle_pt bundle, framework_pt *framework);
+
+FRAMEWORK_EXPORT celix_status_t bundle_getBundleLocation(bundle_pt bundle, const char **location);
+
+
+
+/**********************************************************************************************************************
+ **********************************************************************************************************************
+ * Updated API
+ **********************************************************************************************************************
+ **********************************************************************************************************************/
+
+long celix_bundle_getId(const bundle_t *bnd);
+
+celix_bundle_state_e celix_bundle_getState(const bundle_t *bnd);
+
+/**
+ * Note returned string pointer is owned by the caller.
+ * @param bnd
+ * @param relPath
+ * @return
+ */
+char* celix_bundle_getEntry(const bundle_t *bnd, const char *relPath);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CELIX_BUNDLE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/celix_constants.h
----------------------------------------------------------------------
diff --git a/framework/include/celix_constants.h b/framework/include/celix_constants.h
new file mode 100644
index 0000000..d46c8fb
--- /dev/null
+++ b/framework/include/celix_constants.h
@@ -0,0 +1,79 @@
+/**
+ *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.
+ */
+/*
+ * constants.h
+ *
+ *  \date       Apr 29, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef CELIX_CONSTANTS_H_
+#define CELIX_CONSTANTS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OSGI_FRAMEWORK_OBJECTCLASS "objectClass"
+#define OSGI_FRAMEWORK_SERVICE_NAME "objectClass" //TODO rename in future?
+#define OSGI_FRAMEWORK_SERVICE_ID "service.id"
+#define OSGI_FRAMEWORK_SERVICE_PID "service.pid"
+#define OSGI_FRAMEWORK_SERVICE_RANKING "service.ranking"
+
+#define CELIX_FRAMEWORK_SERVICE_VERSION "service.version"
+#define CELIX_FRAMEWORK_SERVICE_LANGUAGE "service.lang"
+#define CELIX_FRAMEWORK_SERVICE_C_LANGUAGE "C"
+#define CELIX_FRAMEWORK_SERVICE_CXX_LANGUAGE "C++"
+#define CELIX_FRAMEWORK_SERVICE_SHARED_LANGUAGE "shared" //e.g. marker services
+
+#define OSGI_FRAMEWORK_BUNDLE_ACTIVATOR "Bundle-Activator"
+#define OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_CREATE "bundleActivator_create"
+#define OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_START "bundleActivator_start"
+#define OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_STOP "bundleActivator_stop"
+#define OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_DESTROY "bundleActivator_destroy"
+
+#define OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_CREATE "dm_create"
+#define OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_INIT "dm_init"
+#define OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_DESTROY "dm_destroy"
+
+#define OSGI_FRAMEWORK_BUNDLE_SYMBOLICNAME "Bundle-SymbolicName"
+#define OSGI_FRAMEWORK_BUNDLE_VERSION "Bundle-Version"
+#define OSGI_FRAMEWORK_PRIVATE_LIBRARY "Private-Library"
+#define OSGI_FRAMEWORK_EXPORT_LIBRARY "Export-Library"
+#define OSGI_FRAMEWORK_IMPORT_LIBRARY "Import-Library"
+    
+#define OSGI_FRAMEWORK_FRAMEWORK_STORAGE "org.osgi.framework.storage"
+#define OSGI_FRAMEWORK_FRAMEWORK_STORAGE_CLEAN "org.osgi.framework.storage.clean"
+#define OSGI_FRAMEWORK_FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT "onFirstInit"
+#define OSGI_FRAMEWORK_FRAMEWORK_UUID "org.osgi.framework.uuid"
+
+#define CELIX_AUTO_START_0 "CELIX_AUTO_START_0"
+#define CELIX_AUTO_START_1 "CELIX_AUTO_START_1"
+#define CELIX_AUTO_START_2 "CELIX_AUTO_START_2"
+#define CELIX_AUTO_START_3 "CELIX_AUTO_START_3"
+#define CELIX_AUTO_START_4 "CELIX_AUTO_START_4"
+#define CELIX_AUTO_START_5 "CELIX_AUTO_START_5"
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONSTANTS_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/celix_launcher.h
----------------------------------------------------------------------
diff --git a/framework/include/celix_launcher.h b/framework/include/celix_launcher.h
index 579eef7..8675c73 100644
--- a/framework/include/celix_launcher.h
+++ b/framework/include/celix_launcher.h
@@ -24,8 +24,8 @@
  *  \copyright	Apache License, Version 2.0
  */
 
-#ifndef CELIX_LAUNCHER_H
-#define CELIX_LAUNCHER_H
+#ifndef CELIX_LAUNCHER_H_
+#define CELIX_LAUNCHER_H_
 
 #include <stdio.h>
 #include "framework.h"
@@ -113,4 +113,4 @@ void celixLauncher_destroy(framework_t *framework);
 }
 #endif
 
-#endif //CELIX_LAUNCHER_H
+#endif //CELIX_LAUNCHER_H_

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/constants.h
----------------------------------------------------------------------
diff --git a/framework/include/constants.h b/framework/include/constants.h
index 06d89be..ac00241 100644
--- a/framework/include/constants.h
+++ b/framework/include/constants.h
@@ -16,64 +16,5 @@
  *specific language governing permissions and limitations
  *under the License.
  */
-/*
- * constants.h
- *
- *  \date       Apr 29, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
- */
-
-#ifndef CONSTANTS_H_
-#define CONSTANTS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static const char *const OSGI_FRAMEWORK_OBJECTCLASS = "objectClass";
-static const char *const OSGI_FRAMEWORK_SERVICE_ID = "service.id";
-static const char *const OSGI_FRAMEWORK_SERVICE_PID = "service.pid";
-static const char *const OSGI_FRAMEWORK_SERVICE_RANKING = "service.ranking";
-
-static const char *const CELIX_FRAMEWORK_SERVICE_VERSION = "service.version";
-static const char *const CELIX_FRAMEWORK_SERVICE_LANGUAGE = "service.lang";
-static const char *const CELIX_FRAMEWORK_SERVICE_C_LANGUAGE = "C";
-static const char *const CELIX_FRAMEWORK_SERVICE_CXX_LANGUAGE = "C++";
-static const char *const CELIX_FRAMEWORK_SERVICE_SHARED_LANGUAGE = "shared"; //e.g. marker services
-
-static const char *const OSGI_FRAMEWORK_BUNDLE_ACTIVATOR = "Bundle-Activator";
-static const char *const OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_CREATE = "bundleActivator_create";
-static const char *const OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_START = "bundleActivator_start";
-static const char *const OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_STOP = "bundleActivator_stop";
-static const char *const OSGI_FRAMEWORK_BUNDLE_ACTIVATOR_DESTROY = "bundleActivator_destroy";
-
-static const char *const OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_CREATE = "dm_create";
-static const char *const OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_INIT = "dm_init";
-static const char *const OSGI_FRAMEWORK_BUNDLE_DM_ACTIVATOR_DESTROY = "dm_destroy";
-
-
-static const char *const OSGI_FRAMEWORK_BUNDLE_SYMBOLICNAME = "Bundle-SymbolicName";
-static const char *const OSGI_FRAMEWORK_BUNDLE_VERSION = "Bundle-Version";
-static const char *const OSGI_FRAMEWORK_PRIVATE_LIBRARY = "Private-Library";
-static const char *const OSGI_FRAMEWORK_EXPORT_LIBRARY = "Export-Library";
-static const char *const OSGI_FRAMEWORK_IMPORT_LIBRARY = "Import-Library";
-
-static const char *const OSGI_FRAMEWORK_FRAMEWORK_STORAGE = "org.osgi.framework.storage";
-static const char *const OSGI_FRAMEWORK_FRAMEWORK_STORAGE_CLEAN = "org.osgi.framework.storage.clean";
-static const char *const OSGI_FRAMEWORK_FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT = "onFirstInit";
-static const char *const OSGI_FRAMEWORK_FRAMEWORK_UUID = "org.osgi.framework.uuid";
-
-#define CELIX_AUTO_START_0 "CELIX_AUTO_START_0"
-#define CELIX_AUTO_START_1 "CELIX_AUTO_START_1"
-#define CELIX_AUTO_START_2 "CELIX_AUTO_START_2"
-#define CELIX_AUTO_START_3 "CELIX_AUTO_START_3"
-#define CELIX_AUTO_START_4 "CELIX_AUTO_START_4"
-#define CELIX_AUTO_START_5 "CELIX_AUTO_START_5"
-
-
-#ifdef __cplusplus
-}
-#endif
 
-#endif /* CONSTANTS_H_ */
+#include "celix_constants.h"

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/framework.h
----------------------------------------------------------------------
diff --git a/framework/include/framework.h b/framework/include/framework.h
index 5143f47..0b718af 100644
--- a/framework/include/framework.h
+++ b/framework/include/framework.h
@@ -27,10 +27,10 @@
 #ifndef FRAMEWORK_H_
 #define FRAMEWORK_H_
 
-typedef struct activator *activator_pt;
+typedef struct activator * activator_pt;
 typedef struct activator activator_t;
 
-typedef struct framework *framework_pt;
+typedef struct framework * framework_pt;
 typedef struct framework framework_t;
 
 #include "celix_errno.h"
@@ -43,7 +43,6 @@ typedef struct framework framework_t;
 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_start(framework_t *framework);
@@ -52,11 +51,15 @@ FRAMEWORK_EXPORT celix_status_t framework_stop(framework_t *framework);
 
 FRAMEWORK_EXPORT celix_status_t framework_destroy(framework_t *framework);
 
+FRAMEWORK_EXPORT const char* framework_getUUID(framework_t *framework);
+
+FRAMEWORK_EXPORT celix_status_t fw_init(framework_t *framework);
+
 FRAMEWORK_EXPORT celix_status_t framework_waitForStop(framework_t *framework);
 
-FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(framework_t *framework, bundle_t **bundle);
+FRAMEWORK_EXPORT celix_status_t framework_getFrameworkBundle(framework_t *framework, bundle_pt *bundle);
 
-bundle_context_t* framework_getContext(framework_t *framework);
+FRAMEWORK_EXPORT bundle_context_t* framework_getContext(framework_t *framework);
 
 #ifdef __cplusplus
 }

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/include/service_reference.h
----------------------------------------------------------------------
diff --git a/framework/include/service_reference.h b/framework/include/service_reference.h
index 3d84526..18b5455 100644
--- a/framework/include/service_reference.h
+++ b/framework/include/service_reference.h
@@ -28,6 +28,7 @@
 #define SERVICE_REFERENCE_H_
 
 typedef struct serviceReference * service_reference_pt;
+typedef struct serviceReference service_reference_t;
 
 #include "celixbool.h"
 #include "array_list.h"

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/private/mock/bundle_context_mock.c
----------------------------------------------------------------------
diff --git a/framework/private/mock/bundle_context_mock.c b/framework/private/mock/bundle_context_mock.c
index 67bf3be..e32f5e1 100644
--- a/framework/private/mock/bundle_context_mock.c
+++ b/framework/private/mock/bundle_context_mock.c
@@ -276,7 +276,7 @@ void celix_bundleContext_useBundles(
 }
 
 
-void celix_bundleContext_useBundle(
+bool celix_bundleContext_useBundle(
 		bundle_context_t *ctx,
 		long bundleId,
 		void *callbackHandle,
@@ -286,6 +286,7 @@ void celix_bundleContext_useBundle(
 			->withLongIntParameters("bundleId", bundleId)
 			->withPointerParameters("callbackHandle", callbackHandle)
 			->withPointerParameters("use", use);
+	return mock_c()->returnValue().value.boolValue;
 }
 
 void celix_bundleContext_stopTracker(bundle_context_t *ctx, long trackerId) {

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/private/mock/bundle_mock.c
----------------------------------------------------------------------
diff --git a/framework/private/mock/bundle_mock.c b/framework/private/mock/bundle_mock.c
index 8ab5068..b842ffb 100644
--- a/framework/private/mock/bundle_mock.c
+++ b/framework/private/mock/bundle_mock.c
@@ -291,4 +291,18 @@ celix_bundle_state_e celix_bundle_getState(const bundle_t *bnd) {
 }
 
 
+celix_status_t bundle_getBundleLocation(bundle_pt bundle, const char **location) {
+	mock_c()->actualCall("bundle_getBundleLocation")
+			->withPointerParameters("bundle", bundle)
+			->withOutputParameter("location", location);
+	return mock_c()->returnValue().value.intValue;
+}
+
+
+celix_status_t bundle_getBundleCache(bundle_pt bundle, const char **cache) {
+	mock_c()->actualCall("bundle_getBundleCache")
+			->withPointerParameters("bundle", bundle)
+			->withOutputParameter("cache", cache);
+	return mock_c()->returnValue().value.intValue;
+}
 

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/src/BundleImpl.c
----------------------------------------------------------------------
diff --git a/framework/src/BundleImpl.c b/framework/src/BundleImpl.c
new file mode 100644
index 0000000..fccabae
--- /dev/null
+++ b/framework/src/BundleImpl.c
@@ -0,0 +1,771 @@
+/**
+ *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.
+ */
+/*
+ * bundle.c
+ *
+ *  \date       Mar 23, 2010
+ *  \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 "framework_private.h"
+#include "bundle_private.h"
+#include "resolver.h"
+#include "utils.h"
+
+celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module);
+celix_status_t bundle_closeRevisions(bundle_pt bundle);
+
+celix_status_t bundle_create(bundle_pt * bundle) {
+    celix_status_t status;
+    bundle_archive_pt archive = NULL;
+
+	*bundle = (bundle_pt) malloc(sizeof(**bundle));
+	if (*bundle == NULL) {
+		return CELIX_ENOMEM;
+	}
+	status = bundleArchive_createSystemBundleArchive(&archive);
+	if (status == CELIX_SUCCESS) {
+        module_pt module;
+
+        (*bundle)->archive = archive;
+        (*bundle)->activator = NULL;
+        (*bundle)->context = NULL;
+        (*bundle)->framework = NULL;
+        (*bundle)->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
+        (*bundle)->modules = NULL;
+        arrayList_create(&(*bundle)->modules);
+        (*bundle)->handle = NULL;
+        (*bundle)->manifest = NULL;
+
+        module = module_createFrameworkModule((*bundle));
+        bundle_addModule(*bundle, module);
+
+        status = celixThreadMutex_create(&(*bundle)->lock, NULL);
+        if (status != CELIX_SUCCESS) {
+        	status = CELIX_ILLEGAL_STATE;
+        } else {
+			(*bundle)->lockCount = 0;
+			(*bundle)->lockThread = celix_thread_default;
+        }
+	}
+	framework_logIfError(logger, status, NULL, "Failed to create bundle");
+
+	return status;
+}
+
+celix_status_t bundle_createFromArchive(bundle_pt * bundle, framework_pt framework, bundle_archive_pt archive) {
+    module_pt module;
+	
+	celix_status_t status;
+
+	*bundle = (bundle_pt) malloc(sizeof(**bundle));
+	if (*bundle == NULL) {
+		return CELIX_ENOMEM;
+	}
+	(*bundle)->archive = archive;
+	(*bundle)->activator = NULL;
+	(*bundle)->context = NULL;
+	(*bundle)->handle = NULL;
+	(*bundle)->manifest = NULL;
+	(*bundle)->framework = framework;
+	(*bundle)->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
+	(*bundle)->modules = NULL;
+	arrayList_create(&(*bundle)->modules);
+	
+	status = bundle_createModule(*bundle, &module);
+	if (status == CELIX_SUCCESS) {
+		bundle_addModule(*bundle, module);
+        status = celixThreadMutex_create(&(*bundle)->lock, NULL);
+        if (status != CELIX_SUCCESS) {
+			status = CELIX_ILLEGAL_STATE;
+		} else {
+			(*bundle)->lockCount = 0;
+			(*bundle)->lockThread = celix_thread_default;
+		}
+	} else {
+	    status = CELIX_FILE_IO_EXCEPTION;
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to create bundle");
+
+	return status;
+}
+
+celix_status_t bundle_destroy(bundle_pt bundle) {
+	array_list_iterator_pt iter = arrayListIterator_create(bundle->modules);
+	while (arrayListIterator_hasNext(iter)) {
+		module_pt module = arrayListIterator_next(iter);
+		module_destroy(module);
+	}
+	arrayListIterator_destroy(iter);
+	arrayList_destroy(bundle->modules);
+	celixThreadMutex_destroy(&bundle->lock);
+
+	free(bundle);
+
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_getArchive(bundle_pt bundle, bundle_archive_pt *archive) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (bundle != NULL && *archive == NULL) {
+		*archive = bundle->archive;
+	} else {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to get bundle archive");
+
+	return status;
+}
+
+celix_status_t bundle_getCurrentModule(bundle_pt bundle, module_pt *module) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (bundle == NULL || arrayList_size(bundle->modules)==0 ) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		*module = arrayList_get(bundle->modules, arrayList_size(bundle->modules) - 1);
+	}
+
+	return status;
+}
+
+array_list_pt bundle_getModules(bundle_pt bundle) {
+    return bundle->modules;
+}
+
+void * bundle_getHandle(bundle_pt bundle) {
+	return bundle->handle;
+}
+
+void bundle_setHandle(bundle_pt bundle, void * handle) {
+	bundle->handle = handle;
+}
+
+activator_pt bundle_getActivator(bundle_pt bundle) {
+	return bundle->activator;
+}
+
+celix_status_t bundle_setActivator(bundle_pt bundle, activator_pt activator) {
+	bundle->activator = activator;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_getContext(bundle_pt bundle, bundle_context_pt *context) {
+	*context = bundle->context;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_setContext(bundle_pt bundle, bundle_context_pt context) {
+	bundle->context = context;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_getEntry(bundle_pt bundle, const char* name, char** out) {
+	char *entry = celix_bundle_getEntry(bundle, name);
+	if (out != NULL ) {
+		*out = entry;
+	}
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state) {
+	if(bundle==NULL){
+		*state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN;
+		return CELIX_BUNDLE_EXCEPTION;
+	}
+	*state = bundle->state;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_setState(bundle_pt bundle, bundle_state_e state) {
+	bundle->state = state;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module) {
+	celix_status_t status = CELIX_SUCCESS;
+	bundle_archive_pt archive = NULL;
+	bundle_revision_pt revision = NULL;
+	manifest_pt headerMap = NULL;
+
+	status = CELIX_DO_IF(status, bundle_getArchive(bundle, &archive));
+	status = CELIX_DO_IF(status, bundleArchive_getCurrentRevision(archive, &revision));
+	status = CELIX_DO_IF(status, bundleRevision_getManifest(revision, &headerMap));
+	if (status == CELIX_SUCCESS) {
+		long bundleId = 0;
+        status = bundleArchive_getId(bundle->archive, &bundleId);
+        if (status == CELIX_SUCCESS) {
+			int revision = 0;
+			char moduleId[512];
+
+			snprintf(moduleId, sizeof(moduleId), "%ld.%d", bundleId, revision);
+			*module = module_create(headerMap, moduleId, bundle);
+
+			if (*module != NULL) {
+				version_pt bundleVersion = module_getVersion(*module);
+				const char * symName = NULL;
+				status = module_getSymbolicName(*module, &symName);
+				if (status == CELIX_SUCCESS) {
+					array_list_pt bundles = framework_getBundles(bundle->framework);
+					unsigned int i;
+					for (i = 0; i < arrayList_size(bundles); i++) {
+						bundle_pt check = (bundle_pt) arrayList_get(bundles, i);
+
+						long id;
+						if (bundleArchive_getId(check->archive, &id) == CELIX_SUCCESS) {
+							if (id != bundleId) {
+								module_pt mod = NULL;
+								const char * sym = NULL;
+								version_pt version;
+								int cmp;
+								status = bundle_getCurrentModule(check, &mod);
+								status = module_getSymbolicName(mod, &sym);
+
+								version = module_getVersion(mod);
+								version_compareTo(bundleVersion, version, &cmp);
+								if ((symName != NULL) && (sym != NULL) && !strcmp(symName, sym) &&
+										!cmp) {
+									char *versionString = NULL;
+									version_toString(version, &versionString);
+									printf("Bundle symbolic name and version are not unique: %s:%s\n", sym, versionString);
+									free(versionString);
+									status = CELIX_BUNDLE_EXCEPTION;
+									break;
+								}
+							}
+						}
+					}
+					arrayList_destroy(bundles);
+				}
+			}
+        }
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to create module");
+
+	return status;
+}
+
+celix_status_t bundle_start(bundle_pt bundle) {
+	return bundle_startWithOptions(bundle, 0);
+}
+
+celix_status_t bundle_startWithOptions(bundle_pt bundle, int options) {
+	celix_status_t status = CELIX_SUCCESS;
+    if (bundle != NULL) {
+    	bool systemBundle = false;
+    	status = bundle_isSystemBundle(bundle, &systemBundle);
+    	if (status == CELIX_SUCCESS) {
+    		if (systemBundle) {
+    			framework_start(bundle->framework);
+    		} else {
+    			status = fw_startBundle(bundle->framework, bundle, options);
+    		}
+    	}
+    }
+
+	framework_logIfError(logger, status, NULL, "Failed to start bundle");
+
+    return status;
+}
+
+celix_status_t bundle_update(bundle_pt bundle, const char *inputFile) {
+	celix_status_t status = CELIX_SUCCESS;
+	if (bundle != NULL) {
+		bool systemBundle = false;
+		status = bundle_isSystemBundle(bundle, &systemBundle);
+		if (status == CELIX_SUCCESS) {
+			if (systemBundle) {
+				// #TODO: Support framework update
+				status = CELIX_BUNDLE_EXCEPTION;
+			} else {
+				status = framework_updateBundle(bundle->framework, bundle, inputFile);
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to update bundle");
+
+	return status;
+}
+
+celix_status_t bundle_stop(bundle_pt bundle) {
+	return bundle_stopWithOptions(bundle, 0);
+}
+
+celix_status_t bundle_stopWithOptions(bundle_pt bundle, int options) {
+	celix_status_t status = CELIX_SUCCESS;
+	if (bundle != NULL) {
+		bool systemBundle = false;
+		status = bundle_isSystemBundle(bundle, &systemBundle);
+		if (status == CELIX_SUCCESS) {
+			if (systemBundle) {
+				framework_stop(bundle->framework);
+			} else {
+				status = fw_stopBundle(bundle->framework, bundle, options);
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to stop bundle");
+
+	return status;
+}
+
+celix_status_t bundle_uninstall(bundle_pt bundle) {
+	celix_status_t status = CELIX_SUCCESS;
+	if (bundle != NULL) {
+		bool systemBundle = false;
+		status = bundle_isSystemBundle(bundle, &systemBundle);
+		if (status == CELIX_SUCCESS) {
+			if (systemBundle) {
+				status = CELIX_BUNDLE_EXCEPTION;
+			} else {
+				status = fw_uninstallBundle(bundle->framework, bundle);
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to uninstall bundle");
+
+	return status;
+}
+
+celix_status_t bundle_setPersistentStateInactive(bundle_pt bundle) {
+	celix_status_t status;
+	bool systemBundle;
+
+	status = bundle_isSystemBundle(bundle, &systemBundle);
+	if (status == CELIX_SUCCESS) {
+		if (!systemBundle) {
+			status = bundleArchive_setPersistentState(bundle->archive, OSGI_FRAMEWORK_BUNDLE_INSTALLED);
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to set persistent state to inactive");
+
+	return status;
+}
+
+celix_status_t bundle_setPersistentStateUninstalled(bundle_pt bundle) {
+	celix_status_t status;
+	bool systemBundle;
+
+	status = bundle_isSystemBundle(bundle, &systemBundle);
+	if (status == CELIX_SUCCESS) {
+		if (!systemBundle) {
+			status = bundleArchive_setPersistentState(bundle->archive, OSGI_FRAMEWORK_BUNDLE_UNINSTALLED);
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to set persistent state to uninstalled");
+
+    return status;
+}
+
+celix_status_t bundle_revise(bundle_pt bundle, const char * location, const char *inputFile) {
+	celix_status_t status;
+
+	bundle_archive_pt archive = NULL;
+	status = bundle_getArchive(bundle, &archive);
+	if (status == CELIX_SUCCESS) {
+		status = bundleArchive_revise(archive, location, inputFile);
+		if (status == CELIX_SUCCESS) {
+			module_pt module;
+			status = bundle_createModule(bundle, &module);
+			if (status == CELIX_SUCCESS) {
+				status = bundle_addModule(bundle, module);
+			} else {
+				bool rolledback;
+				status = bundleArchive_rollbackRevise(archive, &rolledback);
+				if (status == CELIX_SUCCESS) {
+					status = CELIX_BUNDLE_EXCEPTION;
+				}
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to revise bundle");
+
+	return status;
+}
+
+//bool bundle_rollbackRevise(bundle_pt bundle) {
+//	module_pt module = arrayList_remove(bundle->modules, arrayList_set(bundle->modules) - 1);
+//	return resolver_removeModule(module);
+//}
+
+celix_status_t bundle_addModule(bundle_pt bundle, module_pt module) {
+	arrayList_add(bundle->modules, module);
+	resolver_addModule(module);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t bundle_isSystemBundle(bundle_pt bundle, bool *systemBundle) {
+	celix_status_t status;
+	long bundleId;
+	bundle_archive_pt archive = NULL;
+
+	status = bundle_getArchive(bundle, &archive);
+	if (status == CELIX_SUCCESS) {
+		status = bundleArchive_getId(archive, &bundleId);
+		if (status == CELIX_SUCCESS) {
+			*systemBundle = (bundleId == 0);
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to check if bundle is the systembundle");
+
+	return status;
+}
+
+celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable) {
+	celix_status_t status;
+
+	status = celixThreadMutex_lock(&bundle->lock);
+	if (status != CELIX_SUCCESS) {
+		status = CELIX_BUNDLE_EXCEPTION;
+	} else {
+		bool equals;
+		status = thread_equalsSelf(bundle->lockThread, &equals);
+		if (status == CELIX_SUCCESS) {
+			*lockable = (bundle->lockCount == 0) || (equals);
+		}
+
+		status = celixThreadMutex_unlock(&bundle->lock);
+		if (status != CELIX_SUCCESS) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to check if bundle is lockable");
+
+	return status;
+}
+
+celix_status_t bundle_getLockingThread(bundle_pt bundle, celix_thread_t *thread) {
+	celix_status_t status;
+
+	status = celixThreadMutex_lock(&bundle->lock);
+	if (status != CELIX_SUCCESS) {
+		status = CELIX_BUNDLE_EXCEPTION;
+	} else {
+		*thread = bundle->lockThread;
+
+		status = celixThreadMutex_unlock(&bundle->lock);
+		if (status != CELIX_SUCCESS) {
+			status = CELIX_BUNDLE_EXCEPTION;
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to get locking thread");
+
+	return status;
+}
+
+celix_status_t bundle_lock(bundle_pt bundle, bool *locked) {
+	celix_status_t status;
+	bool equals;
+
+	celixThreadMutex_lock(&bundle->lock);
+
+	status = thread_equalsSelf(bundle->lockThread, &equals);
+	if (status == CELIX_SUCCESS) {
+		if ((bundle->lockCount > 0) && !equals) {
+			*locked = false;
+		} else {
+			bundle->lockCount++;
+			bundle->lockThread = celixThread_self();
+			*locked = true;
+		}
+	}
+
+	celixThreadMutex_unlock(&bundle->lock);
+
+	framework_logIfError(logger, status, NULL, "Failed to lock bundle");
+
+	return status;
+}
+
+celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	bool equals;
+
+	celixThreadMutex_lock(&bundle->lock);
+
+	if (bundle->lockCount == 0) {
+		*unlocked = false;
+	} else {
+		status = thread_equalsSelf(bundle->lockThread, &equals);
+		if (status == CELIX_SUCCESS) {
+			if ((bundle->lockCount > 0) && !equals) {
+				*unlocked = false;
+			}
+			else{
+			   bundle->lockCount--;
+			   if (bundle->lockCount == 0) {
+			   	bundle->lockThread = celix_thread_default;
+			   }
+			   *unlocked = true;
+		   }
+	   }
+	}
+
+	celixThreadMutex_unlock(&bundle->lock);
+
+	framework_logIfError(logger, status, NULL, "Failed to unlock bundle");
+
+	return status;
+}
+
+celix_status_t bundle_close(bundle_pt bundle) {
+	bundle_archive_pt archive = NULL;
+	
+	celix_status_t status;
+
+    bundle_closeModules(bundle);
+    bundle_closeRevisions(bundle);
+    status = bundle_getArchive(bundle, &archive);
+    if (status == CELIX_SUCCESS) {
+		bundleArchive_close(archive);
+    }
+
+	framework_logIfError(logger, status, NULL, "Failed to close bundle");
+
+    return status;
+}
+
+celix_status_t bundle_closeAndDelete(bundle_pt bundle) {
+	celix_status_t status;
+
+	bundle_archive_pt archive = NULL;
+
+    bundle_closeModules(bundle);
+    bundle_closeRevisions(bundle);
+    status = bundle_getArchive(bundle, &archive);
+    if (status == CELIX_SUCCESS) {
+    	bundleArchive_closeAndDelete(archive);
+    }
+
+	framework_logIfError(logger, status, NULL, "Failed to close and delete bundle");
+
+    return status;
+}
+
+celix_status_t bundle_closeRevisions(bundle_pt bundle) {
+    celix_status_t status = CELIX_SUCCESS;
+
+    // TODO implement this
+    return status;
+}
+
+celix_status_t bundle_closeModules(bundle_pt bundle) {
+    celix_status_t status = CELIX_SUCCESS;
+
+    unsigned int i = 0;
+    for (i = 0; i < arrayList_size(bundle->modules); i++) {
+        module_pt module = (module_pt) arrayList_get(bundle->modules, i);
+        resolver_removeModule(module);
+        module_setWires(module, NULL);
+    }
+
+    return status;
+}
+
+celix_status_t bundle_refresh(bundle_pt bundle) {
+	celix_status_t status;
+	module_pt module;
+
+	status = bundle_closeModules(bundle);
+	if (status == CELIX_SUCCESS) {
+		arrayList_clear(bundle->modules);
+		status = bundle_createModule(bundle, &module);
+		if (status == CELIX_SUCCESS) {
+			status = bundle_addModule(bundle, module);
+			if (status == CELIX_SUCCESS) {
+				bundle->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
+			}
+		}
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to refresh bundle");
+
+    return status;
+}
+
+celix_status_t bundle_getBundleId(bundle_t *bundle, long *bndId) {
+	celix_status_t status = CELIX_SUCCESS;
+	long id = celix_bundle_getId(bundle);
+	if (id >= 0) {
+		*bndId = id;
+	} else {
+		status = CELIX_BUNDLE_EXCEPTION;
+		*bndId = -1;
+	}
+	return status;
+}
+
+celix_status_t bundle_getRegisteredServices(bundle_pt bundle, array_list_pt *list) {
+	celix_status_t status;
+
+	status = fw_getBundleRegisteredServices(bundle->framework, bundle, list);
+
+	framework_logIfError(bundle->framework->logger, status, NULL, "Failed to get registered services");
+
+	return status;
+}
+
+celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list) {
+	celix_status_t status;
+
+	status = fw_getBundleServicesInUse(bundle->framework, bundle, list);
+
+	framework_logIfError(logger, status, NULL, "Failed to get in use services");
+
+	return status;
+}
+
+celix_status_t bundle_setFramework(bundle_pt bundle, framework_pt framework) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (bundle != NULL && framework != NULL) {
+		bundle->framework = framework;
+	} else {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to set framework");
+
+	return status;
+}
+
+celix_status_t bundle_getFramework(bundle_pt bundle, framework_pt *framework) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (bundle != NULL && *framework == NULL) {
+		*framework = bundle->framework;
+	} else {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	framework_logIfError(logger, status, NULL, "Failed to get framework");
+
+	return status;
+}
+
+celix_status_t bundle_getBundleLocation(bundle_pt bundle, const char **location){
+	celix_status_t status;
+
+	bundle_archive_pt archive = NULL;
+
+	status = bundle_getArchive(bundle, &archive);
+	if (status != CELIX_SUCCESS){
+		printf("[ ERROR ]: Bundle - getBundleLocation (BundleArchive) \n");
+		return status;
+	}
+
+	status =  bundleArchive_getLocation(archive, location);
+	if (status != CELIX_SUCCESS){
+		printf("[ ERROR ]:  Bundle - getBundleLocation (BundleArchiveLocation) \n");
+		return status;
+	}
+
+	return CELIX_SUCCESS;
+}
+
+
+celix_status_t bundle_getBundleCache(bundle_pt bundle, const char **out) {
+    celix_status_t status;
+    
+    const char *cache = NULL;
+    bundle_archive_pt archive = NULL;
+    bundle_revision_pt rev = NULL;
+    
+    status = bundle_getArchive(bundle, &archive);
+    if (status != CELIX_SUCCESS){
+        printf("[ ERROR ]: Bundle - bundle_getBundleCache (BundleArchive) \n");
+        return status;
+    }
+    
+    status = bundleArchive_getCurrentRevision(archive, &rev);
+    if (status != CELIX_SUCCESS){
+        printf("[ ERROR ]:  Bundle - bundle_getBundleCache (BundleArchiveRevision) \n");
+        return status;
+    }
+    
+    status = bundleRevision_getRoot(rev, &cache);
+    if (status != CELIX_SUCCESS){
+        printf("[ ERROR ]:  Bundle - bundle_getBundleCache (BundleArchiveRevision) \n");
+        return status;
+    }
+    
+    if (out != NULL) {
+        *out = cache;
+    }
+    
+    return CELIX_SUCCESS;
+}
+
+
+
+
+/**********************************************************************************************************************
+ **********************************************************************************************************************
+ * Updated API
+ **********************************************************************************************************************
+ **********************************************************************************************************************/
+
+long celix_bundle_getId(const bundle_t* bnd) {
+	long bndId = -1;
+	bundle_archive_pt archive = NULL;
+	if (bnd != NULL) {
+		bundle_getArchive((bundle_t *) bnd, &archive);
+	}
+	if (archive != NULL) {
+		bundleArchive_getId(archive, &bndId);
+	}
+	if (bndId < 0) {
+		framework_logIfError(logger, CELIX_BUNDLE_EXCEPTION, NULL, "Failed to get bundle id");
+	}
+	return bndId;
+}
+
+celix_bundle_state_e celix_bundle_getState(const bundle_t *bnd) {
+	celix_bundle_state_e state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN;
+	if (bnd != NULL) {
+		state = bnd->state;
+	}
+	return state;
+}
+
+char* celix_bundle_getEntry(const bundle_t *bnd, const char *relPath) {
+	char *entry = NULL;
+	if (bnd != NULL) {
+		framework_getBundleEntry(bnd->framework, (bundle_t*)bnd, relPath, &entry);
+	}
+	return entry;
+}
+

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/src/bundle.c
----------------------------------------------------------------------
diff --git a/framework/src/bundle.c b/framework/src/bundle.c
deleted file mode 100644
index 5feb729..0000000
--- a/framework/src/bundle.c
+++ /dev/null
@@ -1,723 +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.
- */
-/*
- * bundle.c
- *
- *  \date       Mar 23, 2010
- *  \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 "framework_private.h"
-#include "bundle_private.h"
-#include "resolver.h"
-#include "utils.h"
-
-celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module);
-celix_status_t bundle_closeRevisions(bundle_pt bundle);
-
-celix_status_t bundle_create(bundle_pt * bundle) {
-    celix_status_t status;
-    bundle_archive_pt archive = NULL;
-
-	*bundle = (bundle_pt) malloc(sizeof(**bundle));
-	if (*bundle == NULL) {
-		return CELIX_ENOMEM;
-	}
-	status = bundleArchive_createSystemBundleArchive(&archive);
-	if (status == CELIX_SUCCESS) {
-        module_pt module;
-
-        (*bundle)->archive = archive;
-        (*bundle)->activator = NULL;
-        (*bundle)->context = NULL;
-        (*bundle)->framework = NULL;
-        (*bundle)->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
-        (*bundle)->modules = NULL;
-        arrayList_create(&(*bundle)->modules);
-        (*bundle)->handle = NULL;
-        (*bundle)->manifest = NULL;
-
-        module = module_createFrameworkModule((*bundle));
-        bundle_addModule(*bundle, module);
-
-        status = celixThreadMutex_create(&(*bundle)->lock, NULL);
-        if (status != CELIX_SUCCESS) {
-        	status = CELIX_ILLEGAL_STATE;
-        } else {
-			(*bundle)->lockCount = 0;
-			(*bundle)->lockThread = celix_thread_default;
-        }
-	}
-	framework_logIfError(logger, status, NULL, "Failed to create bundle");
-
-	return status;
-}
-
-celix_status_t bundle_createFromArchive(bundle_pt * bundle, framework_pt framework, bundle_archive_pt archive) {
-    module_pt module;
-	
-	celix_status_t status;
-
-	*bundle = (bundle_pt) malloc(sizeof(**bundle));
-	if (*bundle == NULL) {
-		return CELIX_ENOMEM;
-	}
-	(*bundle)->archive = archive;
-	(*bundle)->activator = NULL;
-	(*bundle)->context = NULL;
-	(*bundle)->handle = NULL;
-	(*bundle)->manifest = NULL;
-	(*bundle)->framework = framework;
-	(*bundle)->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
-	(*bundle)->modules = NULL;
-	arrayList_create(&(*bundle)->modules);
-	
-	status = bundle_createModule(*bundle, &module);
-	if (status == CELIX_SUCCESS) {
-		bundle_addModule(*bundle, module);
-        status = celixThreadMutex_create(&(*bundle)->lock, NULL);
-        if (status != CELIX_SUCCESS) {
-			status = CELIX_ILLEGAL_STATE;
-		} else {
-			(*bundle)->lockCount = 0;
-			(*bundle)->lockThread = celix_thread_default;
-		}
-	} else {
-	    status = CELIX_FILE_IO_EXCEPTION;
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to create bundle");
-
-	return status;
-}
-
-celix_status_t bundle_destroy(bundle_pt bundle) {
-	array_list_iterator_pt iter = arrayListIterator_create(bundle->modules);
-	while (arrayListIterator_hasNext(iter)) {
-		module_pt module = arrayListIterator_next(iter);
-		module_destroy(module);
-	}
-	arrayListIterator_destroy(iter);
-	arrayList_destroy(bundle->modules);
-	celixThreadMutex_destroy(&bundle->lock);
-
-	free(bundle);
-
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_getArchive(bundle_pt bundle, bundle_archive_pt *archive) {
-	celix_status_t status = CELIX_SUCCESS;
-
-	if (bundle != NULL && *archive == NULL) {
-		*archive = bundle->archive;
-	} else {
-		status = CELIX_ILLEGAL_ARGUMENT;
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to get bundle archive");
-
-	return status;
-}
-
-celix_status_t bundle_getCurrentModule(bundle_pt bundle, module_pt *module) {
-	celix_status_t status = CELIX_SUCCESS;
-
-	if (bundle == NULL || arrayList_size(bundle->modules)==0 ) {
-		status = CELIX_ILLEGAL_ARGUMENT;
-	} else {
-		*module = arrayList_get(bundle->modules, arrayList_size(bundle->modules) - 1);
-	}
-
-	return status;
-}
-
-array_list_pt bundle_getModules(bundle_pt bundle) {
-    return bundle->modules;
-}
-
-void * bundle_getHandle(bundle_pt bundle) {
-	return bundle->handle;
-}
-
-void bundle_setHandle(bundle_pt bundle, void * handle) {
-	bundle->handle = handle;
-}
-
-activator_pt bundle_getActivator(bundle_pt bundle) {
-	return bundle->activator;
-}
-
-celix_status_t bundle_setActivator(bundle_pt bundle, activator_pt activator) {
-	bundle->activator = activator;
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_getContext(bundle_pt bundle, bundle_context_pt *context) {
-	*context = bundle->context;
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_setContext(bundle_pt bundle, bundle_context_pt context) {
-	bundle->context = context;
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_getEntry(bundle_pt bundle, const char* name, char** entry) {
-	return framework_getBundleEntry(bundle->framework, bundle, name, entry);
-}
-
-celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state) {
-	if(bundle==NULL){
-		*state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN;
-		return CELIX_BUNDLE_EXCEPTION;
-	}
-	*state = bundle->state;
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_setState(bundle_pt bundle, bundle_state_e state) {
-	bundle->state = state;
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module) {
-	celix_status_t status = CELIX_SUCCESS;
-	bundle_archive_pt archive = NULL;
-	bundle_revision_pt revision = NULL;
-	manifest_pt headerMap = NULL;
-
-	status = CELIX_DO_IF(status, bundle_getArchive(bundle, &archive));
-	status = CELIX_DO_IF(status, bundleArchive_getCurrentRevision(archive, &revision));
-	status = CELIX_DO_IF(status, bundleRevision_getManifest(revision, &headerMap));
-	if (status == CELIX_SUCCESS) {
-		long bundleId = 0;
-        status = bundleArchive_getId(bundle->archive, &bundleId);
-        if (status == CELIX_SUCCESS) {
-			int revision = 0;
-			char moduleId[512];
-
-			snprintf(moduleId, sizeof(moduleId), "%ld.%d", bundleId, revision);
-			*module = module_create(headerMap, moduleId, bundle);
-
-			if (*module != NULL) {
-				version_pt bundleVersion = module_getVersion(*module);
-				const char * symName = NULL;
-				status = module_getSymbolicName(*module, &symName);
-				if (status == CELIX_SUCCESS) {
-					array_list_pt bundles = framework_getBundles(bundle->framework);
-					unsigned int i;
-					for (i = 0; i < arrayList_size(bundles); i++) {
-						bundle_pt check = (bundle_pt) arrayList_get(bundles, i);
-
-						long id;
-						if (bundleArchive_getId(check->archive, &id) == CELIX_SUCCESS) {
-							if (id != bundleId) {
-								module_pt mod = NULL;
-								const char * sym = NULL;
-								version_pt version;
-								int cmp;
-								status = bundle_getCurrentModule(check, &mod);
-								status = module_getSymbolicName(mod, &sym);
-
-								version = module_getVersion(mod);
-								version_compareTo(bundleVersion, version, &cmp);
-								if ((symName != NULL) && (sym != NULL) && !strcmp(symName, sym) &&
-										!cmp) {
-									char *versionString = NULL;
-									version_toString(version, &versionString);
-									printf("Bundle symbolic name and version are not unique: %s:%s\n", sym, versionString);
-									free(versionString);
-									status = CELIX_BUNDLE_EXCEPTION;
-									break;
-								}
-							}
-						}
-					}
-					arrayList_destroy(bundles);
-				}
-			}
-        }
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to create module");
-
-	return status;
-}
-
-celix_status_t bundle_start(bundle_pt bundle) {
-	return bundle_startWithOptions(bundle, 0);
-}
-
-celix_status_t bundle_startWithOptions(bundle_pt bundle, int options) {
-	celix_status_t status = CELIX_SUCCESS;
-    if (bundle != NULL) {
-    	bool systemBundle = false;
-    	status = bundle_isSystemBundle(bundle, &systemBundle);
-    	if (status == CELIX_SUCCESS) {
-    		if (systemBundle) {
-    			framework_start(bundle->framework);
-    		} else {
-    			status = fw_startBundle(bundle->framework, bundle, options);
-    		}
-    	}
-    }
-
-	framework_logIfError(logger, status, NULL, "Failed to start bundle");
-
-    return status;
-}
-
-celix_status_t bundle_update(bundle_pt bundle, const char *inputFile) {
-	celix_status_t status = CELIX_SUCCESS;
-	if (bundle != NULL) {
-		bool systemBundle = false;
-		status = bundle_isSystemBundle(bundle, &systemBundle);
-		if (status == CELIX_SUCCESS) {
-			if (systemBundle) {
-				// #TODO: Support framework update
-				status = CELIX_BUNDLE_EXCEPTION;
-			} else {
-				status = framework_updateBundle(bundle->framework, bundle, inputFile);
-			}
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to update bundle");
-
-	return status;
-}
-
-celix_status_t bundle_stop(bundle_pt bundle) {
-	return bundle_stopWithOptions(bundle, 0);
-}
-
-celix_status_t bundle_stopWithOptions(bundle_pt bundle, int options) {
-	celix_status_t status = CELIX_SUCCESS;
-	if (bundle != NULL) {
-		bool systemBundle = false;
-		status = bundle_isSystemBundle(bundle, &systemBundle);
-		if (status == CELIX_SUCCESS) {
-			if (systemBundle) {
-				framework_stop(bundle->framework);
-			} else {
-				status = fw_stopBundle(bundle->framework, bundle, options);
-			}
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to stop bundle");
-
-	return status;
-}
-
-celix_status_t bundle_uninstall(bundle_pt bundle) {
-	celix_status_t status = CELIX_SUCCESS;
-	if (bundle != NULL) {
-		bool systemBundle = false;
-		status = bundle_isSystemBundle(bundle, &systemBundle);
-		if (status == CELIX_SUCCESS) {
-			if (systemBundle) {
-				status = CELIX_BUNDLE_EXCEPTION;
-			} else {
-				status = fw_uninstallBundle(bundle->framework, bundle);
-			}
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to uninstall bundle");
-
-	return status;
-}
-
-celix_status_t bundle_setPersistentStateInactive(bundle_pt bundle) {
-	celix_status_t status;
-	bool systemBundle;
-
-	status = bundle_isSystemBundle(bundle, &systemBundle);
-	if (status == CELIX_SUCCESS) {
-		if (!systemBundle) {
-			status = bundleArchive_setPersistentState(bundle->archive, OSGI_FRAMEWORK_BUNDLE_INSTALLED);
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to set persistent state to inactive");
-
-	return status;
-}
-
-celix_status_t bundle_setPersistentStateUninstalled(bundle_pt bundle) {
-	celix_status_t status;
-	bool systemBundle;
-
-	status = bundle_isSystemBundle(bundle, &systemBundle);
-	if (status == CELIX_SUCCESS) {
-		if (!systemBundle) {
-			status = bundleArchive_setPersistentState(bundle->archive, OSGI_FRAMEWORK_BUNDLE_UNINSTALLED);
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to set persistent state to uninstalled");
-
-    return status;
-}
-
-celix_status_t bundle_revise(bundle_pt bundle, const char * location, const char *inputFile) {
-	celix_status_t status;
-
-	bundle_archive_pt archive = NULL;
-	status = bundle_getArchive(bundle, &archive);
-	if (status == CELIX_SUCCESS) {
-		status = bundleArchive_revise(archive, location, inputFile);
-		if (status == CELIX_SUCCESS) {
-			module_pt module;
-			status = bundle_createModule(bundle, &module);
-			if (status == CELIX_SUCCESS) {
-				status = bundle_addModule(bundle, module);
-			} else {
-				bool rolledback;
-				status = bundleArchive_rollbackRevise(archive, &rolledback);
-				if (status == CELIX_SUCCESS) {
-					status = CELIX_BUNDLE_EXCEPTION;
-				}
-			}
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to revise bundle");
-
-	return status;
-}
-
-//bool bundle_rollbackRevise(bundle_pt bundle) {
-//	module_pt module = arrayList_remove(bundle->modules, arrayList_set(bundle->modules) - 1);
-//	return resolver_removeModule(module);
-//}
-
-celix_status_t bundle_addModule(bundle_pt bundle, module_pt module) {
-	arrayList_add(bundle->modules, module);
-	resolver_addModule(module);
-	return CELIX_SUCCESS;
-}
-
-celix_status_t bundle_isSystemBundle(bundle_pt bundle, bool *systemBundle) {
-	celix_status_t status;
-	long bundleId;
-	bundle_archive_pt archive = NULL;
-
-	status = bundle_getArchive(bundle, &archive);
-	if (status == CELIX_SUCCESS) {
-		status = bundleArchive_getId(archive, &bundleId);
-		if (status == CELIX_SUCCESS) {
-			*systemBundle = (bundleId == 0);
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to check if bundle is the systembundle");
-
-	return status;
-}
-
-celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable) {
-	celix_status_t status;
-
-	status = celixThreadMutex_lock(&bundle->lock);
-	if (status != CELIX_SUCCESS) {
-		status = CELIX_BUNDLE_EXCEPTION;
-	} else {
-		bool equals;
-		status = thread_equalsSelf(bundle->lockThread, &equals);
-		if (status == CELIX_SUCCESS) {
-			*lockable = (bundle->lockCount == 0) || (equals);
-		}
-
-		status = celixThreadMutex_unlock(&bundle->lock);
-		if (status != CELIX_SUCCESS) {
-			status = CELIX_BUNDLE_EXCEPTION;
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to check if bundle is lockable");
-
-	return status;
-}
-
-celix_status_t bundle_getLockingThread(bundle_pt bundle, celix_thread_t *thread) {
-	celix_status_t status;
-
-	status = celixThreadMutex_lock(&bundle->lock);
-	if (status != CELIX_SUCCESS) {
-		status = CELIX_BUNDLE_EXCEPTION;
-	} else {
-		*thread = bundle->lockThread;
-
-		status = celixThreadMutex_unlock(&bundle->lock);
-		if (status != CELIX_SUCCESS) {
-			status = CELIX_BUNDLE_EXCEPTION;
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to get locking thread");
-
-	return status;
-}
-
-celix_status_t bundle_lock(bundle_pt bundle, bool *locked) {
-	celix_status_t status;
-	bool equals;
-
-	celixThreadMutex_lock(&bundle->lock);
-
-	status = thread_equalsSelf(bundle->lockThread, &equals);
-	if (status == CELIX_SUCCESS) {
-		if ((bundle->lockCount > 0) && !equals) {
-			*locked = false;
-		} else {
-			bundle->lockCount++;
-			bundle->lockThread = celixThread_self();
-			*locked = true;
-		}
-	}
-
-	celixThreadMutex_unlock(&bundle->lock);
-
-	framework_logIfError(logger, status, NULL, "Failed to lock bundle");
-
-	return status;
-}
-
-celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked) {
-	celix_status_t status = CELIX_SUCCESS;
-
-	bool equals;
-
-	celixThreadMutex_lock(&bundle->lock);
-
-	if (bundle->lockCount == 0) {
-		*unlocked = false;
-	} else {
-		status = thread_equalsSelf(bundle->lockThread, &equals);
-		if (status == CELIX_SUCCESS) {
-			if ((bundle->lockCount > 0) && !equals) {
-				*unlocked = false;
-			}
-			else{
-			   bundle->lockCount--;
-			   if (bundle->lockCount == 0) {
-			   	bundle->lockThread = celix_thread_default;
-			   }
-			   *unlocked = true;
-		   }
-	   }
-	}
-
-	celixThreadMutex_unlock(&bundle->lock);
-
-	framework_logIfError(logger, status, NULL, "Failed to unlock bundle");
-
-	return status;
-}
-
-celix_status_t bundle_close(bundle_pt bundle) {
-	bundle_archive_pt archive = NULL;
-	
-	celix_status_t status;
-
-    bundle_closeModules(bundle);
-    bundle_closeRevisions(bundle);
-    status = bundle_getArchive(bundle, &archive);
-    if (status == CELIX_SUCCESS) {
-		bundleArchive_close(archive);
-    }
-
-	framework_logIfError(logger, status, NULL, "Failed to close bundle");
-
-    return status;
-}
-
-celix_status_t bundle_closeAndDelete(bundle_pt bundle) {
-	celix_status_t status;
-
-	bundle_archive_pt archive = NULL;
-
-    bundle_closeModules(bundle);
-    bundle_closeRevisions(bundle);
-    status = bundle_getArchive(bundle, &archive);
-    if (status == CELIX_SUCCESS) {
-    	bundleArchive_closeAndDelete(archive);
-    }
-
-	framework_logIfError(logger, status, NULL, "Failed to close and delete bundle");
-
-    return status;
-}
-
-celix_status_t bundle_closeRevisions(bundle_pt bundle) {
-    celix_status_t status = CELIX_SUCCESS;
-
-    // TODO implement this
-    return status;
-}
-
-celix_status_t bundle_closeModules(bundle_pt bundle) {
-    celix_status_t status = CELIX_SUCCESS;
-
-    unsigned int i = 0;
-    for (i = 0; i < arrayList_size(bundle->modules); i++) {
-        module_pt module = (module_pt) arrayList_get(bundle->modules, i);
-        resolver_removeModule(module);
-        module_setWires(module, NULL);
-    }
-
-    return status;
-}
-
-celix_status_t bundle_refresh(bundle_pt bundle) {
-	celix_status_t status;
-	module_pt module;
-
-	status = bundle_closeModules(bundle);
-	if (status == CELIX_SUCCESS) {
-		arrayList_clear(bundle->modules);
-		status = bundle_createModule(bundle, &module);
-		if (status == CELIX_SUCCESS) {
-			status = bundle_addModule(bundle, module);
-			if (status == CELIX_SUCCESS) {
-				bundle->state = OSGI_FRAMEWORK_BUNDLE_INSTALLED;
-			}
-		}
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to refresh bundle");
-
-    return status;
-}
-
-celix_status_t bundle_getBundleId(bundle_t *bundle, long *bndId) {
-	celix_status_t status = CELIX_SUCCESS;
-	long id = celix_bundle_getId(bundle);
-	if (id >= 0) {
-		*bndId = id;
-	} else {
-		status = CELIX_BUNDLE_EXCEPTION;
-		*bndId = -1;
-	}
-	return status;
-}
-
-celix_status_t bundle_getRegisteredServices(bundle_pt bundle, array_list_pt *list) {
-	celix_status_t status;
-
-	status = fw_getBundleRegisteredServices(bundle->framework, bundle, list);
-
-	framework_logIfError(bundle->framework->logger, status, NULL, "Failed to get registered services");
-
-	return status;
-}
-
-celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list) {
-	celix_status_t status;
-
-	status = fw_getBundleServicesInUse(bundle->framework, bundle, list);
-
-	framework_logIfError(logger, status, NULL, "Failed to get in use services");
-
-	return status;
-}
-
-celix_status_t bundle_setFramework(bundle_pt bundle, framework_pt framework) {
-	celix_status_t status = CELIX_SUCCESS;
-
-	if (bundle != NULL && framework != NULL) {
-		bundle->framework = framework;
-	} else {
-		status = CELIX_ILLEGAL_ARGUMENT;
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to set framework");
-
-	return status;
-}
-
-celix_status_t bundle_getFramework(bundle_pt bundle, framework_pt *framework) {
-	celix_status_t status = CELIX_SUCCESS;
-
-	if (bundle != NULL && *framework == NULL) {
-		*framework = bundle->framework;
-	} else {
-		status = CELIX_ILLEGAL_ARGUMENT;
-	}
-
-	framework_logIfError(logger, status, NULL, "Failed to get framework");
-
-	return status;
-}
-
-celix_status_t bundle_getBundleLocation(bundle_pt bundle, const char **location){
-
-	celix_status_t status;
-
-	bundle_archive_pt archive = NULL;
-
-	status = bundle_getArchive(bundle, &archive);
-	if (status != CELIX_SUCCESS){
-		printf("[ ERROR ]: Bundle - getBundleLocation (BundleArchive) \n");
-		return status;
-	}
-
-	status =  bundleArchive_getLocation(archive, location);
-	if (status != CELIX_SUCCESS){
-		printf("[ ERROR ]:  Bundle - getBundleLocation (BundleArchiveLocation) \n");
-		return status;
-	}
-
-	return CELIX_SUCCESS;
-}
-
-
-
-
-
-
-/**********************************************************************************************************************
- **********************************************************************************************************************
- * Updated API
- **********************************************************************************************************************
- **********************************************************************************************************************/
-
-long celix_bundle_getId(const bundle_t* bnd) {
-	long bndId = -1;
-	bundle_archive_pt archive = NULL;
-	bundle_getArchive((bundle_t*)bnd, &archive);
-	if (archive != NULL) {
-		bundleArchive_getId(archive, &bndId);
-	}
-
-	if (bndId < 0) {
-		framework_logIfError(logger, CELIX_BUNDLE_EXCEPTION, NULL, "Failed to get bundle id");
-	}
-	return bndId;
-}
-
-celix_bundle_state_e celix_bundle_getState(const bundle_t *bnd) {
-	return bnd->state;
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/src/bundle_context.c
----------------------------------------------------------------------
diff --git a/framework/src/bundle_context.c b/framework/src/bundle_context.c
index b058d88..7e6b58f 100644
--- a/framework/src/bundle_context.c
+++ b/framework/src/bundle_context.c
@@ -583,12 +583,12 @@ void celix_bundleContext_useBundles(
     celix_framework_useBundles(ctx->framework, callbackHandle, use);
 }
 
-void celix_bundleContext_useBundle(
+bool celix_bundleContext_useBundle(
         bundle_context_t *ctx,
         long bundleId,
         void *callbackHandle,
         void (*use)(void *handle, const bundle_t *bundle)) {
-    celix_framework_useBundle(ctx->framework, bundleId, callbackHandle, use);
+    return celix_framework_useBundle(ctx->framework, bundleId, callbackHandle, use);
 }
 
 static void bundleContext_cleanupBundleTracker(bundle_context_t *ctx) {

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/src/framework.c
----------------------------------------------------------------------
diff --git a/framework/src/framework.c b/framework/src/framework.c
index b6cb825..0566572 100644
--- a/framework/src/framework.c
+++ b/framework/src/framework.c
@@ -248,6 +248,10 @@ celix_status_t framework_create(framework_pt *framework, properties_pt config) {
             (*framework)->configurationMap = config;
             (*framework)->logger = logger;
 
+            //gen uuid
+            uuid_t uuid;
+            uuid_generate(uuid);
+            uuid_unparse(uuid, (*framework)->uuid);
 
             status = CELIX_DO_IF(status, bundle_create(&(*framework)->bundle));
             status = CELIX_DO_IF(status, arrayList_create(&(*framework)->globalLockWaitersList));
@@ -401,15 +405,7 @@ celix_status_t fw_init(framework_pt framework) {
 	}
 
 	if (status == CELIX_SUCCESS) {
-        /*create and store framework uuid*/
-        char uuid[37];
-
-	    uuid_t uid;
-        uuid_generate(uid);
-        uuid_unparse(uid, uuid);
-
-        properties_set(framework->configurationMap, (char*) OSGI_FRAMEWORK_FRAMEWORK_UUID, uuid);
-
+        properties_set(framework->configurationMap, (char*) OSGI_FRAMEWORK_FRAMEWORK_UUID, framework->uuid);
         framework->installedBundleMap = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
 	}
 
@@ -507,6 +503,14 @@ celix_status_t fw_init(framework_pt framework) {
 	return status;
 }
 
+FRAMEWORK_EXPORT const char* framework_getUUID(framework_t *framework) {
+    const char *uuid = NULL;
+    if (framework != NULL) {
+        uuid = framework->uuid;
+    }
+    return uuid;
+}
+
 celix_status_t framework_start(framework_pt framework) {
 	celix_status_t status = CELIX_SUCCESS;
 	bundle_state_e state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN;
@@ -717,7 +721,7 @@ celix_status_t framework_getBundleEntry(framework_pt framework, bundle_pt bundle
         }
 
         if (access(e, F_OK) == 0) {
-            (*entry) = strndup(e, 1024*10);
+            (*entry) = strndup(e, 1024*1024*10);
         } else {
             (*entry) = NULL;
         }
@@ -2771,14 +2775,17 @@ void celix_framework_useBundles(framework_t *fw, void *callbackHandle, void(*use
     }
 }
 
-void celix_framework_useBundle(framework_t *fw, long bundleId, void *callbackHandle, void(*use)(void *handle, const bundle_t *bnd)) {
+bool celix_framework_useBundle(framework_t *fw, long bundleId, void *callbackHandle, void(*use)(void *handle, const bundle_t *bnd)) {
+    bool called = false;
     if (bundleId >= 0) {
         //TODO get bundle lock without throwing errors framework_acquireBundleLock() -> a more simple lock ??
         bundle_t *bnd = framework_getBundleById(fw, bundleId);
         celix_bundle_state_e bndState = celix_bundle_getState(bnd);
         if (bndState == OSGI_FRAMEWORK_BUNDLE_ACTIVE) {
             use(callbackHandle, bnd);
+            called = true;
         }
         //TODO unlock
     }
+    return called;
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/framework/src/framework_private.h
----------------------------------------------------------------------
diff --git a/framework/src/framework_private.h b/framework/src/framework_private.h
index 66c1125..f10d024 100644
--- a/framework/src/framework_private.h
+++ b/framework/src/framework_private.h
@@ -48,9 +48,8 @@
 #include "celix_threads.h"
 
 struct framework {
-#ifdef WITH_APR
-    apr_pool_t *pool;
-#endif
+    char uuid[37];
+
     struct bundle * bundle;
     hash_map_pt installedBundleMap;
     hash_map_pt installRequestMap;
@@ -157,6 +156,6 @@ FRAMEWORK_EXPORT bundle_pt framework_getBundleById(framework_pt framework, long
  **********************************************************************************************************************/
 
 void celix_framework_useBundles(framework_t *fw, void *callbackHandle, void(*use)(void *handle, const bundle_t *bnd));
-void celix_framework_useBundle(framework_t *fw, long bundleId, void *callbackHandle, void(*use)(void *handle, const bundle_t *bnd));
+bool celix_framework_useBundle(framework_t *fw, long bundleId, void *callbackHandle, void(*use)(void *handle, const bundle_t *bnd));
 
 #endif /* FRAMEWORK_PRIVATE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/shell/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/shell/CMakeLists.txt b/shell/CMakeLists.txt
index 622e0ee..c1afda7 100644
--- a/shell/CMakeLists.txt
+++ b/shell/CMakeLists.txt
@@ -23,7 +23,7 @@ if (SHELL)
 			$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
 			$<INSTALL_INTERFACE:include/celix/shell>
 	)
-        install(TARGETS shell_api EXPORT celix COMPONENT shell)
+	install(TARGETS shell_api EXPORT celix COMPONENT shell)
 	install(DIRECTORY include/ DESTINATION include/celix/shell COMPONENT shell)
 
     add_celix_bundle(shell

http://git-wip-us.apache.org/repos/asf/celix/blob/764bd7f7/utils/include/celix_exports.h
----------------------------------------------------------------------
diff --git a/utils/include/celix_exports.h b/utils/include/celix_exports.h
new file mode 100644
index 0000000..58b7abc
--- /dev/null
+++ b/utils/include/celix_exports.h
@@ -0,0 +1,25 @@
+/**
+ *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_CELIX_EXPORTS_H
+#define CELIX_CELIX_EXPORTS_H
+
+#include "exports.h"
+
+#endif //CELIX_CELIX_EXPORTS_H


Mime
View raw message