CommonAPI-D-Bus 3.1.33.1.3

author: Jürgen Gehring <juergen.gehring@bmw.de> 2015-07-29 00:04:02 -0700
committer: Jürgen Gehring <juergen.gehring@bmw.de> 2015-07-29 00:04:02 -0700
commit: db96446ece67ba1f495811e29838e8c7bc7984ff (patch)
tree: ad49d3368287caf7d201057989db4bd19e37fd0c
parent: 49d0b428ca19852d49965f35328a314f22d88807 (diff)
download: genivi-common-api-dbus-runtime-db96446ece67ba1f495811e29838e8c7bc7984ff.tar.gz
152 files changed, 4232 insertions, 1224 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d0f3f56..5e24149 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ PROJECT(libcommonapi-dbus)
 # version of CommonAPI-DBus
 SET( LIBCOMMONAPI_DBUS_MAJOR_VERSION 3 )
 SET( LIBCOMMONAPI_DBUS_MINOR_VERSION 1 )
-SET( LIBCOMMONAPI_DBUS_PATCH_VERSION 2 )
+SET( LIBCOMMONAPI_DBUS_PATCH_VERSION 3 )
 
 message(STATUS "Project name: ${PROJECT_NAME}")
 
@@ -42,6 +42,9 @@ message(STATUS "BUILD_SHARED_LIBS is set to value: ${BUILD_SHARED_LIBS}")
 OPTION(USE_INSTALLED_COMMONAPI "Set to OFF to use the local (build tree) version of CommonAPI" ON)
 message(STATUS "USE_INSTALLED_COMMONAPI is set to value: ${USE_INSTALLED_COMMONAPI}")
 
+OPTION(USE_INSTALLED_DBUS "Set to OFF to use the local (build tree) version of DBUS" ON)
+message(STATUS "USE_INSTALLED_DBUS is set to value: ${USE_INSTALLED_DBUS}")
+
 SET(RPM_PACKAGE_VERSION "r0" CACHE STRING "rpm packet version") # used in e.g. commonapi-dbus.spec.in
 
 if(NOT CMAKE_BUILD_TYPE)
@@ -68,7 +71,7 @@ set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation director
 foreach(p LIB INCLUDE CMAKE)
   set(var INSTALL_${p}_DIR)
   if(NOT IS_ABSOLUTE "${${var}}")
-    set(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+    set(ABSOLUTE_${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
   endif()
 endforeach()
 
@@ -97,9 +100,9 @@ message(STATUS "CMAKE_FIND_ROOT_PATH: ${CMAKE_FIND_ROOT_PATH}")
 FIND_PACKAGE(PkgConfig)
 FIND_PACKAGE(Threads REQUIRED)
 if ("${USE_INSTALLED_COMMONAPI}" STREQUAL "ON")
-    FIND_PACKAGE(CommonAPI 3.1.2 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
+    FIND_PACKAGE(CommonAPI 3.1.3 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
 else()
-    FIND_PACKAGE(CommonAPI 3.1.2 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
+    FIND_PACKAGE(CommonAPI 3.1.3 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
 endif()
 
 message(STATUS "CommonAPI_CONSIDERED_CONFIGS: ${CommonAPI_CONSIDERED_CONFIGS}")
@@ -145,6 +148,12 @@ include_directories(
     ${DBus_INCLUDE_DIRS}
 )
 
+if ("${USE_INSTALLED_DBUS}" STREQUAL "OFF")
+	link_directories(
+		${DBus_INCLUDE_DIRS}/dbus/.libs
+	)
+endif()
+
 # DBus source files
 file(GLOB CAPIDB_SRCS "src/CommonAPI/DBus/*.cpp")
 
@@ -158,8 +167,8 @@ file(GLOB MMHASH_SRCS "src/murmurhash/*.cpp")
 add_library(CommonAPI-DBus ${CAPIDB_SRCS} ${PUGIXML_SRCS} ${MMHASH_SRCS})
 
 if(MSVC)
-#workaround since pkg-config on windows doesn't work easily
-target_link_libraries(CommonAPI-DBus CommonAPI debug ${DBus_BUILD_DIR}/bin/Debug/dbus-1d.lib optimized ${DBus_BUILD_DIR}/bin/Release/dbus-1.lib)
+#workaround since pkg-config on windows doesn't work easily and windows needs ws2_32 for the mainloop
+target_link_libraries(CommonAPI-DBus CommonAPI ws2_32 debug ${DBus_BUILD_DIR}/bin/Debug/dbus-1d.lib optimized ${DBus_BUILD_DIR}/bin/Release/dbus-1.lib)
 else()
 target_link_libraries(CommonAPI-DBus CommonAPI dbus-1)
 endif()
@@ -203,7 +212,7 @@ export(TARGETS CommonAPI-DBus
 export(PACKAGE CommonAPI-DBus)
 
 # Create the CommonAPI-DBusConfig.cmake and CommonAPI-DBusConfigVersion files ...
-file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}" "${INSTALL_INCLUDE_DIR}")
+file(RELATIVE_PATH REL_INCLUDE_DIR "${ABSOLUTE_INSTALL_CMAKE_DIR}" "${ABSOLUTE_INSTALL_INCLUDE_DIR}")
 
 # ... for the build tree
 set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include")
diff --git a/README b/README
new file mode 100644
index 0000000..a9ebbcc
--- /dev/null
+++ b/README
@@ -0,0 +1,3 @@
+This is CommonAPI-DBus 3.1.3
+
+Please refer to INSTALL for further information.
+\ No newline at end of file
diff --git a/cmake/CommonAPI-DBusConfigVersion.cmake.in b/cmake/CommonAPI-DBusConfigVersion.cmake.in
index 8377282..414c0c9 100644
--- a/cmake/CommonAPI-DBusConfigVersion.cmake.in
+++ b/cmake/CommonAPI-DBusConfigVersion.cmake.in
@@ -3,7 +3,7 @@ set(PACKAGE_VERSION "@PACKAGE_VERSION@")
 set(PACKAGE_VERSION_COMPATIBLE FALSE)
 
 string(REPLACE "." "\\." ESCAPED_API_HEADER_VERSION "@COMMONAPI_API_HEADER_VERSION@")
-if("${PACKAGE_FIND_VERSION}" MATCHES "^@ESCAPED_API_HEADER_VERSION@($|\\.)")
+if("${PACKAGE_FIND_VERSION}" MATCHES "^${ESCAPED_API_HEADER_VERSION}($|\\.)")
     set(PACKAGE_VERSION_COMPATIBLE TRUE)
 endif()
 
diff --git a/include/CommonAPI/DBus/CommonAPIDBus.hpp b/include/CommonAPI/DBus/CommonAPIDBus.hpp
new file mode 100644
index 0000000..1be7770
--- /dev/null
+++ b/include/CommonAPI/DBus/CommonAPIDBus.hpp
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef COMMONAPI_DBUS_HPP_
+#define COMMONAPI_DBUS_HPP_
+
+#ifndef COMMONAPI_INTERNAL_COMPILATION
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+
+#include "DBusAddressTranslator.hpp"
+
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+#endif // COMMONAPI_DBUS_HPP_
+
diff --git a/include/CommonAPI/DBus/DBusAddressTranslator.hpp b/include/CommonAPI/DBus/DBusAddressTranslator.hpp
index 7f11197..bbe1d75 100644
--- a/include/CommonAPI/DBus/DBusAddressTranslator.hpp
+++ b/include/CommonAPI/DBus/DBusAddressTranslator.hpp
@@ -3,6 +3,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#error "Only <CommonAPI/CommonAPI.hpp> can be included directly, this file may disappear or change contents."
+#endif
+
 #ifndef COMMONAPI_DBUS_ADDRESSTRANSLATOR_HPP_
 #define COMMONAPI_DBUS_ADDRESSTRANSLATOR_HPP_
 
@@ -10,6 +14,7 @@
 #include <memory>
 #include <mutex>
 
+#include <CommonAPI/Types.hpp>
 #include <CommonAPI/Address.hpp>
 #include <CommonAPI/DBus/DBusAddress.hpp>
 #include <CommonAPI/DBus/DBusTypes.hpp>
@@ -32,9 +37,15 @@ public:
 	COMMONAPI_EXPORT bool translate(const DBusAddress &_key, CommonAPI::Address &_value);
 
 	COMMONAPI_EXPORT void insert(const std::string &_address,
-		const std::string &_service, const std::string &_path, const std::string &_interface);
+		const std::string &_service, const std::string &_path, const std::string &_interface, const bool _objPathStartWithDigits = false);
+
+	COMMONAPI_EXPORT DBusType_t getDBusBusType(const ConnectionId_t &_connectionId) const ;
 
-	COMMONAPI_EXPORT DBusType_t getDBusBusType() const;
+	/**
+	 * @brief Returns whether or not org.freedesktop.DBus.Peer interface is used in a (valid) name mapping.
+	 * @return true in case any (valid) mapping of org.freedesktop.DBus.Peer is present, otherwise false
+	 */
+	COMMONAPI_EXPORT bool isOrgFreedesktopDBusPeerMapped() const;
 
 private:
 	COMMONAPI_EXPORT bool readConfiguration();
@@ -53,7 +64,9 @@ private:
 
 	std::mutex mutex_;
 
-	DBusType_t dBusBusType_;
+	std::map<ConnectionId_t, DBusType_t> dbusTypes_;
+
+	bool orgFreedesktopDBusPeerMapped_;
 };
 
 } // namespace DBus
diff --git a/include/CommonAPI/DBus/DBusAttribute.hpp b/include/CommonAPI/DBus/DBusAttribute.hpp
index 3d9170d..50dea3b 100644
--- a/include/CommonAPI/DBus/DBusAttribute.hpp
+++ b/include/CommonAPI/DBus/DBusAttribute.hpp
@@ -138,7 +138,7 @@ public:
     						const char *_changedEventName,
     						_AttributeTypeArguments... arguments)
     	 : _AttributeType(_proxy, arguments...),
-    	   changedEvent_(_proxy, _changedEventName, this->setMethodSignature_,
+    	   changedEvent_(_proxy, _changedEventName, this->setMethodSignature_, this->getMethodName_,
     			   	   	 std::make_tuple(CommonAPI::Deployable<ValueType, ValueTypeDepl>(this->depl_))) {
     }
 
diff --git a/include/CommonAPI/DBus/DBusConnection.hpp b/include/CommonAPI/DBus/DBusConnection.hpp
index cce6296..97cb069 100644
--- a/include/CommonAPI/DBus/DBusConnection.hpp
+++ b/include/CommonAPI/DBus/DBusConnection.hpp
@@ -33,7 +33,7 @@ public:
     virtual ~DBusConnectionStatusEvent() {}
 
  protected:
-    virtual void onListenerAdded(const Listener& listener);
+    virtual void onListenerAdded(const Listener& listener, const Subscription subscription);
 
     // TODO: change to std::weak_ptr<DBusConnection> connection_;
     DBusConnection* dbusConnection_;
@@ -130,6 +130,8 @@ public:
 	COMMONAPI_EXPORT bool isDispatchReady();
 	COMMONAPI_EXPORT bool singleDispatch();
 
+	COMMONAPI_EXPORT virtual bool hasDispatchThread();
+
 	typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
 	typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
 	typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
@@ -164,6 +166,8 @@ public:
 	COMMONAPI_EXPORT void initLibdbusObjectPathHandlerAfterConnect();
     ::DBusHandlerResult onLibdbusObjectPathMessage(::DBusMessage* libdbusMessage);
 
+    COMMONAPI_EXPORT static DBusMessage convertToDBusMessage(::DBusPendingCall* _libdbusPendingCall,
+    		CallStatus& _callStatus);
 	COMMONAPI_EXPORT static void onLibdbusPendingCallNotifyThunk(::DBusPendingCall* libdbusPendingCall, void* userData);
 	COMMONAPI_EXPORT static void onLibdbusDataCleanup(void* userData);
 
@@ -242,12 +246,17 @@ public:
     		>
     	> timeoutMap_;
 
-    typedef std::pair<DBusMessageReplyAsyncHandler *, DBusMessage> MainloopTimeout_t;
+    typedef std::tuple<
+    			DBusMessageReplyAsyncHandler *,
+				DBusMessage,
+				CommonAPI::CallStatus,
+				::DBusPendingCall*
+			> MainloopTimeout_t;
     mutable std::list<MainloopTimeout_t> mainloopTimeouts_;
 
     mutable std::mutex enforceTimeoutMutex_;
     mutable std::condition_variable enforceTimeoutCondition_;
-    
+
     mutable std::shared_ptr<std::thread> enforcerThread_;
     mutable std::mutex enforcerThreadMutex_;
     bool enforcerThreadCancelled_;
diff --git a/include/CommonAPI/DBus/DBusDeployment.hpp b/include/CommonAPI/DBus/DBusDeployment.hpp
index 21ad78a..dce9d21 100644
--- a/include/CommonAPI/DBus/DBusDeployment.hpp
+++ b/include/CommonAPI/DBus/DBusDeployment.hpp
@@ -21,16 +21,34 @@ namespace DBus {
 
 template<typename... _Types>
 struct VariantDeployment : CommonAPI::Deployment<_Types...> {
-	VariantDeployment(bool _isFreeDesktop, _Types*... _t)
+	VariantDeployment(bool _isDBus, _Types*... _t)
 		  : CommonAPI::Deployment<_Types...>(_t...),
-			isFreeDesktop_(_isFreeDesktop) {
-	}
+			isDBus_(_isDBus) {};
 
-	bool isFreeDesktop_;
+	bool isDBus_;
 };
 
 extern COMMONAPI_IMPORT_EXPORT VariantDeployment<> freedesktopVariant;
 
+struct StringDeployment : CommonAPI::Deployment<> {
+	StringDeployment(bool _isObjectPath)
+	: isObjectPath_(_isObjectPath) {};
+
+	bool isObjectPath_;
+};
+
+template<typename... _Types>
+struct StructDeployment : CommonAPI::Deployment<_Types...> {
+	StructDeployment(_Types*... t)
+	: CommonAPI::Deployment<_Types...>(t...) {};
+};
+
+template<typename _ElementDepl>
+struct ArrayDeployment : CommonAPI::ArrayDeployment<_ElementDepl> {
+	ArrayDeployment(_ElementDepl *_element)
+	: CommonAPI::ArrayDeployment<_ElementDepl>(_element) {}
+};
+
 } // namespace DBus
 } // namespace CommonAPI
 
diff --git a/include/CommonAPI/DBus/DBusEvent.hpp b/include/CommonAPI/DBus/DBusEvent.hpp
index a3bfe01..3ce945c 100644
--- a/include/CommonAPI/DBus/DBusEvent.hpp
+++ b/include/CommonAPI/DBus/DBusEvent.hpp
@@ -24,6 +24,7 @@ namespace DBus {
 template <typename _Event, typename... _Arguments>
 class DBusEvent: public _Event, public DBusProxyConnection::DBusSignalHandler {
 public:
+	typedef typename _Event::Subscription Subscription;
     typedef typename _Event::Listener Listener;
 
     DBusEvent(DBusProxyBase &_proxy,
@@ -31,6 +32,7 @@ public:
     		  std::tuple<_Arguments...> _arguments)
     	: proxy_(_proxy),
           name_(_name), signature_(_signature),
+		  getMethodName_(""),
           arguments_(_arguments) {
 
         interface_ = proxy_.getDBusAddress().getInterface();
@@ -44,9 +46,25 @@ public:
     	: proxy_(_proxy),
           name_(_name), signature_(_signature),
           path_(_path), interface_(_interface),
+		  getMethodName_(""),
           arguments_(_arguments) {
     }
 
+    DBusEvent(DBusProxyBase &_proxy,
+			  const std::string &_name,
+			  const std::string &_signature,
+			  const std::string &_getMethodName,
+			  std::tuple<_Arguments...> _arguments)
+		: proxy_(_proxy),
+		  name_(_name),
+		  signature_(_signature),
+		  getMethodName_(_getMethodName),
+		  arguments_(_arguments) {
+
+		interface_ = proxy_.getDBusAddress().getInterface();
+		path_ = proxy_.getDBusAddress().getObjectPath();
+	}
+
     virtual ~DBusEvent() {
         proxy_.removeSignalMemberHandler(subscription_, this);
     }
@@ -54,14 +72,29 @@ public:
     virtual void onSignalDBusMessage(const DBusMessage &_message) {
         handleSignalDBusMessage(_message, typename make_sequence<sizeof...(_Arguments)>::type());
     }
+
+    virtual void onInitialValueSignalDBusMessage(const DBusMessage&_message, const uint32_t tag) {
+        handleSignalDBusMessage(tag, _message, typename make_sequence<sizeof...(_Arguments)>::type());
+    }
+
  protected:
-    virtual void onFirstListenerAdded(const Listener&) {
-        subscription_ = proxy_.addSignalMemberHandler(
-        					path_, interface_, name_, signature_, this);
+    virtual void onFirstListenerAdded(const Listener& listener) {
+    	subscription_ = proxy_.addSignalMemberHandler(
+                            path_, interface_, name_, signature_, getMethodName_, this, false);
+    }
+
+    virtual void onListenerAdded(const Listener& listener, const Subscription subscription) {
+		if ("" != getMethodName_) {
+			proxy_.getCurrentValueForSignalListener(getMethodName_, this, subscription);
+		}
     }
 
     virtual void onLastListenerRemoved(const Listener&) {
         proxy_.removeSignalMemberHandler(subscription_, this);
+        std::get<0>(subscription_) = "";
+        std::get<1>(subscription_) = "";
+        std::get<2>(subscription_) = "";
+        std::get<3>(subscription_) = "";
     }
 
     template<int ... _Indices>
@@ -74,12 +107,23 @@ public:
         }
     }
 
+    template<int ... _Indices>
+    inline void handleSignalDBusMessage(const uint32_t tag, const DBusMessage &_message, index_sequence<_Indices...>) {
+        DBusInputStream input(_message);
+        if (DBusSerializableArguments<
+                _Arguments...
+            >::deserialize(input, std::get<_Indices>(arguments_)...)) {
+            this->notifySpecificListener(tag, std::get<_Indices>(arguments_)...);
+        }
+    }
+
     DBusProxyBase &proxy_;
 
     std::string name_;
     std::string signature_;
     std::string path_;
     std::string interface_;
+    std::string getMethodName_;
 
     DBusProxyConnection::DBusSignalHandlerToken subscription_;
     std::tuple<_Arguments...> arguments_;
diff --git a/include/CommonAPI/DBus/DBusFreedesktopAttribute.hpp b/include/CommonAPI/DBus/DBusFreedesktopAttribute.hpp
index dc485cb..fd9237e 100644
--- a/include/CommonAPI/DBus/DBusFreedesktopAttribute.hpp
+++ b/include/CommonAPI/DBus/DBusFreedesktopAttribute.hpp
@@ -15,16 +15,19 @@
 namespace CommonAPI {
 namespace DBus {
 
-template <typename _AttributeType>
+template <typename _AttributeType, typename _AttributeDepl = EmptyDeployment>
 class DBusFreedesktopReadonlyAttribute: public _AttributeType {
 public:
     typedef typename _AttributeType::ValueType ValueType;
+    typedef _AttributeDepl ValueTypeDepl;
     typedef typename _AttributeType::AttributeAsyncCallback AttributeAsyncCallback;
 
-    DBusFreedesktopReadonlyAttribute(DBusProxy &_proxy, const std::string &_interfaceName, const std::string &_propertyName)
+    DBusFreedesktopReadonlyAttribute(DBusProxy &_proxy, const std::string &_interfaceName, const std::string &_propertyName,
+        _AttributeDepl *_depl = nullptr)
     	: proxy_(_proxy),
           interfaceName_(_interfaceName),
-          propertyName_(_propertyName) {
+          propertyName_(_propertyName),
+          depl_(_depl) {
     }
 
     void getValue(CommonAPI::CallStatus &_status, ValueType &_value, const CommonAPI::CallInfo *_info) const {
@@ -78,6 +81,7 @@ protected:
     DBusProxy &proxy_;
     std::string interfaceName_;
     std::string propertyName_;
+    _AttributeDepl *depl_;
 };
 
 template <typename _AttributeType>
@@ -145,16 +149,15 @@ protected:
     std::string propertyName_;
 };
 
-template <typename _AttributeType>
+template <typename _AttributeType, typename _AttributeDepl = EmptyDeployment>
 class DBusFreedesktopAttribute
-		: public DBusFreedesktopReadonlyAttribute<_AttributeType> {
+		: public DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl> {
  public:
     typedef typename _AttributeType::ValueType ValueType;
     typedef typename _AttributeType::AttributeAsyncCallback AttributeAsyncCallback;
-    typedef typename _AttributeType::ChangedEvent ChangedEvent;
 
-    DBusFreedesktopAttribute(DBusProxy &_proxy, const std::string &_interfaceName, const std::string &_propertyName)
-    	: DBusFreedesktopReadonlyAttribute<_AttributeType>(_proxy, _interfaceName, _propertyName) {
+    DBusFreedesktopAttribute(DBusProxy &_proxy, const std::string &_interfaceName, const std::string &_propertyName, _AttributeDepl *_depl = nullptr)
+        : DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>(_proxy, _interfaceName, _propertyName, _depl) {
     }
 
     void setValue(const ValueType &_request, CommonAPI::CallStatus &_status, ValueType &_response, const CommonAPI::CallInfo *_info) {
@@ -166,13 +169,13 @@ class DBusFreedesktopAttribute
             DBusSerializableArguments<
 			>
         >::callMethodWithReply(
-				DBusFreedesktopReadonlyAttribute<_AttributeType>::proxy_,
+				DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::proxy_,
 				"org.freedesktop.DBus.Properties",
 				"Set",
 				"ssv",
 				(_info ? _info : &defaultCallInfo),
-				DBusFreedesktopReadonlyAttribute<_AttributeType>::interfaceName_,
-				DBusFreedesktopReadonlyAttribute<_AttributeType>::propertyName_,
+				DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::interfaceName_,
+				DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::propertyName_,
 				deployedVariant,
 				_status);
         _response = _request;
@@ -187,13 +190,13 @@ class DBusFreedesktopAttribute
                     DBusSerializableArguments<
 					>
         	   >::callMethodAsync(
-					DBusFreedesktopReadonlyAttribute<_AttributeType>::proxy_,
+					DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::proxy_,
 					"org.freedesktop.DBus.Properties",
 					"Set",
 					"ssv",
 					(_info ? _info : &defaultCallInfo),
-					DBusFreedesktopReadonlyAttribute<_AttributeType>::interfaceName_,
-					DBusFreedesktopReadonlyAttribute<_AttributeType>::propertyName_,
+					DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::interfaceName_,
+					DBusFreedesktopReadonlyAttribute<_AttributeType, _AttributeDepl>::propertyName_,
 					deployedVariant,
 					[_callback, deployedVariant](CommonAPI::CallStatus _status) {
         				_callback(_status, deployedVariant.getValue().template get<ValueType>());
diff --git a/include/CommonAPI/DBus/DBusFreedesktopStubAdapterHelper.hpp b/include/CommonAPI/DBus/DBusFreedesktopStubAdapterHelper.hpp
index 5c0bffa..bfe2493 100644
--- a/include/CommonAPI/DBus/DBusFreedesktopStubAdapterHelper.hpp
+++ b/include/CommonAPI/DBus/DBusFreedesktopStubAdapterHelper.hpp
@@ -26,16 +26,16 @@ public:
 												   const std::shared_ptr<DBusClientId> &_clientId) = 0;
 };
 
-template <typename _StubClass, typename _AttributeType>
+template <typename _StubClass, typename _AttributeType, typename _AttributeDepl = EmptyDeployment>
 class DBusGetFreedesktopAttributeStubDispatcher
-		: public virtual DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>,
+		: public virtual DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>,
 		  public virtual DBusGetFreedesktopAttributeStubDispatcherBase<_StubClass> {
 public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
-    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::GetStubFunctor GetStubFunctor;
+    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::GetStubFunctor GetStubFunctor;
 
-    DBusGetFreedesktopAttributeStubDispatcher(GetStubFunctor _getStubFunctor)
-    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, "v") {
+    DBusGetFreedesktopAttributeStubDispatcher(GetStubFunctor _getStubFunctor, _AttributeDepl *_depl = nullptr)
+    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, "v", _depl) {
     }
 
     virtual ~DBusGetFreedesktopAttributeStubDispatcher() {};
@@ -45,18 +45,19 @@ public:
 										   DBusOutputStream &_output,
 										   const std::shared_ptr<DBusClientId> &_clientId) {
     	CommonAPI::Deployable<CommonAPI::Variant<_AttributeType>, VariantDeployment<>> deployedVariant(
-        		(_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::getStubFunctor_))(_clientId), &freedesktopVariant);
+        		(_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::getStubFunctor_))(_clientId), &freedesktopVariant);
 
         _output << deployedVariant;
     }
 
 protected:
    virtual bool sendAttributeValueReply(const DBusMessage &_message, const std::shared_ptr<_StubClass> &_stub, DBusStubAdapterHelperType &_helper) {
-       DBusMessage reply = _message.createMethodReturn(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::signature_);
+       DBusMessage reply = _message.createMethodReturn(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::signature_);
 
+       VariantDeployment<_AttributeDepl> actualDepl(true, DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::depl_);
        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(_message.getSender()));
-       CommonAPI::Deployable<CommonAPI::Variant<_AttributeType>, VariantDeployment<>> deployedVariant(
-    		   (_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::getStubFunctor_))(clientId), &freedesktopVariant);
+       CommonAPI::Deployable<CommonAPI::Variant<_AttributeType>, VariantDeployment<_AttributeDepl>> deployedVariant(
+                (_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::getStubFunctor_))(clientId), &actualDepl);
 
        DBusOutputStream output(reply);
        output << deployedVariant;
@@ -66,13 +67,13 @@ protected:
    }
 };
 
-template <typename _StubClass, typename _AttributeType>
+template <typename _StubClass, typename _AttributeType, typename _AttributeDepl = EmptyDeployment>
 class DBusSetFreedesktopAttributeStubDispatcher
-		: public virtual DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>,
-		  public virtual DBusSetAttributeStubDispatcher<_StubClass, _AttributeType> {
+		: public virtual DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>,
+		  public virtual DBusSetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl> {
 public:
-    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::GetStubFunctor GetStubFunctor;
-    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::DBusStubAdapterHelperType DBusStubAdapterHelperType;
+    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::GetStubFunctor GetStubFunctor;
+    typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::DBusStubAdapterHelperType DBusStubAdapterHelperType;
     typedef typename DBusStubAdapterHelperType::RemoteEventHandlerType RemoteEventHandlerType;
     typedef bool (RemoteEventHandlerType::*OnRemoteSetFunctor)(std::shared_ptr<CommonAPI::ClientId>, _AttributeType);
     typedef void (RemoteEventHandlerType::*OnRemoteChangedFunctor)();
@@ -80,16 +81,17 @@ public:
     DBusSetFreedesktopAttributeStubDispatcher(
     		GetStubFunctor _getStubFunctor,
 			OnRemoteSetFunctor _onRemoteSetFunctor,
-            OnRemoteChangedFunctor _onRemoteChangedFunctor)
-    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, "v"),
-          DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor),
-          DBusSetAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, "v") {
+            OnRemoteChangedFunctor _onRemoteChangedFunctor,
+            _AttributeDepl * _depl = nullptr)
+    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, "v", _depl),
+          DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _depl),
+          DBusSetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, "v", _depl) {
     }
 
     virtual ~DBusSetFreedesktopAttributeStubDispatcher() {};
 
 protected:
-    virtual _AttributeType retreiveAttributeValue(const DBusMessage &_message, bool &_error) {
+    virtual _AttributeType retrieveAttributeValue(const DBusMessage &_message, bool &_error) {
         std::string interfaceName, attributeName;
         DBusInputStream input(_message);
         CommonAPI::Deployable<CommonAPI::Variant<_AttributeType>, VariantDeployment<>> deployedVariant(&freedesktopVariant);
@@ -102,28 +104,29 @@ protected:
     }
 };
 
-template <typename _StubClass, typename _AttributeType>
+template <typename _StubClass, typename _AttributeType, typename _AttributeDepl = EmptyDeployment>
 class DBusSetFreedesktopObservableAttributeStubDispatcher
-		: public virtual DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>,
-		  public virtual DBusSetObservableAttributeStubDispatcher<_StubClass, _AttributeType> {
+		: public virtual DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>,
+		  public virtual DBusSetObservableAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl> {
 public:
-    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>::DBusStubAdapterHelperType DBusStubAdapterHelperType;
+    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::DBusStubAdapterHelperType DBusStubAdapterHelperType;
     typedef typename DBusStubAdapterHelperType::StubAdapterType StubAdapterType;
-    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>::GetStubFunctor GetStubFunctor;
-    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>::OnRemoteSetFunctor OnRemoteSetFunctor;
-    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>::OnRemoteChangedFunctor OnRemoteChangedFunctor;
+    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::GetStubFunctor GetStubFunctor;
+    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::OnRemoteSetFunctor OnRemoteSetFunctor;
+    typedef typename DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::OnRemoteChangedFunctor OnRemoteChangedFunctor;
     typedef void (StubAdapterType::*FireChangedFunctor)(const _AttributeType&);
 
     DBusSetFreedesktopObservableAttributeStubDispatcher(
     		GetStubFunctor _getStubFunctor,
             OnRemoteSetFunctor _onRemoteSetFunctor,
             OnRemoteChangedFunctor _onRemoteChangedFunctor,
-            FireChangedFunctor _fireChangedFunctor)
-    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, "v"),
-          DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor),
-          DBusSetAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, "v"),
-          DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor),
-          DBusSetObservableAttributeStubDispatcher<_StubClass, _AttributeType>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, _fireChangedFunctor, "v") {
+            FireChangedFunctor _fireChangedFunctor,
+            _AttributeDepl *_depl = nullptr)
+    	: DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, "v", _depl),
+          DBusGetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _depl),
+          DBusSetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, "v", _depl),
+          DBusSetFreedesktopAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, _depl),
+          DBusSetObservableAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>(_getStubFunctor, _onRemoteSetFunctor, _onRemoteChangedFunctor, _fireChangedFunctor, "v", _depl) {
     }
 };
 
diff --git a/include/CommonAPI/DBus/DBusInputStream.hpp b/include/CommonAPI/DBus/DBusInputStream.hpp
index 389cb68..4f00cec 100644
--- a/include/CommonAPI/DBus/DBusInputStream.hpp
+++ b/include/CommonAPI/DBus/DBusInputStream.hpp
@@ -65,8 +65,38 @@ public:
 
 	COMMONAPI_EXPORT InputStream &readValue(std::string &_value, const EmptyDeployment *_depl);
 
+        COMMONAPI_EXPORT InputStream &readValue(std::string &_value, const CommonAPI::DBus::StringDeployment* _depl) {
+            return readValue(_value, static_cast<EmptyDeployment *>(nullptr));
+        }
+
 	COMMONAPI_EXPORT InputStream &readValue(Version &_value, const EmptyDeployment *_depl);
 
+	COMMONAPI_EXPORT void beginReadMapOfSerializableStructs() {
+		uint32_t itsSize;
+		_readValue(itsSize);
+		pushSize(itsSize);
+		align(8); /* correct alignment for first DICT_ENTRY */
+		pushPosition();
+	}
+
+	COMMONAPI_EXPORT bool readMapCompleted() {
+		return (sizes_.top() <= (current_ - positions_.top()));
+	}
+
+	COMMONAPI_EXPORT void endReadMapOfSerializableStructs() {
+		(void)popSize();
+		(void)popPosition();
+	}
+
+	COMMONAPI_EXPORT InputStream &skipMap() {
+		uint32_t itsSize;
+		_readValue(itsSize);
+		align(8); /* skip padding (if any) */
+		assert(itsSize <= (sizes_.top() + positions_.top() - current_));
+		_readRaw(itsSize);
+		return (*this);
+	}
+
     template<class _Deployment, typename _Base>
 	COMMONAPI_EXPORT InputStream &readValue(Enumeration<_Base> &_value, const _Deployment *_depl) {
     	_Base tmpValue;
@@ -127,7 +157,7 @@ public:
     			Variant<_Types...>, _Types... >::visit(visitor, _value);
     	}
 
-    	if (_depl != nullptr && _depl->isFreeDesktop_) {
+    	if (_depl != nullptr && _depl->isDBus_) {
 			// Read signature
 			uint8_t signatureLength;
 			readValue(signatureLength, static_cast<EmptyDeployment *>(nullptr));
@@ -195,7 +225,7 @@ public:
     	_value.clear();
     	while (sizes_.top() > current_ - positions_.top()) {
     		_ElementType itsElement;
-    		readValue(itsElement, _depl->elementDepl_);
+    		readValue(itsElement, (_depl ? _depl->elementDepl_ : nullptr));
 
     		if (hasError()) {
     			break;
@@ -264,8 +294,8 @@ public:
     		_ValueType itsValue;
 
     		align(8);
-    		readValue(itsKey, _depl->key_);
-    		readValue(itsValue, _depl->value_);
+    		readValue(itsKey, (_depl ? _depl->key_ : nullptr));
+    		readValue(itsValue, (_depl ? _depl->value_ : nullptr));
 
     		if (hasError()) {
     			break;
diff --git a/include/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.hpp b/include/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.hpp
index d520034..0f3dd24 100644
--- a/include/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.hpp
+++ b/include/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.hpp
@@ -55,14 +55,16 @@ class DBusInstanceAvailabilityStatusChangedEvent:
                         DBusObjectManagerStub::getInterfaceName(),
                         "InterfacesAdded",
                         "oa{sa{sv}}",
-                        this);
+                        this,
+                        false);
 
         interfacesRemovedSubscription_ = proxy_.addSignalMemberHandler(
         				proxy_.getDBusAddress().getObjectPath(),
                         DBusObjectManagerStub::getInterfaceName(),
                         "InterfacesRemoved",
                         "oas",
-                        this);
+                        this,
+                        false);
     }
 
     virtual void onLastListenerRemoved(const Listener&) {
@@ -74,21 +76,23 @@ class DBusInstanceAvailabilityStatusChangedEvent:
     inline void onInterfacesAddedSignal(const DBusMessage &_message) {
         DBusInputStream dbusInputStream(_message);
         std::string dbusObjectPath;
+        std::string dbusInterfaceName;
         DBusInterfacesAndPropertiesDict dbusInterfacesAndPropertiesDict;
 
         dbusInputStream >> dbusObjectPath;
         assert(!dbusInputStream.hasError());
 
-        dbusInputStream >> dbusInterfacesAndPropertiesDict;
-        assert(!dbusInputStream.hasError());
-
-        for (const auto& dbusInterfaceIterator : dbusInterfacesAndPropertiesDict) {
-            const std::string& dbusInterfaceName = dbusInterfaceIterator.first;
-
+        dbusInputStream.beginReadMapOfSerializableStructs();
+        while (!dbusInputStream.readMapCompleted()) {
+            dbusInputStream.align(8);
+            dbusInputStream >> dbusInterfaceName;
+            dbusInputStream.skipMap();
+            assert(!dbusInputStream.hasError());
             if(dbusInterfaceName == observedInterfaceName_) {
                 notifyInterfaceStatusChanged(dbusObjectPath, dbusInterfaceName, AvailabilityStatus::AVAILABLE);
             }
         }
+        dbusInputStream.endReadMapOfSerializableStructs();
     }
 
     inline void onInterfacesRemovedSignal(const DBusMessage &_message) {
diff --git a/include/CommonAPI/DBus/DBusMainLoopContext.hpp b/include/CommonAPI/DBus/DBusMainLoopContext.hpp
index 9230cd2..27428db 100644
--- a/include/CommonAPI/DBus/DBusMainLoopContext.hpp
+++ b/include/CommonAPI/DBus/DBusMainLoopContext.hpp
@@ -47,6 +47,10 @@ class DBusWatch: public Watch {
 
     const pollfd& getAssociatedFileDescriptor();
 
+#ifdef WIN32
+	const HANDLE& getAssociatedEvent();
+#endif
+
     const std::vector<DispatchSource*>& getDependentDispatchSources();
     void addDependentDispatchSource(DispatchSource* dispatchSource);
  private:
@@ -57,6 +61,10 @@ class DBusWatch: public Watch {
     std::vector<DispatchSource*> dependentDispatchSources_;
 
     std::weak_ptr<MainLoopContext> mainLoopContext_;
+
+#ifdef WIN32
+	HANDLE wsaEvent_;
+#endif
 };
 
 
diff --git a/include/CommonAPI/DBus/DBusOutputStream.hpp b/include/CommonAPI/DBus/DBusOutputStream.hpp
index b0bdd22..93afca2 100644
--- a/include/CommonAPI/DBus/DBusOutputStream.hpp
+++ b/include/CommonAPI/DBus/DBusOutputStream.hpp
@@ -111,6 +111,10 @@ public:
         return writeString(_value.c_str(), _value.length());
     }
 
+	COMMONAPI_EXPORT OutputStream &writeValue(const std::string &_value, const CommonAPI::DBus::StringDeployment* _depl) {
+        return writeString(_value.c_str(), _value.length());
+    }
+
 	COMMONAPI_EXPORT OutputStream &writeValue(const Version &_value, const EmptyDeployment *_depl = nullptr) {
     	align(8);
     	writeValue(_value.Major, _depl);
@@ -168,7 +172,7 @@ public:
 
     template<typename _Deployment, typename... _Types>
 	COMMONAPI_EXPORT OutputStream &writeValue(const Variant<_Types...> &_value, const _Deployment *_depl = nullptr) {
-    	if (_depl != nullptr && _depl->isFreeDesktop_) {
+    	if (_depl != nullptr && _depl->isDBus_) {
     		align(1);
     	} else {
     		align(8);
@@ -223,7 +227,7 @@ public:
     	pushPosition(); // Start of vector data
 
     	for (auto i : _value) {
-    		writeValue(i, _depl->elementDepl_);
+    		writeValue(i, (_depl ? _depl->elementDepl_ : nullptr));
     		if (hasError()) {
     			break;
     		}
@@ -274,8 +278,8 @@ public:
 
     	for (auto v : _value) {
     		align(8);
-    		writeValue(v.first, _depl->key_);
-    		writeValue(v.second, _depl->value_);
+    		writeValue(v.first, (_depl ? _depl->key_ : nullptr));
+    		writeValue(v.second, (_depl ? _depl->value_ : nullptr));
 
     		if (hasError()) {
     			return (*this);
@@ -289,6 +293,15 @@ public:
     }
 
     /**
+     * Fills the stream with 0-bytes to make the next value be aligned to the boundary given.
+     * This means that as many 0-bytes are written to the buffer as are necessary
+     * to make the next value start with the given alignment.
+     *
+     * @param alignBoundary The byte-boundary to which the next value should be aligned.
+     */
+    COMMONAPI_EXPORT void align(const size_t _boundary);
+
+    /**
      * Writes the data that was buffered within this #DBusOutputMessageStream to the #DBusMessage that was given to the constructor. Each call to flush()
      * will completely override the data that currently is contained in the #DBusMessage. The data that is buffered in this #DBusOutputMessageStream is
      * not deleted by calling flush().
@@ -297,6 +310,22 @@ public:
 
 	COMMONAPI_EXPORT bool hasError() const;
 
+	// Helper for serializing Freedesktop properties
+    COMMONAPI_EXPORT void beginWriteMap() {
+        align(sizeof(uint32_t));
+        pushPosition();
+        _writeValue(static_cast<uint32_t>(0)); // Placeholder
+
+        align(8);
+        pushPosition(); // Start of map data
+    }
+
+    COMMONAPI_EXPORT void endWriteMap() {
+        // Write number of written bytes to placeholder position
+        const uint32_t length = getPosition() - popPosition();
+        _writeValueAt(popPosition(), length);
+    }
+
 private:
 	COMMONAPI_EXPORT size_t getPosition();
 	COMMONAPI_EXPORT void pushPosition();
@@ -361,15 +390,6 @@ private:
 	COMMONAPI_EXPORT DBusOutputStream &writeString(const char *_data, const uint32_t &_length);
 
     /**
-     * Fills the stream with 0-bytes to make the next value be aligned to the boundary given.
-     * This means that as many 0-bytes are written to the buffer as are necessary
-     * to make the next value start with the given alignment.
-     *
-     * @param alignBoundary The byte-boundary to which the next value should be aligned.
-     */
-	COMMONAPI_EXPORT void align(const size_t _boundary);
-
-    /**
      * Takes sizeInByte characters, starting from the character which val points to, and stores them for later writing.
      * When calling flush(), all values that were written to this stream are copied into the payload of the #DBusMessage.
      *
diff --git a/include/CommonAPI/DBus/DBusProxy.hpp b/include/CommonAPI/DBus/DBusProxy.hpp
index 058a681..2f8a89c 100644
--- a/include/CommonAPI/DBus/DBusProxy.hpp
+++ b/include/CommonAPI/DBus/DBusProxy.hpp
@@ -30,7 +30,7 @@ class DBusProxyStatusEvent
     virtual ~DBusProxyStatusEvent() {}
 
  protected:
-    virtual void onListenerAdded(const Listener& listener);
+    virtual void onListenerAdded(const Listener& listener, const Subscription subscription);
 
     DBusProxy* dbusProxy_;
 };
@@ -62,14 +62,61 @@ public:
 
 	COMMONAPI_EXPORT void init();
 
+	COMMONAPI_EXPORT virtual DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
+            const std::string &objectPath,
+            const std::string &interfaceName,
+            const std::string &signalName,
+            const std::string &signalSignature,
+            DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+            const bool justAddFilter);
+
+	COMMONAPI_EXPORT virtual DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
+            const std::string &objectPath,
+            const std::string &interfaceName,
+            const std::string &signalName,
+            const std::string &signalSignature,
+			const std::string &getMethodName,
+            DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+            const bool justAddFilter);
+
+	COMMONAPI_EXPORT virtual bool removeSignalMemberHandler(
+    		const DBusProxyConnection::DBusSignalHandlerToken &_dbusSignalHandlerToken,
+    		const DBusProxyConnection::DBusSignalHandler *_dbusSignalHandler = NULL);
+
+	COMMONAPI_EXPORT virtual void getCurrentValueForSignalListener(
+            const std::string &getMethodName,
+            DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+			const uint32_t subscription);
+
 private:
+    typedef std::tuple<
+		const std::string,
+		const std::string,
+		const std::string,
+		const std::string,
+		const std::string,
+		DBusProxyConnection::DBusSignalHandler*,
+		const bool,
+		bool
+		> SignalMemberHandlerTuple;
+
 	COMMONAPI_EXPORT DBusProxy(const DBusProxy &) = delete;
 
 	COMMONAPI_EXPORT void onDBusServiceInstanceStatus(const AvailabilityStatus& availabilityStatus);
+	COMMONAPI_EXPORT void signalMemberCallback(const CallStatus dbusMessageCallStatus,
+			const DBusMessage& dbusMessage,
+			DBusProxyConnection::DBusSignalHandler* dbusSignalHandlers,
+			const uint32_t tag);
+	COMMONAPI_EXPORT void signalInitialValueCallback(const CallStatus dbusMessageCallStatus,
+			const DBusMessage& dbusMessage,
+			DBusProxyConnection::DBusSignalHandler* dbusSignalHandlers,
+			const uint32_t tag);
+	COMMONAPI_EXPORT void addSignalMemberHandlerToQueue(SignalMemberHandlerTuple& _signalMemberHandler);
 
     DBusProxyStatusEvent dbusProxyStatusEvent_;
     DBusServiceRegistry::DBusServiceSubscription dbusServiceRegistrySubscription_;
     AvailabilityStatus availabilityStatus_;
+    mutable std::mutex availabilityStatusMutex_;
 
     DBusReadonlyAttribute<InterfaceVersionAttribute> interfaceVersionAttribute_;
 
@@ -77,6 +124,10 @@ private:
 
     mutable std::mutex availabilityMutex_;
     mutable std::condition_variable availabilityCondition_;
+
+    std::list<SignalMemberHandlerTuple> signalMemberHandlerQueue_;
+    CallInfo signalMemberHandlerInfo_;
+    mutable std::mutex signalMemberHandlerQueueMutex_;
 };
 
 
diff --git a/include/CommonAPI/DBus/DBusProxyAsyncSignalMemberCallbackHandler.hpp b/include/CommonAPI/DBus/DBusProxyAsyncSignalMemberCallbackHandler.hpp
new file mode 100644
index 0000000..9c706ca
--- /dev/null
+++ b/include/CommonAPI/DBus/DBusProxyAsyncSignalMemberCallbackHandler.hpp
@@ -0,0 +1,68 @@
+// Copyright (C) 2015 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#error "Only <CommonAPI/CommonAPI.hpp> can be included directly, this file may disappear or change contents."
+#endif
+
+#ifndef COMMONAPI_DBUS_DBUSPROXYASYNCSIGNALMEMBERCALLBACKHANDLER_HPP_
+#define COMMONAPI_DBUS_DBUSPROXYASYNCSIGNALMEMBERCALLBACKHANDLER_HPP_
+
+#include <functional>
+#include <future>
+#include <memory>
+
+//#include <CommonAPI/DBus/DBusHelper.hpp>
+#include <CommonAPI/DBus/DBusMessage.hpp>
+#include <CommonAPI/DBus/DBusProxyConnection.hpp>
+
+namespace CommonAPI {
+namespace DBus {
+
+class DBusProxyAsyncSignalMemberCallbackHandler: public DBusProxyConnection::DBusMessageReplyAsyncHandler {
+ public:
+	typedef std::function<void(CallStatus, DBusMessage, DBusProxyConnection::DBusSignalHandler*, int)> FunctionType;
+
+    static std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler> create(
+			FunctionType& callback, DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+			const int tag) {
+		return std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler>(
+				new DBusProxyAsyncSignalMemberCallbackHandler(std::move(callback), dbusSignalHandler, tag));
+	}
+
+    DBusProxyAsyncSignalMemberCallbackHandler() = delete;
+    DBusProxyAsyncSignalMemberCallbackHandler(FunctionType&& callback,
+    		DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+			const int tag):
+		callback_(std::move(callback)), dbusSignalHandler_(dbusSignalHandler), tag_(tag) {
+	}
+    virtual ~DBusProxyAsyncSignalMemberCallbackHandler() {}
+
+    virtual std::future<CallStatus> getFuture() {
+        return promise_.get_future();
+    }
+
+    virtual void onDBusMessageReply(const CallStatus& dbusMessageCallStatus, const DBusMessage& dbusMessage) {
+    	promise_.set_value(handleDBusMessageReply(dbusMessageCallStatus, dbusMessage));
+    }
+
+ private:
+    inline CallStatus handleDBusMessageReply(const CallStatus dbusMessageCallStatus, const DBusMessage& dbusMessage) const {
+        CallStatus callStatus = dbusMessageCallStatus;
+
+        callback_(callStatus, dbusMessage, dbusSignalHandler_, tag_);
+        return callStatus;
+    }
+
+    std::promise<CallStatus> promise_;
+    const FunctionType callback_;
+    DBusProxyConnection::DBusSignalHandler* dbusSignalHandler_;
+    const int tag_;
+};
+
+} // namespace DBus
+} // namespace CommonAPI
+
+#endif // COMMONAPI_DBUS_DBUSPROXYASYNCSIGNALMEMBERCALLBACKHANDLER_HPP_
diff --git a/include/CommonAPI/DBus/DBusProxyBase.hpp b/include/CommonAPI/DBus/DBusProxyBase.hpp
index 85c746c..970035f 100644
--- a/include/CommonAPI/DBus/DBusProxyBase.hpp
+++ b/include/CommonAPI/DBus/DBusProxyBase.hpp
@@ -39,27 +39,35 @@ public:
 	COMMONAPI_EXPORT DBusMessage createMethodCall(const std::string &_method,
                                  const std::string &_signature = "") const;
 
-	COMMONAPI_EXPORT DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
-            const std::string& signalName,
-            const std::string& signalSignature,
-            DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
-            const bool justAddFilter = false);
+	COMMONAPI_EXPORT virtual DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
+            const std::string &objectPath,
+            const std::string &interfaceName,
+            const std::string &signalName,
+            const std::string &signalSignature,
+            DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+            const bool justAddFilter);
 
-	COMMONAPI_EXPORT DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
+	COMMONAPI_EXPORT virtual DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
             const std::string &objectPath,
             const std::string &interfaceName,
             const std::string &signalName,
             const std::string &signalSignature,
+            const std::string &getMethodName,
             DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
-            const bool justAddFilter = false);
+            const bool justAddFilter);
+
+	COMMONAPI_EXPORT virtual bool removeSignalMemberHandler(
+    		const DBusProxyConnection::DBusSignalHandlerToken &_dbusSignalHandlerToken,
+    		const DBusProxyConnection::DBusSignalHandler *_dbusSignalHandler = NULL);
 
-	COMMONAPI_EXPORT bool removeSignalMemberHandler(
-    		const DBusProxyConnection::DBusSignalHandlerToken &_token,
-    		const DBusProxyConnection::DBusSignalHandler *_handler = NULL);
+	COMMONAPI_EXPORT virtual void getCurrentValueForSignalListener(
+            const std::string &getMethodName,
+            DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+            const uint32_t subscription) {}
 
 	COMMONAPI_EXPORT virtual void init() = 0;
 
- private:
+ protected:
 	COMMONAPI_EXPORT DBusProxyBase(const DBusProxyBase &) = delete;
 
     DBusAddress dbusAddress_;
diff --git a/include/CommonAPI/DBus/DBusProxyConnection.hpp b/include/CommonAPI/DBus/DBusProxyConnection.hpp
index cbef54d..10c2ea4 100644
--- a/include/CommonAPI/DBus/DBusProxyConnection.hpp
+++ b/include/CommonAPI/DBus/DBusProxyConnection.hpp
@@ -51,6 +51,7 @@ class DBusProxyConnection {
      public:
         virtual ~DBusSignalHandler() {}
         virtual void onSignalDBusMessage(const DBusMessage&) = 0;
+        virtual void onInitialValueSignalDBusMessage(const DBusMessage&, const uint32_t) {};
     };
 
     // objectPath, interfaceName, interfaceMemberName, interfaceMemberSignature
@@ -119,6 +120,8 @@ class DBusProxyConnection {
 
     virtual void setObjectPathMessageHandler(DBusObjectPathMessageHandler) = 0;
     virtual bool isObjectPathMessageHandlerSet() = 0;
+
+    virtual bool hasDispatchThread() = 0;
 };
 
 } // namespace DBus
diff --git a/include/CommonAPI/DBus/DBusProxyHelper.hpp b/include/CommonAPI/DBus/DBusProxyHelper.hpp
index 516d923..4a2748b 100644
--- a/include/CommonAPI/DBus/DBusProxyHelper.hpp
+++ b/include/CommonAPI/DBus/DBusProxyHelper.hpp
@@ -43,11 +43,11 @@ struct DBusProxyHelper<_In<DBusInputStream, DBusOutputStream, _InArgs...>,
 						   const _InArgs&... _in,
 						   CommonAPI::CallStatus &_status) {
 
-		if (_proxy.isAvailableBlocking()) {
+		if (_proxy.isAvailable()) {
 			DBusMessage message = _proxy.createMethodCall(_method, _signature);
 			if (sizeof...(_InArgs) > 0) {
 				DBusOutputStream output(message);
-				if (DBusSerializableArguments<_InArgs...>::serialize(output, _in...)) {
+				if (!DBusSerializableArguments<_InArgs...>::serialize(output, _in...)) {
 					_status = CallStatus::OUT_OF_MEMORY;
 					return;
 				}
@@ -106,7 +106,7 @@ struct DBusProxyHelper<_In<DBusInputStream, DBusOutputStream, _InArgs...>,
                 const _InArgs&... _in,
                 CommonAPI::CallStatus &_status,
                 _OutArgs&... _out) {
-        if (_proxy.isAvailableBlocking()) {
+        if (_proxy.isAvailable()) {
             DBusMessage message = DBusMessage::createMethodCall(_address, _method, _signature);
             callMethodWithReply(_proxy, message, _info, _in..., _status, _out...);
         } else {
@@ -142,7 +142,7 @@ struct DBusProxyHelper<_In<DBusInputStream, DBusOutputStream, _InArgs...>,
                     const _InArgs&... _in,
                     CommonAPI::CallStatus &_status,
                     _OutArgs&... _out) {
-        if (_proxy.isAvailableBlocking()) {
+        if (_proxy.isAvailable()) {
             DBusMessage message = _proxy.createMethodCall(_method, _signature);
             callMethodWithReply(_proxy, message, _info, _in..., _status, _out...);
         } else {
diff --git a/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp b/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
index 730a5c7..90efba5 100644
--- a/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
+++ b/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
@@ -193,7 +193,7 @@ class DBusStubAdapterHelper: public virtual DBusStubAdapter {
         DBusMessage dbusMessageReply = dbusMessage.createMethodReturn("a{sv}");
         DBusOutputStream dbusOutputStream(dbusMessageReply);
 
-        dbusOutputStream.beginWriteVectorOfSerializableStructs();
+        dbusOutputStream.beginWriteMap();
 
         std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSender()));
         for(auto attributeDispatcherIterator = getStubAttributeTable().begin(); attributeDispatcherIterator != getStubAttributeTable().end(); attributeDispatcherIterator++) {
@@ -202,12 +202,13 @@ class DBusStubAdapterHelper: public virtual DBusStubAdapter {
             if (stub_) {
                 StubDispatcher* getterDispatcher = static_cast<StubDispatcher*>(attributeDispatcherIterator->second.getter);
                 assert(getterDispatcher != NULL); // all attributes have at least a getter
+                dbusOutputStream.align(8);
                 dbusOutputStream << attributeDispatcherIterator->first;
                 getterDispatcher->appendGetAllReply(dbusMessage, stub_, *this, dbusOutputStream);
             }
         }
 
-        dbusOutputStream.endWriteVector();
+        dbusOutputStream.endWriteMap();
         dbusOutputStream.flush();
 
         return getDBusConnection()->sendDBusMessage(dbusMessageReply);
@@ -287,59 +288,75 @@ struct DBusStubSignalHelper<_In<DBusInputStream, DBusOutputStream, _InArgs...>>
        }
 };
 
-template< class, class >
+template< class, class, class >
 class DBusMethodStubDispatcher;
 
 template <
     typename _StubClass,
-    template <class...> class _In, class... _InArgs>
-class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
+    template <class...> class _In, class... _InArgs,
+    template <class...> class _DeplIn, class... _DeplInArgs>
+
+class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...>, _DeplIn<_DeplInArgs...> >: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
  public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
     typedef void (_StubClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs...);
 
-    DBusMethodStubDispatcher(_StubFunctor stubFunctor):
+    DBusMethodStubDispatcher(_StubFunctor stubFunctor, std::tuple<_DeplInArgs*...> _in):
             stubFunctor_(stubFunctor) {
+            initialize(typename make_sequence_range<sizeof...(_DeplInArgs), 0>::type(), _in);
     }
 
     bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
-        return handleDBusMessage(dbusMessage, stub, dbusStubAdapterHelper, typename make_sequence<sizeof...(_InArgs)>::type());
+		return handleDBusMessage(dbusMessage, stub, dbusStubAdapterHelper, typename make_sequence_range<sizeof...(_InArgs), 0>::type());
     }
 
  private:
+    template <int... _DeplInArgIndices>
+    inline void initialize(index_sequence<_DeplInArgIndices...>, std::tuple<_DeplInArgs*...> &_in) {
+	in_ = std::make_tuple(std::get<_DeplInArgIndices>(_in)...);
+    }
+
     template <int... _InArgIndices>
     inline bool handleDBusMessage(const DBusMessage& dbusMessage,
                                   const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
-                                  index_sequence<_InArgIndices...>) const {
-        std::tuple<_InArgs...> argTuple;
+                                  index_sequence<_InArgIndices...>) {
 
         if (sizeof...(_InArgs) > 0) {
             DBusInputStream dbusInputStream(dbusMessage);
-            const bool success = DBusSerializableArguments<_InArgs...>::deserialize(dbusInputStream, std::get<_InArgIndices>(argTuple)...);
+            const bool success = DBusSerializableArguments<CommonAPI::Deployable<_InArgs, _DeplInArgs>...>::deserialize(dbusInputStream, std::get<_InArgIndices>(in_)...);
             if (!success)
                 return false;
         }
 
         std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSender()));
 
-        (stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))...);
+        (stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(in_).getValue())...);
 
         return true;
     }
 
     _StubFunctor stubFunctor_;
+    std::tuple<CommonAPI::Deployable<_InArgs, _DeplInArgs>...> in_;
 };
 
 
-template< class, class, class>
+template< class, class, class, class, class>
 class DBusMethodWithReplyStubDispatcher;
 
 template <
     typename _StubClass,
     template <class...> class _In, class... _InArgs,
-    template <class...> class _Out, class... _OutArgs>
-class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutArgs...> >:
+    template <class...> class _Out, class... _OutArgs,
+    template <class...> class _DeplIn, class... _DeplInArgs,
+    template <class...> class _DeplOut, class... _DeplOutArgs>
+
+class DBusMethodWithReplyStubDispatcher<
+       _StubClass, 
+       _In<_InArgs...>,
+       _Out<_OutArgs...>,
+       _DeplIn<_DeplInArgs...>,
+       _DeplOut<_DeplOutArgs...> >:
             public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
  public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
@@ -347,38 +364,53 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
     typedef void (_StubClass::*_StubFunctor)(
         		std::shared_ptr<CommonAPI::ClientId>, _InArgs..., ReplyType_t);
 
-    DBusMethodWithReplyStubDispatcher(_StubFunctor stubFunctor, const char* dbusReplySignature, std::tuple<_InArgs..., _OutArgs...> _args):
+    DBusMethodWithReplyStubDispatcher(_StubFunctor stubFunctor,
+        const char* dbusReplySignature, 
+        std::tuple<_DeplInArgs*...> _inDepArgs,
+        std::tuple<_DeplOutArgs*...> _outDepArgs):
             stubFunctor_(stubFunctor),
             dbusReplySignature_(dbusReplySignature),
-            args_(_args),
-			currentCall_(0) {
+            out_(_outDepArgs),
+            currentCall_(0) {
+
+    	initialize(typename make_sequence_range<sizeof...(_DeplInArgs), 0>::type(), _inDepArgs);
+
     }
 
-    bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
+    bool dispatchDBusMessage(const DBusMessage& dbusMessage, 
+                             const std::shared_ptr<_StubClass>& stub, 
+                             DBusStubAdapterHelperType& dbusStubAdapterHelper) {
     	connection_ = dbusStubAdapterHelper.getDBusConnection();
         return handleDBusMessage(
                         dbusMessage,
                         stub,
                         dbusStubAdapterHelper,
                         typename make_sequence_range<sizeof...(_InArgs), 0>::type(),
-                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type(), args_);
+                        typename make_sequence_range<sizeof...(_OutArgs), 0>::type());
     }
 
-	bool sendReply(CommonAPI::CallId_t _call, std::tuple<_OutArgs...> args = std::make_tuple()) {
+	bool sendReply(CommonAPI::CallId_t _call, 
+                       std::tuple<CommonAPI::Deployable<_OutArgs, _DeplOutArgs>...> args = std::make_tuple()) {
 		return sendReplyInternal(_call, typename make_sequence_range<sizeof...(_OutArgs), 0>::type(), args);
 	}
 
 private:
+
+	template <int... _DeplInArgIndices>
+	inline void initialize(index_sequence<_DeplInArgIndices...>, std::tuple<_DeplInArgs*...> &_in) {
+		in_ = std::make_tuple(std::get<_DeplInArgIndices>(_in)...);
+	}
+
+
     template <int... _InArgIndices, int... _OutArgIndices>
     inline bool handleDBusMessage(const DBusMessage& dbusMessage,
                                   const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
                                   index_sequence<_InArgIndices...>,
-                                  index_sequence<_OutArgIndices...>,
-                                  std::tuple<_InArgs..., _OutArgs...> argTuple) {
-        if (sizeof...(_InArgs) > 0) {
+                                  index_sequence<_OutArgIndices...>) {
+        if (sizeof...(_DeplInArgs) > 0) {
             DBusInputStream dbusInputStream(dbusMessage);
-            const bool success = DBusSerializableArguments<_InArgs...>::deserialize(dbusInputStream, std::get<_InArgIndices>(argTuple)...);
+            const bool success = DBusSerializableArguments<CommonAPI::Deployable<_InArgs, _DeplInArgs>...>::deserialize(dbusInputStream, std::get<_InArgIndices>(in_)...);
             if (!success)
                 return false;
         }
@@ -396,9 +428,11 @@ private:
 
         (stub.get()->*stubFunctor_)(
         	clientId,
-        	std::move(std::get<_InArgIndices>(argTuple))...,
+        	std::move(std::get<_InArgIndices>(in_).getValue())...,
         	[call, this](_OutArgs... _args){
-        		this->sendReply(call, std::make_tuple(_args...));
+        		this->sendReply(call, std::make_tuple(CommonAPI::Deployable<_OutArgs, _DeplOutArgs>(
+        					_args, std::get<_OutArgIndices>(out_)
+						)...));
         	}
         );
 
@@ -408,13 +442,13 @@ private:
     template<int... _OutArgIndices>
     bool sendReplyInternal(CommonAPI::CallId_t _call,
     					   index_sequence<_OutArgIndices...>,
-    					   std::tuple<_OutArgs...> args) {
+    					   std::tuple<CommonAPI::Deployable<_OutArgs, _DeplOutArgs>...> args) {
 		std::lock_guard<std::mutex> lock(mutex_);
 		auto reply = pending_.find(_call);
 		if (reply != pending_.end()) {
-			if (sizeof...(_OutArgs) > 0) {
+			if (sizeof...(_DeplOutArgs) > 0) {
 				DBusOutputStream output(reply->second);
-				if (!DBusSerializableArguments<_OutArgs...>::serialize(
+				if (!DBusSerializableArguments<CommonAPI::Deployable<_OutArgs, _DeplOutArgs>...>::serialize(
 						output, std::get<_OutArgIndices>(args)...)) {
 					pending_.erase(_call);
 					return false;
@@ -430,8 +464,9 @@ private:
 
     _StubFunctor stubFunctor_;
     const char* dbusReplySignature_;
-    std::tuple<_InArgs..., _OutArgs...> args_;
 
+    std::tuple<CommonAPI::Deployable<_InArgs, _DeplInArgs>...> in_;
+    std::tuple<_DeplOutArgs*...> out_;
 	CommonAPI::CallId_t currentCall_;
 	std::map<CommonAPI::CallId_t, DBusMessage> pending_;
 	std::mutex mutex_; // protects pending_
@@ -683,3 +718,4 @@ protected:
 } // namespace CommonAPI
 
 #endif // COMMONAPI_DBUS_DBUSSTUBADAPTERHELPER_HPP_
+
diff --git a/include/CommonAPI/DBus/DBusTypeOutputStream.hpp b/include/CommonAPI/DBus/DBusTypeOutputStream.hpp
index 928eadc..074d76a 100644
--- a/include/CommonAPI/DBus/DBusTypeOutputStream.hpp
+++ b/include/CommonAPI/DBus/DBusTypeOutputStream.hpp
@@ -116,20 +116,22 @@ public:
 
     template<typename _Deployment, typename... _Types>
     TypeOutputStream &writeType(const Variant<_Types...> &_value, const _Deployment *_depl) {
-        if (_depl != nullptr && _depl->isFreeDesktop_) {
-            signature_.append("v");
-        } else {
-            signature_.append("(yv)");
-        }
-        TypeOutputStreamWriteVisitor<DBusTypeOutputStream> typeVisitor(*this);
-        ApplyVoidVisitor<TypeOutputStreamWriteVisitor<DBusTypeOutputStream>,
-            Variant<_Types...>, _Types...>::visit(typeVisitor, _value);
+    	if (_depl != nullptr && _depl->isDBus_) {
+    		signature_.append("v");
+    	} else {
+    		signature_.append("(yv)");
+    	}
+		TypeOutputStreamWriteVisitor<DBusTypeOutputStream> typeVisitor(*this);
+		ApplyVoidVisitor<TypeOutputStreamWriteVisitor<DBusTypeOutputStream>,
+				Variant<_Types...>, _Types...>::visit(typeVisitor, _value);
         return (*this);
     }
 
 	template<typename _ElementType>
 	TypeOutputStream &writeType(const std::vector<_ElementType> &_value) {
 		signature_.append("a");
+		_ElementType dummyElement;
+		writeType(dummyElement);
 		return (*this);
 	}
 
diff --git a/src/CommonAPI/DBus/DBusAddressTranslator.cpp b/src/CommonAPI/DBus/DBusAddressTranslator.cpp
index 57101b4..0c653dc 100644
--- a/src/CommonAPI/DBus/DBusAddressTranslator.cpp
+++ b/src/CommonAPI/DBus/DBusAddressTranslator.cpp
@@ -31,8 +31,7 @@ std::shared_ptr<DBusAddressTranslator> DBusAddressTranslator::get() {
 }
 
 DBusAddressTranslator::DBusAddressTranslator()
-	: defaultDomain_("local"),
-	  dBusBusType_(DBusType_t::SESSION) {
+	: defaultDomain_("local"), orgFreedesktopDBusPeerMapped_(false) {
 	init();
 
 	isDefault_ = ("dbus" == Runtime::get()->getDefaultBinding());
@@ -133,13 +132,13 @@ DBusAddressTranslator::translate(const DBusAddress &_key, CommonAPI::Address &_v
 void
 DBusAddressTranslator::insert(
 		const std::string &_address,
-		const std::string &_service, const std::string &_path, const std::string &_interface) {
+		const std::string &_service, const std::string &_path, const std::string &_interface, const bool _objPathStartWithDigits) {
 
 	if (isValid(_service, '.',
 			(_service.length() > 0 && _service[0] == ':'),
 			(_service.length() > 0 && _service[0] == ':'),
 			true)
-	  && isValid(_path, '/', true)
+	  && isValid(_path, '/', true, _objPathStartWithDigits)
 	  && isValid(_interface, '.')) {
 		CommonAPI::Address address(_address);
 		DBusAddress dbusAddress(_service, _path, _interface);
@@ -152,6 +151,12 @@ DBusAddressTranslator::insert(
 			backwards_[dbusAddress] = address;
 			COMMONAPI_DEBUG(
 				"Added address mapping: ", address, " <--> ", dbusAddress);
+			if (!orgFreedesktopDBusPeerMapped_) {
+				orgFreedesktopDBusPeerMapped_ = (_interface == "org.freedesktop.DBus.Peer");
+				if (orgFreedesktopDBusPeerMapped_) {
+					COMMONAPI_DEBUG("org.freedesktop.DBus.Peer mapped");
+				}
+			}
 		} else if(bw != backwards_.end() && bw->second != address) {
 			COMMONAPI_ERROR("Trying to overwrite existing DBus address "
 					"which is already mapped to a CommonAPI address: ",
@@ -189,21 +194,28 @@ DBusAddressTranslator::readConfiguration() {
 		return false;
 
 	for (auto itsMapping : reader.getSections()) {
-		if(itsMapping.first == "dbus") {
-			// TODO this is kind of misplaced in the AddressTranslator...
-			std::string bus_type_str_ = itsMapping.second->getValue("dbus_bus_type");
-			if(bus_type_str_ == "SESSION") {
-				dBusBusType_ = DBusType_t::SESSION;
-			} else if (bus_type_str_ == "SYSTEM") {
-				dBusBusType_ = DBusType_t::SYSTEM;
-			} else {
-				COMMONAPI_FATAL("Invalid dbus_bus_type specified in .ini file, "
-								"choose one of {SYSTEM, SESSION}");
-				continue;
-			}
-			COMMONAPI_INFO("D-Bus bus type set to: " + bus_type_str_ + " via ini file");
-			continue;
+		if(itsMapping.first == "segments") {
+		    std::map<std::string, std::string> mappings = itsMapping.second->getMappings();
+		    ConnectionId_t connectionId;
+		    std::string busType;
+		    for(auto const &it : mappings) {
+		        connectionId = it.first;
+		        busType = it.second;
+		        if(busType == "SESSION") {
+		            dbusTypes_.insert({ connectionId, DBusType_t::SESSION });
+		        } else if (busType == "SYSTEM") {
+		            dbusTypes_.insert({ connectionId, DBusType_t::SYSTEM });
+		        } else {
+		            COMMONAPI_FATAL("Invalid bus type specified in .ini file, "
+		                    "choose one of {SYSTEM, SESSION}");
+		            continue;
+		        }
+		        COMMONAPI_INFO("D-Bus bus type for connection: " + connectionId +
+		                " is set to: " + busType + " via ini file");
+		    }
+		    continue;
 		}
+
 		CommonAPI::Address itsAddress(itsMapping.first);
 
 		std::string service = itsMapping.second->getValue("service");
@@ -234,8 +246,13 @@ DBusAddressTranslator::isValid(
 
 	if (_ignoreFirst) {
 		start = 1;
-		if (separatorPos == 0)
+		if (separatorPos == 0) {
+			// accept "root-only" i.e. '/' object path
+			if (1 == _name.length()) {
+				return true;
+			}
 			separatorPos = _name.find(_separator, separatorPos+1);
+		}
 	}
 
 	while (start != std::string::npos) {
@@ -306,8 +323,17 @@ DBusAddressTranslator::isValid(
 }
 
 DBusType_t
-DBusAddressTranslator::getDBusBusType() const {
-	return dBusBusType_;
+DBusAddressTranslator::getDBusBusType(const ConnectionId_t &_connectionId) const {
+	auto itsDbusTypesIterator = dbusTypes_.find(_connectionId);
+	if(itsDbusTypesIterator != dbusTypes_.end()) {
+	    return itsDbusTypesIterator->second;
+	} else {
+	    return DBusType_t::SESSION;
+	}
+}
+
+bool DBusAddressTranslator::isOrgFreedesktopDBusPeerMapped() const {
+	return orgFreedesktopDBusPeerMapped_;
 }
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusConnection.cpp b/src/CommonAPI/DBus/DBusConnection.cpp
index cb4f8aa..e3fb4a4 100644
--- a/src/CommonAPI/DBus/DBusConnection.cpp
+++ b/src/CommonAPI/DBus/DBusConnection.cpp
@@ -16,6 +16,7 @@
 #include <CommonAPI/DBus/DBusProxy.hpp>
 #include <CommonAPI/DBus/DBusAddressTranslator.hpp>
 
+
 namespace CommonAPI {
 namespace DBus {
 
@@ -23,7 +24,7 @@ DBusConnectionStatusEvent::DBusConnectionStatusEvent(DBusConnection* dbusConnect
                 dbusConnection_(dbusConnection) {
 }
 
-void DBusConnectionStatusEvent::onListenerAdded(const Listener& listener) {
+void DBusConnectionStatusEvent::onListenerAdded(const Listener& listener, const Subscription subscription) {
     if (dbusConnection_->isConnected())
         listener(AvailabilityStatus::AVAILABLE);
 }
@@ -43,18 +44,18 @@ const DBusObjectPathVTable* DBusConnection::getDBusObjectPathVTable() {
 const int32_t ownUseCount = 2;
 
 void DBusConnection::dispatch() {
-    std::shared_ptr<DBusConnection> selfReference = this->shared_from_this();
-    while (!stopDispatching_ && readWriteDispatch(10) && selfReference.use_count() > ownUseCount) {
-        if (pauseDispatching_) {
-            dispatchSuspendLock_.lock();
-            dispatchSuspendLock_.unlock();
-        }
-    }
+	std::shared_ptr<DBusConnection> selfReference = this->shared_from_this();
+	while (!stopDispatching_ && readWriteDispatch(10) && selfReference.use_count() > ownUseCount) {
+		if (pauseDispatching_) {
+			dispatchSuspendLock_.lock();
+			dispatchSuspendLock_.unlock();
+		}
+	}
 }
 
 bool DBusConnection::readWriteDispatch(int _timeout) {
     if(isConnected()) {
-		return 0 != dbus_connection_read_write_dispatch(connection_, _timeout);
+        return 0 != dbus_connection_read_write_dispatch(connection_, _timeout);
     }
     return false;
 }
@@ -76,13 +77,13 @@ DBusConnection::DBusConnection(DBusType_t busType) :
                 watchContext_(NULL),
                 pauseDispatching_(false),
                 connection_(NULL),
-                busType_(DBusAddressTranslator::get()->getDBusBusType()),
+                busType_(busType),
                 dbusConnectionStatusEvent_(this),
                 libdbusSignalMatchRulesCount_(0),
                 dbusObjectMessageHandler_(),
                 connectionNameCount_(),
                 enforcerThread_(NULL),
-				enforcerThreadCancelled_(false) {
+                enforcerThreadCancelled_(false) {
 
     dbus_threads_init_default();
 }
@@ -99,8 +100,8 @@ DBusConnection::DBusConnection(::DBusConnection *_connection) :
                 libdbusSignalMatchRulesCount_(0),
                 dbusObjectMessageHandler_(),
                 connectionNameCount_(),
-				enforcerThread_(NULL),
-				enforcerThreadCancelled_(false) {
+                enforcerThread_(NULL),
+                enforcerThreadCancelled_(false) {
 
     dbus_threads_init_default();
 }
@@ -124,27 +125,27 @@ DBusConnection::~DBusConnection() {
     }
 
     // ensure, the registry survives until disconnecting is done...
-	//std::shared_ptr<DBusServiceRegistry> itsRegistry = DBusServiceRegistry::get(shared_from_this());
-   	disconnect();
+    //std::shared_ptr<DBusServiceRegistry> itsRegistry = DBusServiceRegistry::get(shared_from_this());
+       disconnect();
 
     //Assert that the enforcerThread_ is in a position to finish itself correctly even after destruction
     //of the DBusConnection. Also assert all resources are cleaned up.
-	auto it = timeoutMap_.begin();
-	while (it != timeoutMap_.end()) {
-		DBusPendingCall* libdbusPendingCall = it->first;
+    auto it = timeoutMap_.begin();
+    while (it != timeoutMap_.end()) {
+        DBusPendingCall* libdbusPendingCall = it->first;
 
-		if (!dbus_pending_call_get_completed(libdbusPendingCall)) {
-			dbus_pending_call_cancel(libdbusPendingCall);
-			DBusMessageReplyAsyncHandler* asyncHandler = std::get<1>(it->second);
-			DBusMessage& dbusMessageCall = std::get<2>(it->second);
+        if (!dbus_pending_call_get_completed(libdbusPendingCall)) {
+            dbus_pending_call_cancel(libdbusPendingCall);
+            DBusMessageReplyAsyncHandler* asyncHandler = std::get<1>(it->second);
+            DBusMessage& dbusMessageCall = std::get<2>(it->second);
 
-			asyncHandler->onDBusMessageReply(CallStatus::REMOTE_ERROR, dbusMessageCall.createMethodError(DBUS_ERROR_TIMEOUT));
-			delete asyncHandler;
+            asyncHandler->onDBusMessageReply(CallStatus::REMOTE_ERROR, dbusMessageCall.createMethodError(DBUS_ERROR_TIMEOUT));
+            delete asyncHandler;
 
-		}
-		it = timeoutMap_.erase(it);
-		dbus_pending_call_unref(libdbusPendingCall);
-	}
+        }
+        it = timeoutMap_.erase(it);
+        dbus_pending_call_unref(libdbusPendingCall);
+    }
 }
 
 
@@ -162,7 +163,7 @@ bool DBusConnection::attachMainLoopContext(std::weak_ptr<MainLoopContext> mainLo
                         &mainLoopContext_,
                         NULL);
 
-		bool success = 0 != dbus_connection_set_watch_functions(
+        bool success = 0 != dbus_connection_set_watch_functions(
                 connection_,
                 &DBusConnection::onAddWatch,
                 &DBusConnection::onRemoveWatch,
@@ -174,7 +175,7 @@ bool DBusConnection::attachMainLoopContext(std::weak_ptr<MainLoopContext> mainLo
             return false;
         }
 
-		success = 0 != dbus_connection_set_timeout_functions(
+        success = 0 != dbus_connection_set_timeout_functions(
                 connection_,
                 &DBusConnection::onAddTimeout,
                 &DBusConnection::onRemoveTimeout,
@@ -289,15 +290,15 @@ bool DBusConnection::connect(DBusError &dbusError, bool startDispatchThread) {
 
     connection_ = dbus_bus_get_private(libdbusType, &dbusError.libdbusError_);
     if (dbusError) {
-		#ifdef _MSC_VER
-				COMMONAPI_ERROR(std::string(__FUNCTION__) +
-					": Name: " + dbusError.getName() +
-					" Message: " + dbusError.getMessage())
-		#else
-				COMMONAPI_ERROR(std::string(__PRETTY_FUNCTION__) +
-					": Name: " + dbusError.getName() +
-					" Message: " + dbusError.getMessage())
-		#endif
+        #ifdef _MSC_VER
+                COMMONAPI_ERROR(std::string(__FUNCTION__) +
+                    ": Name: " + dbusError.getName() +
+                    " Message: " + dbusError.getMessage())
+        #else
+                COMMONAPI_ERROR(std::string(__PRETTY_FUNCTION__) +
+                    ": Name: " + dbusError.getName() +
+                    " Message: " + dbusError.getMessage())
+        #endif
         return false;
     }
 
@@ -310,11 +311,11 @@ bool DBusConnection::connect(DBusError &dbusError, bool startDispatchThread) {
 
     stopDispatching_ = !startDispatchThread;
     if (startDispatchThread) {
-        dispatchThread_ = new std::thread(std::bind(&DBusConnection::dispatch, this->shared_from_this()));
+    	dispatchThread_ = new std::thread(std::bind(&DBusConnection::dispatch, this->shared_from_this()));
     }
 
-   	enforcerThread_ = std::make_shared<std::thread>(
-   							std::bind(&DBusConnection::enforceAsynchronousTimeouts, shared_from_this()));
+    enforcerThread_ = std::make_shared<std::thread>(
+    					std::bind(&DBusConnection::enforceAsynchronousTimeouts, shared_from_this()));
 
     dbusConnectionStatusEvent_.notifyListeners(AvailabilityStatus::AVAILABLE);
 
@@ -352,7 +353,7 @@ void DBusConnection::disconnect() {
         enforcerThreadCancelled_ = true;
         enforceTimeoutCondition_.notify_one();
         if (enforcerThread_->joinable()) {
-        	enforcerThread_->join();
+            enforcerThread_->join();
         }
         enforcerThreadCancelled_ = false;
 
@@ -388,7 +389,7 @@ bool DBusConnection::requestServiceNameAndBlock(const std::string& serviceName)
     std::lock_guard<std::mutex> dbusConnectionLock(connectionGuard_);
     auto conIter = connectionNameCount_.find(serviceName);
     if (conIter == connectionNameCount_.end()) {
-        suspendDispatching();
+    	suspendDispatching();
 
         const int libdbusStatus = dbus_bus_request_name(connection_,
                         serviceName.c_str(),
@@ -400,17 +401,17 @@ bool DBusConnection::requestServiceNameAndBlock(const std::string& serviceName)
         isServiceNameAcquired = (libdbusStatus == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
         if (isServiceNameAcquired) {
             connectionNameCount_.insert( { serviceName, (uint16_t)1 } );
-		}
-		else {
-			#ifdef _MSC_VER // Visual Studio
-			COMMONAPI_ERROR(std::string(__FUNCTION__) +
-				": Name: " + dbusError.getName() +
-				" Message: " + dbusError.getMessage())
-			#else
+        }
+        else {
+            #ifdef _MSC_VER // Visual Studio
+            COMMONAPI_ERROR(std::string(__FUNCTION__) +
+                ": Name: " + dbusError.getName() +
+                " Message: " + dbusError.getMessage())
+            #else
             COMMONAPI_ERROR(std::string(__PRETTY_FUNCTION__) +
                             ": Name: " + dbusError.getName() +
                             " Message: " + dbusError.getMessage())
-			#endif
+            #endif
         }
     } else {
         conIter->second = conIter->second + 1;
@@ -427,7 +428,7 @@ bool DBusConnection::releaseServiceName(const std::string& serviceName) const {
     auto conIter = connectionNameCount_.find(serviceName);
     if (conIter != connectionNameCount_.end()) {
         if (conIter->second == 1) {
-            suspendDispatching();
+        	suspendDispatching();
             const int libdbusStatus = dbus_bus_release_name(connection_,
                             serviceName.c_str(),
                             &dbusError.libdbusError_);
@@ -449,29 +450,40 @@ bool DBusConnection::sendDBusMessage(const DBusMessage &_message) const {
     assert(isConnected());
 
     dbus_uint32_t dbusSerial;
-	bool result = 0 != dbus_connection_send(connection_, _message.message_, &dbusSerial);
+    bool result = 0 != dbus_connection_send(connection_, _message.message_, &dbusSerial);
     return result;
 }
 
-void DBusConnection::onLibdbusPendingCallNotifyThunk(::DBusPendingCall* libdbusPendingCall, void *userData) {
-    assert(userData);
-    assert(libdbusPendingCall);
+DBusMessage DBusConnection::convertToDBusMessage(::DBusPendingCall* _libdbusPendingCall,
+		CallStatus& _callStatus) {
+	assert(_libdbusPendingCall);
 
-    auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(userData);
+	::DBusMessage* libdbusMessage = dbus_pending_call_steal_reply(_libdbusPendingCall);
+	const bool increaseLibdbusMessageReferenceCount = false;
+	DBusMessage dbusMessage(libdbusMessage, increaseLibdbusMessageReferenceCount);
+	_callStatus = CallStatus::SUCCESS;
 
-    ::DBusMessage* libdbusMessage = dbus_pending_call_steal_reply(libdbusPendingCall);
-    const bool increaseLibdbusMessageReferenceCount = false;
-    DBusMessage dbusMessage(libdbusMessage, increaseLibdbusMessageReferenceCount);
-    CallStatus callStatus = CallStatus::SUCCESS;
+	if (!dbusMessage.isMethodReturnType()) {
+		_callStatus = CallStatus::REMOTE_ERROR;
+	}
 
-    if (!dbusMessage.isMethodReturnType()) {
-        callStatus = CallStatus::REMOTE_ERROR;
-    }
+	return dbusMessage;
+}
+
+void DBusConnection::onLibdbusPendingCallNotifyThunk(::DBusPendingCall* _libdbusPendingCall, void *_userData) {
+    assert(_userData);
+    assert(_libdbusPendingCall);
+
+    auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(_userData);
+
+    DBusMessage dbusMessage;
+    CallStatus callStatus;
+    dbusMessage = DBusConnection::convertToDBusMessage(_libdbusPendingCall, callStatus);
 
     dbusMessageReplyAsyncHandler->onDBusMessageReply(callStatus, dbusMessage);
 
     // libdbus calls the cleanup method below
-    dbus_pending_call_unref(libdbusPendingCall);
+    dbus_pending_call_unref(_libdbusPendingCall);
 }
 
 void DBusConnection::onLibdbusDataCleanup(void* userData) {
@@ -479,74 +491,77 @@ void DBusConnection::onLibdbusDataCleanup(void* userData) {
     delete dbusMessageReplyAsyncHandler;
 }
 
-
 //Would not be needed if libdbus would actually handle its timeouts for pending calls.
 void DBusConnection::enforceAsynchronousTimeouts() const {
-	std::unique_lock<std::mutex> itsLock(enforcerThreadMutex_);
+    std::unique_lock<std::mutex> itsLock(enforcerThreadMutex_);
 
-	while (!enforcerThreadCancelled_) {
+    while (!enforcerThreadCancelled_) {
         enforceTimeoutMutex_.lock();
 
         int timeout = std::numeric_limits<int>::max(); // not really, but nearly "forever"
         if (timeoutMap_.size() > 0) {
-        	auto minTimeoutElement = std::min_element(timeoutMap_.begin(), timeoutMap_.end(),
-        			[] (const TimeoutMapElement& lhs, const TimeoutMapElement& rhs) {
-                    	return std::get<0>(lhs.second) < std::get<0>(rhs.second);
-        	});
+            auto minTimeoutElement = std::min_element(timeoutMap_.begin(), timeoutMap_.end(),
+                    [] (const TimeoutMapElement& lhs, const TimeoutMapElement& rhs) {
+                        return std::get<0>(lhs.second) < std::get<0>(rhs.second);
+            });
 
-        	auto minTimeout = std::get<0>(minTimeoutElement->second);
+            auto minTimeout = std::get<0>(minTimeoutElement->second);
 
-        	std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
+            std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
 
-        	timeout = (int)std::chrono::duration_cast<std::chrono::milliseconds>(minTimeout - now).count();
+            timeout = (int)std::chrono::duration_cast<std::chrono::milliseconds>(minTimeout - now).count();
         }
 
         enforceTimeoutMutex_.unlock();
 
         if (std::cv_status::timeout ==
-        	enforceTimeoutCondition_.wait_for(itsLock, std::chrono::milliseconds(timeout))) {
-
-			//Do not access members if the DBusConnection was destroyed during the unlocked phase.
-			enforceTimeoutMutex_.lock();
-			auto it = timeoutMap_.begin();
-			while (it != timeoutMap_.end()) {
-				std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
-
-				if (now > std::get<0>(it->second)) {
-					DBusPendingCall* libdbusPendingCall = it->first;
-
-					if (!dbus_pending_call_get_completed(libdbusPendingCall)) {
-						dbus_pending_call_cancel(libdbusPendingCall);
-						DBusMessageReplyAsyncHandler* asyncHandler = std::get<1>(it->second);
-						DBusMessage& dbusMessageCall = std::get<2>(it->second);
-
-						if (mainLoopContext_.lock()) {
-							mainloopTimeouts_.push_back(std::make_pair(asyncHandler, dbusMessageCall));
-						} else {
-							enforceTimeoutMutex_.unlock(); // unlock before making callbacks to application to avoid deadlocks
-							asyncHandler->onDBusMessageReply(CallStatus::REMOTE_ERROR, dbusMessageCall.createMethodError(DBUS_ERROR_TIMEOUT));
-							enforceTimeoutMutex_.lock();
-							delete asyncHandler;
-						}
-					}
-					it = timeoutMap_.erase(it);
-
-					//This unref MIGHT cause the destruction of the last callback object that references the DBusConnection.
-					//So after this unref has been called, it has to be ensured that continuation of the loop is an option.
-					dbus_pending_call_unref(libdbusPendingCall);
-				} else {
-					++it;
-				}
-			}
-			enforceTimeoutMutex_.unlock();
-		}
+            enforceTimeoutCondition_.wait_for(itsLock, std::chrono::milliseconds(timeout))) {
+
+            //Do not access members if the DBusConnection was destroyed during the unlocked phase.
+            enforceTimeoutMutex_.lock();
+            auto it = timeoutMap_.begin();
+            while (it != timeoutMap_.end()) {
+                std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
+
+                if (now > std::get<0>(it->second)) {
+                    DBusPendingCall* libdbusPendingCall = it->first;
+
+                    if (!dbus_pending_call_get_completed(libdbusPendingCall)) {
+                        dbus_pending_call_cancel(libdbusPendingCall);
+                        DBusMessageReplyAsyncHandler* asyncHandler = std::get<1>(it->second);
+                        DBusMessage& dbusMessageCall = std::get<2>(it->second);
+
+                        if (mainLoopContext_.lock()) {
+                        	mainloopTimeouts_.push_back(std::make_tuple(asyncHandler,
+													dbusMessageCall.createMethodError(DBUS_ERROR_TIMEOUT),
+													CallStatus::REMOTE_ERROR,
+													nullptr));
+                        							mainLoopContext_.lock()->wakeup();
+                        } else {
+                        	enforceTimeoutMutex_.unlock(); // unlock before making callbacks to application to avoid deadlocks
+                        	asyncHandler->onDBusMessageReply(CallStatus::REMOTE_ERROR, dbusMessageCall.createMethodError(DBUS_ERROR_TIMEOUT));
+                        	enforceTimeoutMutex_.lock();
+                        	delete asyncHandler;
+                        }
+                    }
+                    it = timeoutMap_.erase(it);
+
+                    //This unref MIGHT cause the destruction of the last callback object that references the DBusConnection.
+                    //So after this unref has been called, it has to be ensured that continuation of the loop is an option.
+                    dbus_pending_call_unref(libdbusPendingCall);
+                } else {
+                    ++it;
+                }
+            }
+            enforceTimeoutMutex_.unlock();
+        }
     }
 }
 
 std::future<CallStatus> DBusConnection::sendDBusMessageWithReplyAsync(
         const DBusMessage& dbusMessage,
         std::unique_ptr<DBusMessageReplyAsyncHandler> dbusMessageReplyAsyncHandler,
-		const CommonAPI::CallInfo *_info) const {
+        const CommonAPI::CallInfo *_info) const {
 
     assert(dbusMessage);
     assert(isConnected());
@@ -555,56 +570,47 @@ std::future<CallStatus> DBusConnection::sendDBusMessageWithReplyAsync(
     dbus_bool_t libdbusSuccess;
 
     suspendDispatching();
-    libdbusSuccess = dbus_connection_send_with_reply(connection_,
-                                                     dbusMessage.message_,
-                                                     &libdbusPendingCall,
-                                                     _info->timeout_);
+    libdbusSuccess = dbus_connection_send_with_reply_set_notify(connection_,
+    		dbusMessage.message_,
+			&libdbusPendingCall,
+			onLibdbusPendingCallNotifyThunk,
+			dbusMessageReplyAsyncHandler.get(),
+			onLibdbusDataCleanup,
+			_info->timeout_);
 
     if (_info->sender_ != 0) {
-    	COMMONAPI_DEBUG("Message sent: SenderID: ", _info->sender_, " - Serial number: ", dbusMessage.getSerial());
+        COMMONAPI_DEBUG("Message sent: SenderID: ", _info->sender_, " - Serial number: ", dbusMessage.getSerial());
     }
 
     if (!libdbusSuccess || !libdbusPendingCall) {
-        dbusMessageReplyAsyncHandler->onDBusMessageReply(CallStatus::CONNECTION_FAILED, dbusMessage.createMethodError(DBUS_ERROR_DISCONNECTED));
-        resumeDispatching();
-        return dbusMessageReplyAsyncHandler->getFuture();
+		#ifdef _MSC_VER // Visual Studio
+            COMMONAPI_ERROR(std::string(__FUNCTION__) +
+                ": (!libdbusSuccess || !libdbusPendingCall) == true")
+        #else
+            COMMONAPI_ERROR(std::string(__PRETTY_FUNCTION__) +
+                            ": (!libdbusSuccess || !libdbusPendingCall) == true")
+        #endif
+		if (libdbusPendingCall) {
+			dbus_pending_call_unref(libdbusPendingCall);
+		}
+		dbusMessageReplyAsyncHandler->onDBusMessageReply(CallStatus::CONNECTION_FAILED, dbusMessage.createMethodError(DBUS_ERROR_DISCONNECTED));
+		resumeDispatching();
+		return dbusMessageReplyAsyncHandler->getFuture();
     }
 
-    sendLock_.lock();
-	if (dbus_pending_call_get_completed (libdbusPendingCall)) {
-		onLibdbusPendingCallNotifyThunk(libdbusPendingCall, dbusMessageReplyAsyncHandler.get());
-		onLibdbusDataCleanup(dbusMessageReplyAsyncHandler.get());
-
-	} else {
-		libdbusSuccess = dbus_pending_call_set_notify(
-						libdbusPendingCall,
-						onLibdbusPendingCallNotifyThunk,
-						dbusMessageReplyAsyncHandler.get(),
-						onLibdbusDataCleanup);
-
-	    if (!libdbusSuccess) {
-	        dbusMessageReplyAsyncHandler->onDBusMessageReply(CallStatus::OUT_OF_MEMORY, dbusMessage);
-	        dbus_pending_call_unref(libdbusPendingCall);
-	        resumeDispatching();
-			sendLock_.unlock();
-	        return dbusMessageReplyAsyncHandler->getFuture();
-	    }
-	}
-    sendLock_.unlock();
-
     DBusMessageReplyAsyncHandler* replyAsyncHandler = dbusMessageReplyAsyncHandler.release();
 
     if (_info->timeout_ != DBUS_TIMEOUT_INFINITE) {
         dbus_pending_call_ref(libdbusPendingCall);
         auto timeoutPoint = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(_info->timeout_);
         std::tuple<
-        	std::chrono::time_point<std::chrono::high_resolution_clock>,
-        	DBusMessageReplyAsyncHandler*,
-        	DBusMessage> toInsert {
-        		timeoutPoint,
-        		replyAsyncHandler,
-        		dbusMessage
-        	};
+            std::chrono::time_point<std::chrono::high_resolution_clock>,
+            DBusMessageReplyAsyncHandler*,
+            DBusMessage> toInsert {
+                timeoutPoint,
+                replyAsyncHandler,
+                dbusMessage
+            };
 
         enforceTimeoutMutex_.lock();
         timeoutMap_.insert( { libdbusPendingCall, toInsert } );
@@ -622,7 +628,7 @@ std::future<CallStatus> DBusConnection::sendDBusMessageWithReplyAsync(
 
 DBusMessage DBusConnection::sendDBusMessageWithReplyAndBlock(const DBusMessage& dbusMessage,
                                                              DBusError& dbusError,
-															 const CommonAPI::CallInfo *_info) const {
+                                                             const CommonAPI::CallInfo *_info) const {
     assert(dbusMessage);
     assert(!dbusError);
     assert(isConnected());
@@ -635,7 +641,7 @@ DBusMessage DBusConnection::sendDBusMessageWithReplyAndBlock(const DBusMessage&
                                                                                    &dbusError.libdbusError_);
 
     if (_info->sender_ != 0) {
-    	COMMONAPI_DEBUG("Message sent: SenderID: ", _info->sender_, " - Serial number: ", dbusMessage.getSerial());
+        COMMONAPI_DEBUG("Message sent: SenderID: ", _info->sender_, " - Serial number: ", dbusMessage.getSerial());
     }
 
     resumeDispatching();
@@ -650,18 +656,25 @@ DBusMessage DBusConnection::sendDBusMessageWithReplyAndBlock(const DBusMessage&
 
 
 bool DBusConnection::singleDispatch() {
-	for (auto t : mainloopTimeouts_) {
-		t.first->onDBusMessageReply(CallStatus::REMOTE_ERROR, t.second.createMethodError(DBUS_ERROR_TIMEOUT));
-		delete t.first;
-	}
-	mainloopTimeouts_.clear();
+    for (auto t : mainloopTimeouts_) {
+    	std::get<0>(t)->onDBusMessageReply(std::get<2>(t), std::get<1>(t));
+    	if (std::get<3>(t) != nullptr) {
+    		dbus_pending_call_unref(std::get<3>(t));
+    	}
+    	delete std::get<0>(t);
+    }
+    mainloopTimeouts_.clear();
 
     return (dbus_connection_dispatch(connection_) == DBUS_DISPATCH_DATA_REMAINS);
 }
 
 bool DBusConnection::isDispatchReady() {
     return (dbus_connection_get_dispatch_status(connection_) == DBUS_DISPATCH_DATA_REMAINS ||
-    		!mainloopTimeouts_.empty());
+            !mainloopTimeouts_.empty());
+}
+
+bool DBusConnection::hasDispatchThread() {
+    return (dispatchThread_ != NULL);
 }
 
 DBusProxyConnection::DBusSignalHandlerToken DBusConnection::subscribeForSelectiveBroadcast(
@@ -685,13 +698,13 @@ DBusProxyConnection::DBusSignalHandlerToken DBusConnection::subscribeForSelectiv
     DBusProxyConnection::DBusSignalHandlerToken subscriptionToken;
     if (callStatus == CommonAPI::CallStatus::SUCCESS && subscriptionAccepted) {
         subscriptionToken = addSignalMemberHandler(
-								objectPath,
-								interfaceName,
-								interfaceMemberName,
-								interfaceMemberSignature,
-								dbusSignalHandler,
-								true
-							);
+                                objectPath,
+                                interfaceName,
+                                interfaceMemberName,
+                                interfaceMemberSignature,
+                                dbusSignalHandler,
+                                true
+                            );
         subscriptionAccepted = true;
     }
 
@@ -735,7 +748,7 @@ DBusProxyConnection::DBusSignalHandlerToken DBusConnection::addSignalMemberHandl
         handlerList.insert(dbusSignalHandler);
 
         dbusSignalHandlerTable_.insert( {
-        	dbusSignalHandlerPath,
+            dbusSignalHandlerPath,
             std::make_pair(std::make_shared<std::recursive_mutex>(), std::move(handlerList))
         } );
     } else {
@@ -763,6 +776,14 @@ bool DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken &dbu
         }
         signalEntry->second.first->unlock();
     }
+
+    if (lastHandlerRemoved) {
+		dbusSignalHandlerTable_.erase(signalEntry);
+		removeLibdbusSignalMatchRule(std::get<0>(dbusSignalHandlerToken),
+				std::get<1>(dbusSignalHandlerToken),
+				std::get<2>(dbusSignalHandlerToken));
+	}
+
     return lastHandlerRemoved;
 }
 
@@ -874,12 +895,12 @@ bool DBusConnection::addLibdbusSignalMatchRule(const std::string& dbusMatchRule)
 
     // add the libdbus message signal filter
     if (!libdbusSignalMatchRulesCount_) {
-		libdbusSuccess = 0 != dbus_connection_add_filter(
-        	connection_,
+        libdbusSuccess = 0 != dbus_connection_add_filter(
+            connection_,
             &onLibdbusSignalFilterThunk,
             this,
             NULL
-		);
+        );
     }
 
     // finally add the match rule
@@ -912,10 +933,10 @@ bool DBusConnection::removeLibdbusSignalMatchRule(const std::string& dbusMatchRu
 
     dbus_bus_remove_match(connection_, dbusMatchRule.c_str(), NULL);
 
-	libdbusSignalMatchRulesCount_--;
-	if (libdbusSignalMatchRulesCount_ == 0) {
-		dbus_connection_remove_filter(connection_, &onLibdbusSignalFilterThunk, this);
-	}
+    libdbusSignalMatchRulesCount_--;
+    if (libdbusSignalMatchRulesCount_ == 0) {
+        dbus_connection_remove_filter(connection_, &onLibdbusSignalFilterThunk, this);
+    }
 
     resumeDispatching();
 
@@ -968,7 +989,7 @@ void DBusConnection::unregisterObjectPath(const std::string& objectPath) {
 
     if (isConnected()) {
         dbus_bool_t libdbusSuccess
-			= dbus_connection_unregister_object_path(connection_, objectPath.c_str());
+            = dbus_connection_unregister_object_path(connection_, objectPath.c_str());
         assert(libdbusSuccess);
     }
 }
@@ -1007,14 +1028,15 @@ void DBusConnection::addLibdbusSignalMatchRule(const std::string& objectPath,
     if (isConnected()) {
         bool libdbusSuccess = true;
         suspendDispatching();
+
         // add the libdbus message signal filter
         if (isFirstMatchRule) {
 
-			libdbusSuccess = 0 != dbus_connection_add_filter(
-            					connection_,
-								&onLibdbusSignalFilterThunk,
-								this,
-								NULL);
+            libdbusSuccess = 0 != dbus_connection_add_filter(
+                                connection_,
+                                &onLibdbusSignalFilterThunk,
+                                this,
+                                NULL);
             assert(libdbusSuccess);
         }
 
diff --git a/src/CommonAPI/DBus/DBusDaemonProxy.cpp b/src/CommonAPI/DBus/DBusDaemonProxy.cpp
index 489f06b..fe87335 100644
--- a/src/CommonAPI/DBus/DBusDaemonProxy.cpp
+++ b/src/CommonAPI/DBus/DBusDaemonProxy.cpp
@@ -36,7 +36,7 @@ static const char *DAEMON_DBUS_INTERFACE = DBusDaemonProxy::getInterfaceId();
 static const char *DAEMON_DBUS_OBJECT_PATH = "/org/freedesktop/DBus";
 static const char *DAEMON_DBUS_BUS = "org.freedesktop.DBus";
 static DBusAddress dbusProxyAddress(DAEMON_DBUS_INTERFACE, DAEMON_DBUS_OBJECT_PATH, DAEMON_DBUS_BUS);
-static CommonAPI::CallInfo daemonProxyInfo(2000);
+static CommonAPI::CallInfo daemonProxyInfo(30000);
 
 DBusDaemonProxy::DBusDaemonProxy(const std::shared_ptr<DBusProxyConnection>& dbusConnection):
                 DBusProxyBase(dbusProxyAddress, dbusConnection),
diff --git a/src/CommonAPI/DBus/DBusFactory.cpp b/src/CommonAPI/DBus/DBusFactory.cpp
index f75619c..afe5ad7 100644
--- a/src/CommonAPI/DBus/DBusFactory.cpp
+++ b/src/CommonAPI/DBus/DBusFactory.cpp
@@ -27,8 +27,7 @@ Factory::get() {
 	return theFactory;
 }
 
-Factory::Factory()
-	: dBusBusType_(DBusAddressTranslator::get()->getDBusBusType()) {
+Factory::Factory() {
 }
 
 Factory::~Factory() {
@@ -224,8 +223,9 @@ Factory::getConnection(const ConnectionId_t &_connectionId) {
 	}
 
 	// No connection found, lets create and initialize one
+	DBusType_t dbusType = DBusAddressTranslator::get()->getDBusBusType(_connectionId);
 	std::shared_ptr<DBusConnection> itsConnection
-		= std::make_shared<DBusConnection>(dBusBusType_);
+		= std::make_shared<DBusConnection>(dbusType);
 	connections_.insert({ _connectionId, itsConnection });
 
 	itsConnection->connect(true);
@@ -244,7 +244,7 @@ Factory::getConnection(std::shared_ptr<MainLoopContext> _context) {
 
 	// No connection found, lets create and initialize one
 	std::shared_ptr<DBusConnection> itsConnection
-		= std::make_shared<DBusConnection>(dBusBusType_);
+		= std::make_shared<DBusConnection>(DBusType_t::SESSION);
 	contextConnections_.insert({ _context.get(), itsConnection } );
 
 	itsConnection->connect(false);
diff --git a/src/CommonAPI/DBus/DBusMainLoopContext.cpp b/src/CommonAPI/DBus/DBusMainLoopContext.cpp
index beaee2c..c20beb9 100644
--- a/src/CommonAPI/DBus/DBusMainLoopContext.cpp
+++ b/src/CommonAPI/DBus/DBusMainLoopContext.cpp
@@ -65,6 +65,8 @@ void DBusWatch::startWatching() {
 
 #ifdef WIN32
 	pollFileDescriptor_.fd = dbus_watch_get_socket(libdbusWatch_);
+	wsaEvent_ = WSACreateEvent();
+	WSAEventSelect(pollFileDescriptor_.fd, wsaEvent_, FD_READ);
 #else
 	pollFileDescriptor_.fd = dbus_watch_get_unix_fd(libdbusWatch_);
 #endif
@@ -88,6 +90,12 @@ const pollfd& DBusWatch::getAssociatedFileDescriptor() {
     return pollFileDescriptor_;
 }
 
+#ifdef WIN32
+const HANDLE& DBusWatch::getAssociatedEvent() {
+	return wsaEvent_;
+}
+#endif
+
 void DBusWatch::dispatch(unsigned int eventFlags) {
 #ifdef WIN32
     unsigned int dbusWatchFlags = 0;
@@ -111,7 +119,11 @@ void DBusWatch::dispatch(unsigned int eventFlags) {
                             ((eventFlags & POLLERR) >> 1) |
                             ((eventFlags & POLLHUP) >> 1);
 #endif
-    dbus_watch_handle(libdbusWatch_, dbusWatchFlags);
+    dbus_bool_t response = dbus_watch_handle(libdbusWatch_, dbusWatchFlags);
+
+    if (!response) {
+        printf("dbus_watch_handle returned FALSE!");
+    }
 }
 
 const std::vector<DispatchSource*>& DBusWatch::getDependentDispatchSources() {
diff --git a/src/CommonAPI/DBus/DBusProxy.cpp b/src/CommonAPI/DBus/DBusProxy.cpp
index 47336f7..1de88fc 100644
--- a/src/CommonAPI/DBus/DBusProxy.cpp
+++ b/src/CommonAPI/DBus/DBusProxy.cpp
@@ -9,6 +9,8 @@
 #include <CommonAPI/Utils.hpp>
 #include <CommonAPI/DBus/DBusProxy.hpp>
 #include <CommonAPI/DBus/DBusUtils.hpp>
+#include <CommonAPI/DBus/DBusProxyAsyncSignalMemberCallbackHandler.hpp>
+#include <CommonAPI/Logger.hpp>
 
 namespace CommonAPI {
 namespace DBus {
@@ -17,7 +19,7 @@ DBusProxyStatusEvent::DBusProxyStatusEvent(DBusProxy *_dbusProxy)
 	: dbusProxy_(_dbusProxy) {
 }
 
-void DBusProxyStatusEvent::onListenerAdded(const Listener& listener) {
+void DBusProxyStatusEvent::onListenerAdded(const Listener& listener, const Subscription subscription) {
     if (dbusProxy_->isAvailable())
         listener(AvailabilityStatus::AVAILABLE);
 }
@@ -28,7 +30,8 @@ DBusProxy::DBusProxy(const DBusAddress &_dbusAddress,
                 dbusProxyStatusEvent_(this),
                 availabilityStatus_(AvailabilityStatus::UNKNOWN),
                 interfaceVersionAttribute_(*this, "uu", "getInterfaceVersion"),
-                dbusServiceRegistry_(DBusServiceRegistry::get(_connection))
+                dbusServiceRegistry_(DBusServiceRegistry::get(_connection)),
+				signalMemberHandlerInfo_(3000)
 {
 }
 
@@ -49,11 +52,15 @@ bool DBusProxy::isAvailable() const {
 }
 
 bool DBusProxy::isAvailableBlocking() const {
-	std::unique_lock<std::mutex> lock(availabilityMutex_);
+    std::unique_lock<std::mutex> lock(availabilityMutex_);
+
+    if(!getDBusConnection()->hasDispatchThread()) {
+        return isAvailable();
+    }
 
     while (availabilityStatus_ != AvailabilityStatus::AVAILABLE) {
-		availabilityCondition_.wait(lock);
-	}
+        availabilityCondition_.wait(lock);
+    }
 
     return true;
 }
@@ -66,9 +73,79 @@ InterfaceVersionAttribute& DBusProxy::getInterfaceVersionAttribute() {
     return interfaceVersionAttribute_;
 }
 
+void DBusProxy::signalMemberCallback(const CallStatus dbusMessageCallStatus,
+		const DBusMessage& dbusMessage,
+		DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+		const uint32_t tag) {
+	dbusSignalHandler->onSignalDBusMessage(dbusMessage);
+}
+
+void DBusProxy::signalInitialValueCallback(const CallStatus dbusMessageCallStatus,
+		const DBusMessage& dbusMessage,
+		DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+		const uint32_t tag) {
+	dbusSignalHandler->onInitialValueSignalDBusMessage(dbusMessage, tag);
+}
+
 void DBusProxy::onDBusServiceInstanceStatus(const AvailabilityStatus& availabilityStatus) {
-    availabilityStatus_ = availabilityStatus;
-    dbusProxyStatusEvent_.notifyListeners(availabilityStatus);
+	if (availabilityStatus != availabilityStatus_) {
+		availabilityStatusMutex_.lock();
+		availabilityStatus_ = availabilityStatus;
+		availabilityStatusMutex_.unlock();
+
+		dbusProxyStatusEvent_.notifyListeners(availabilityStatus);
+
+		if (availabilityStatus == AvailabilityStatus::AVAILABLE) {
+			std::lock_guard < std::mutex > queueLock(signalMemberHandlerQueueMutex_);
+
+			for(auto signalMemberHandlerIterator = signalMemberHandlerQueue_.begin();
+					signalMemberHandlerIterator != signalMemberHandlerQueue_.end();
+					signalMemberHandlerIterator++) {
+
+				if (!std::get<7>(*signalMemberHandlerIterator)) {
+					connection_->addSignalMemberHandler(
+								std::get<0>(*signalMemberHandlerIterator),
+								std::get<1>(*signalMemberHandlerIterator),
+								std::get<2>(*signalMemberHandlerIterator),
+								std::get<3>(*signalMemberHandlerIterator),
+								std::get<5>(*signalMemberHandlerIterator),
+								std::get<6>(*signalMemberHandlerIterator));
+					std::get<7>(*signalMemberHandlerIterator) = true;
+
+					DBusMessage message = createMethodCall(std::get<4>(*signalMemberHandlerIterator), "");
+
+					DBusProxyAsyncSignalMemberCallbackHandler::FunctionType myFunc = std::bind(
+							&DBusProxy::signalMemberCallback,
+							this,
+							std::placeholders::_1,
+							std::placeholders::_2,
+							std::placeholders::_3,
+							std::placeholders::_4);
+					connection_->sendDBusMessageWithReplyAsync(
+							message,
+							DBusProxyAsyncSignalMemberCallbackHandler::create(myFunc, std::get<5>(*signalMemberHandlerIterator), 0),
+							&signalMemberHandlerInfo_);
+				}
+			}
+		} else {
+			std::lock_guard < std::mutex > queueLock(signalMemberHandlerQueueMutex_);
+
+			for(auto signalMemberHandlerIterator = signalMemberHandlerQueue_.begin();
+					signalMemberHandlerIterator != signalMemberHandlerQueue_.end();
+					signalMemberHandlerIterator++) {
+
+				if (std::get<7>(*signalMemberHandlerIterator)) {
+					DBusProxyConnection::DBusSignalHandlerToken signalHandlerToken (
+							std::get<0>(*signalMemberHandlerIterator),
+							std::get<1>(*signalMemberHandlerIterator),
+							std::get<2>(*signalMemberHandlerIterator),
+							std::get<3>(*signalMemberHandlerIterator));
+					connection_->removeSignalMemberHandler(signalHandlerToken, std::get<5>(*signalMemberHandlerIterator));
+					std::get<7>(*signalMemberHandlerIterator) = false;
+				}
+			}
+		}
+	}
     availabilityCondition_.notify_one();
 }
 
@@ -96,5 +173,151 @@ void DBusProxy::unsubscribeFromSelectiveBroadcast(const std::string& eventName,
     getDBusConnection()->unsubscribeFromSelectiveBroadcast(eventName, subscription, this, dbusSignalHandler);
 }
 
+DBusProxyConnection::DBusSignalHandlerToken DBusProxy::addSignalMemberHandler(
+                const std::string& objectPath,
+                const std::string& interfaceName,
+                const std::string& signalName,
+                const std::string& signalSignature,
+                DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+                const bool justAddFilter) {
+    return DBusProxyBase::addSignalMemberHandler(
+                objectPath,
+                interfaceName,
+                signalName,
+                signalSignature,
+                dbusSignalHandler,
+                justAddFilter);
+}
+
+DBusProxyConnection::DBusSignalHandlerToken DBusProxy::addSignalMemberHandler(
+        const std::string &objectPath,
+        const std::string &interfaceName,
+        const std::string &signalName,
+        const std::string &signalSignature,
+		const std::string &getMethodName,
+        DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+        const bool justAddFilter) {
+
+	DBusProxyConnection::DBusSignalHandlerToken signalHandlerToken (
+			objectPath,
+			interfaceName,
+			signalName,
+			signalSignature);
+
+	if (getMethodName != "") {
+
+		SignalMemberHandlerTuple signalMemberHandler(
+			objectPath,
+			interfaceName,
+			signalName,
+			signalSignature,
+			getMethodName,
+			dbusSignalHandler,
+			justAddFilter,
+			false);
+
+		availabilityStatusMutex_.lock();
+		if (availabilityStatus_ == AvailabilityStatus::AVAILABLE) {
+			availabilityStatusMutex_.unlock();
+			signalHandlerToken = connection_->addSignalMemberHandler(
+				objectPath,
+				interfaceName,
+				signalName,
+				signalSignature,
+				dbusSignalHandler,
+				justAddFilter);
+			std::get<7>(signalMemberHandler) = true;
+		} else {
+			availabilityStatusMutex_.unlock();
+		}
+		addSignalMemberHandlerToQueue(signalMemberHandler);
+	} else {
+		signalHandlerToken = connection_->addSignalMemberHandler(
+				objectPath,
+				interfaceName,
+				signalName,
+				signalSignature,
+				dbusSignalHandler,
+				justAddFilter);
+	}
+
+    return signalHandlerToken;
+}
+
+void DBusProxy::addSignalMemberHandlerToQueue(SignalMemberHandlerTuple& _signalMemberHandler) {
+
+	std::lock_guard < std::mutex > queueLock(signalMemberHandlerQueueMutex_);
+	bool found = false;
+
+	for(auto signalMemberHandlerIterator = signalMemberHandlerQueue_.begin();
+			signalMemberHandlerIterator != signalMemberHandlerQueue_.end();
+			signalMemberHandlerIterator++) {
+
+		if ( (std::get<0>(*signalMemberHandlerIterator) == std::get<0>(_signalMemberHandler)) &&
+				(std::get<1>(*signalMemberHandlerIterator) == std::get<1>(_signalMemberHandler)) &&
+				(std::get<2>(*signalMemberHandlerIterator) == std::get<2>(_signalMemberHandler)) &&
+				(std::get<3>(*signalMemberHandlerIterator) == std::get<3>(_signalMemberHandler))) {
+
+			found = true;
+			break;
+		}
+	}
+	if (!found) {
+		signalMemberHandlerQueue_.push_back(_signalMemberHandler);
+	}
+}
+
+bool DBusProxy::removeSignalMemberHandler(
+    		const DBusProxyConnection::DBusSignalHandlerToken &_dbusSignalHandlerToken,
+    		const DBusProxyConnection::DBusSignalHandler *_dbusSignalHandler) {
+
+	{
+		std::lock_guard < std::mutex > queueLock(signalMemberHandlerQueueMutex_);
+		for(auto signalMemberHandlerIterator = signalMemberHandlerQueue_.begin();
+				signalMemberHandlerIterator != signalMemberHandlerQueue_.end();
+				signalMemberHandlerIterator++) {
+
+			if ( (std::get<0>(*signalMemberHandlerIterator) == std::get<0>(_dbusSignalHandlerToken)) &&
+					(std::get<1>(*signalMemberHandlerIterator) == std::get<1>(_dbusSignalHandlerToken)) &&
+					(std::get<2>(*signalMemberHandlerIterator) == std::get<2>(_dbusSignalHandlerToken)) &&
+					(std::get<3>(*signalMemberHandlerIterator) == std::get<3>(_dbusSignalHandlerToken))) {
+				signalMemberHandlerIterator = signalMemberHandlerQueue_.erase(signalMemberHandlerIterator);
+
+				if (signalMemberHandlerIterator == signalMemberHandlerQueue_.end()) {
+					break;
+				}
+			}
+		}
+	}
+
+    return connection_->removeSignalMemberHandler(_dbusSignalHandlerToken, _dbusSignalHandler);
+}
+
+void DBusProxy::getCurrentValueForSignalListener(
+        const std::string &getMethodName,
+        DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+		const uint32_t subscription) {
+
+	availabilityStatusMutex_.lock();
+	if (availabilityStatus_ == AvailabilityStatus::AVAILABLE) {
+		availabilityStatusMutex_.unlock();
+
+		DBusMessage message = createMethodCall(getMethodName, "");
+
+		DBusProxyAsyncSignalMemberCallbackHandler::FunctionType myFunc = std::bind(&DBusProxy::signalInitialValueCallback,
+				this,
+				std::placeholders::_1,
+				std::placeholders::_2,
+				std::placeholders::_3,
+				std::placeholders::_4);
+		connection_->sendDBusMessageWithReplyAsync(
+				message,
+				DBusProxyAsyncSignalMemberCallbackHandler::create(myFunc, dbusSignalHandler, subscription),
+				&signalMemberHandlerInfo_);
+	} else {
+		availabilityStatusMutex_.unlock();
+	}
+}
+
 } // namespace DBus
 } // namespace CommonAPI
diff --git a/src/CommonAPI/DBus/DBusProxyBase.cpp b/src/CommonAPI/DBus/DBusProxyBase.cpp
index 56d5717..ae8faac 100644
--- a/src/CommonAPI/DBus/DBusProxyBase.cpp
+++ b/src/CommonAPI/DBus/DBusProxyBase.cpp
@@ -36,20 +36,6 @@ DBusProxyBase::getDBusConnection() const {
 }
 
 DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
-        const std::string& signalName,
-        const std::string& signalSignature,
-        DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
-        const bool justAddFilter) {
-    return addSignalMemberHandler(
-    		getDBusAddress().getObjectPath(),
-    		getDBusAddress().getInterface(),
-            signalName,
-            signalSignature,
-            dbusSignalHandler,
-            justAddFilter);
-}
-
-DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
                 const std::string& objectPath,
                 const std::string& interfaceName,
                 const std::string& signalName,
@@ -65,8 +51,25 @@ DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandle
                 justAddFilter);
 }
 
-bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken, const DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
-    return connection_->removeSignalMemberHandler(dbusSignalHandlerToken, dbusSignalHandler);
+DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
+				const std::string &objectPath,
+				const std::string &interfaceName,
+				const std::string &signalName,
+				const std::string &signalSignature,
+				const std::string &getMethodName,
+				DBusProxyConnection::DBusSignalHandler *dbusSignalHandler,
+				const bool justAddFilter) {
+    return addSignalMemberHandler(
+    			objectPath,
+				interfaceName,
+				signalName,
+				signalSignature,
+				dbusSignalHandler,
+				justAddFilter);
+}
+
+bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& _dbusSignalHandlerToken, const DBusProxyConnection::DBusSignalHandler* _dbusSignalHandler) {
+    return connection_->removeSignalMemberHandler(_dbusSignalHandlerToken, _dbusSignalHandler);
 }
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusServiceRegistry.cpp b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
index 7d12878..f18ff44 100644
--- a/src/CommonAPI/DBus/DBusServiceRegistry.cpp
+++ b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
@@ -453,15 +453,18 @@ void DBusServiceRegistry::onSignalDBusMessage(const DBusMessage &_dbusMessage) {
     dbusInputStream >> dbusObjectPath;
 
     if (_dbusMessage.hasMemberName("InterfacesAdded")) {
+        std::string dbusInterfaceName;
         dbusInterfaceNameState = DBusRecordState::AVAILABLE;
 
-        DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-        dbusInputStream >> dbusObjectPathAndInterfacesDict;
-
-        for (auto& dbusInterfaceIterator : dbusObjectPathAndInterfacesDict) {
-            const auto& dbusInterfaceName = dbusInterfaceIterator.first;
+        dbusInputStream.beginReadMapOfSerializableStructs();
+        while (!dbusInputStream.readMapCompleted()) {
+            dbusInputStream.align(8);
+            dbusInputStream >> dbusInterfaceName;
+            dbusInputStream.skipMap();
+            assert(!dbusInputStream.hasError());
             dbusInterfaceNames.insert(dbusInterfaceName);
         }
+        dbusInputStream.endReadMapOfSerializableStructs();
     } else {
         std::vector<std::string> removedDBusInterfaceNames;
 
@@ -748,7 +751,7 @@ void DBusServiceRegistry::onIntrospectCallback(const CallStatus& callStatus,
     dbusObjectPathRecord.state = DBusRecordState::RESOLVED;
     dbusObjectPathRecord.promiseOnResolve.set_value(dbusObjectPathRecord.state);
     mutexObjectPathsResolveCount.lock();
-    objectPathsToResolve++;
+    objectPathsToResolve--;
     mutexObjectPathsResolveCount.unlock();
     monitorResolveAllObjectPaths_.notify_all();
 
@@ -801,12 +804,13 @@ void DBusServiceRegistry::processIntrospectionObjectPath(const pugi::xml_node& n
 
 void DBusServiceRegistry::processIntrospectionInterface(const pugi::xml_node& node, const std::string& rootObjectPath, const std::string& fullObjectPath, const std::string& dbusServiceUniqueName) {
     std::string interfaceName = node.attribute("name").as_string();
-
     DBusUniqueNameRecord& dbusUniqueNameRecord = dbusUniqueNamesMap_[dbusServiceUniqueName];
     DBusObjectPathCache& dbusObjectPathCache = dbusUniqueNameRecord.dbusObjectPathsCache[fullObjectPath];
 
     if(!isOrgFreedesktopDBusInterface(interfaceName)) {
         dbusObjectPathCache.dbusInterfaceNamesCache.insert(interfaceName);
+    } else if (translator_->isOrgFreedesktopDBusPeerMapped() && (interfaceName == "org.freedesktop.DBus.Peer")) {
+        dbusObjectPathCache.dbusInterfaceNamesCache.insert(interfaceName);
     }
 
     for(pugi::xml_node subNode : node.children()) {
diff --git a/src/dbus-patches/capi-dbus-correct-dbus-connection-block-pending-call.patch b/src/dbus-patches/capi-dbus-correct-dbus-connection-block-pending-call.patch
new file mode 100644
index 0000000..ce17128
--- /dev/null
+++ b/src/dbus-patches/capi-dbus-correct-dbus-connection-block-pending-call.patch
@@ -0,0 +1,13 @@
+diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
+index b574207..a617457 100644
+--- a/dbus/dbus-connection.c
++++ b/dbus/dbus-connection.c
+@@ -2525,7 +2525,7 @@ _dbus_connection_block_pending_call (DBusPendingCall *pending)
+         {          
+           /* block again, we don't have the reply buffered yet. */
+           _dbus_connection_do_iteration_unlocked (connection,
+-                                                  NULL,
++                                                  pending,
+                                                   DBUS_ITERATION_DO_READING |
+                                                   DBUS_ITERATION_BLOCK,
+                                                   timeout_milliseconds - elapsed_milliseconds);
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index f6620a1..5bc063a 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -77,10 +77,9 @@ target_link_libraries(SomeOtherNameForGeneratedDBus ${LIB_LINK_LIBRARIES})
 # DBusManagedTest
 ##############################################################################
 
-##### FIXME: serviceFactory not part of CommonAPI 3.0
-##### add_executable(DBusManagedTest DBusManagedTest.cpp
-#####                               ${ManagedDBusSources})
-##### target_link_libraries(DBusManagedTest ${TEST_LINK_LIBRARIES})
+add_executable(DBusManagedTest DBusManagedTest.cpp
+                              ${ManagedDBusSources})
+target_link_libraries(DBusManagedTest ${TEST_LINK_LIBRARIES})
 
 ##############################################################################
 # DBusObjectManagerStubTest
@@ -337,7 +336,7 @@ target_link_libraries(DBusLoadTest ${TEST_LINK_LIBRARIES})
 # Add for every test a dependency to gtest
 ##############################################################################
 
-##### add_dependencies(DBusManagedTest gtest)
+add_dependencies(DBusManagedTest gtest)
 ##### add_dependencies(DBusObjectManagerStubTest gtest)
 add_dependencies(DBusMainLoopIntegrationTest gtest)
 ##### add_dependencies(DBusServiceRegistryTest gtest)
@@ -373,7 +372,7 @@ add_dependencies(DBusLoadTest gtest)
 ##### add_dependencies(build_tests CommonAPI-Fake)
 add_dependencies(build_tests DBusGen-TestInterface)
 add_dependencies(build_tests SomeOtherNameForGeneratedDBus)
-##### add_dependencies(build_tests DBusManagedTest)
+add_dependencies(build_tests DBusManagedTest)
 ##### add_dependencies(build_tests DBusObjectManagerStubTest)
 add_dependencies(build_tests DBusMainLoopIntegrationTest)
 ##### add_dependencies(build_tests DBusServiceRegistryTest)
@@ -406,7 +405,7 @@ add_dependencies(build_tests DBusLoadTest)
 # Add tests
 ##############################################################################
 
-##### add_test(NAME DBusManagedTest COMMAND DBusManagedTest)
+add_test(NAME DBusManagedTest COMMAND DBusManagedTest)
 ##### add_test(NAME DBusObjectManagerStubTest COMMAND DBusObjectManagerStubTest)
 add_test(NAME DBusMainLoopIntegrationTest COMMAND DBusMainLoopIntegrationTest)
 ##### add_test(NAME DBusServiceRegistryTest COMMAND DBusServiceRegistryTest)
diff --git a/src/test/DBusManagedTest.cpp b/src/test/DBusManagedTest.cpp
index 421b645..5c0fa12 100644
--- a/src/test/DBusManagedTest.cpp
+++ b/src/test/DBusManagedTest.cpp
@@ -21,11 +21,14 @@
 #include "v1_0/commonapi/tests/managed/RootInterfaceStubDefault.hpp"
 #include "v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.hpp"
 #include "v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.hpp"
+#include "v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp"
 
 #include "v1_0/commonapi/tests/managed/RootInterfaceProxy.hpp"
 #include "v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.hpp"
 #include "v1_0/commonapi/tests/managed/LeafInterfaceProxy.hpp"
-#include "v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp"
+
+#include "v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.hpp"
+#include "v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.hpp"
 
 #include <gtest/gtest.h>
 #include <algorithm>
@@ -34,37 +37,83 @@
 
 #define VERSION v1_0
 
+static const std::string connectionId = "managed-test";
+
 static const std::string domain = "local";
-static const std::string rootAddress = "commonapi.tests.managed.RootInterface";
-static const std::string leafInstance = "commonapi.tests.managed.RootInterface.LeafInterface";
-static const std::string branchInstance = "commonapi.tests.managed.RootInterface.BranchInterface";
-static const std::string secondLeafInstance = "commonapi.tests.managed.RootInterface.LeafInterface2";
-static const std::string leafAddress = "local:commonapi.tests.managed.LeafInterface:" + leafInstance;
-static const std::string branchAddress = "local:commonapi.tests.managed.BranchInterface:" + branchInstance;
 
-static const std::string dbusServiceName = "CommonAPI.DBus.DBusObjectManagerStubTest";
+static const std::string instanceNameBase = "commonapi.tests.managed";
+static const std::string objectPathBase = "/commonapi/tests/managed";
+
+//Root
+static const std::string rootInterfaceName = VERSION::commonapi::tests::managed::RootInterfaceStubDefault::StubInterface::getInterface();
+static const std::string rootInstanceName =  instanceNameBase + ".RootInterface";
+static const std::string rootDbusServiceName = rootInterfaceName + "_" + rootInstanceName;
+static const std::string rootDbusObjectPath = objectPathBase + "/RootInterface";
+
+//SecondRoot
+static const std::string secondRootInterfaceName = VERSION::commonapi::tests::managed::SecondRootStubDefault::StubInterface::getInterface();
+static const std::string secondRootInstanceName = instanceNameBase + ".SecondRoot";
+static const std::string secondRootDbusServiceName = secondRootInterfaceName + "_" + secondRootInstanceName;
+static const std::string secondRootDbusObjectPath = objectPathBase + "/SecondRoot";
+
+//Leaf
+static const std::string leafInterfaceName = VERSION::commonapi::tests::managed::LeafInterfaceStubDefault::StubInterface::getInterface();
+
+//Leaf based on Root
+static const std::string leafInstanceNameRoot =  rootInstanceName + ".LeafInterface";
+static const std::string leafDbusServiceNameRoot = leafInterfaceName + "_" + leafInstanceNameRoot;
+static const std::string leafDbusObjectPathRoot = rootDbusObjectPath + "/LeafInterface";
 
-static const std::string rootInterfaceName = "/commonapi/tests/managed/RootInterface";
-static const std::string rootObjectPath = "/commonapi/tests/managed/RootInterface";
+//Leaf based on SecondRoot
+static const std::string leafInstanceNameSecondRoot = secondRootInstanceName + ".LeafInterface";
+static const std::string leafDbusObjectPathSecondRoot = secondRootDbusObjectPath + "/LeafInterface";
 
+//Branch
+static const std::string branchInterfaceName = VERSION::commonapi::tests::managed::BranchInterfaceStubDefault::StubInterface::getInterface();
+static const std::string branchInstanceNameRoot = rootInstanceName + ".BranchInterface";
+static const std::string branchDbusServiceNameRoot = branchInterfaceName + "_" + branchInstanceNameRoot;
+static const std::string branchDbusObjectPathRoot = rootDbusObjectPath + "/BranchInterface";
 
-const CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict getManagedObjects(const std::string& dbusObjectPath,
-                                                                                                std::shared_ptr<CommonAPI::DBus::DBusConnection> connection) {
+
+const CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict getManagedObjects(const std::string& _dbusServiceName, const std::string& _dbusObjectPath,
+                                                                                                std::shared_ptr<CommonAPI::DBus::DBusConnection> _connection) {
     auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall(
-                    CommonAPI::DBus::DBusAddress(dbusServiceName, dbusObjectPath, CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()),
+                    CommonAPI::DBus::DBusAddress(_dbusServiceName, _dbusObjectPath, CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()),
                     "GetManagedObjects");
 
     CommonAPI::DBus::DBusError dbusError;
-    auto dbusMessageReply = connection->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError);
+    CommonAPI::CallInfo info(1000);
+    auto dbusMessageReply = _connection->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError, &info);
+
+    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
+    if(!dbusMessageReply)
+        return dbusObjectPathAndInterfacesDict;
 
     CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply);
 
-    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
     dbusInputStream >> dbusObjectPathAndInterfacesDict;
 
     return dbusObjectPathAndInterfacesDict;
 }
 
+bool isManaged(const std::string& _objectPath, const std::string& _interfaceName,
+               CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict)
+{
+    for(auto objectPathDict : dbusObjectPathAndInterfacesDict)
+    {
+        std::string objectPath = objectPathDict.first;
+        if(objectPath != _objectPath)
+            continue;
+        CommonAPI::DBus::DBusObjectManagerStub::DBusInterfacesAndPropertiesDict interfacesAndPropertiesDict = objectPathDict.second;
+        for(auto interfaceDict : interfacesAndPropertiesDict)
+        {
+            std::string interfaceName = interfaceDict.first;
+            if(interfaceName == _interfaceName)
+                return true;
+        }
+    }
+    return false;
+}
 
 class DBusManagedTest: public ::testing::Test {
 protected:
@@ -72,28 +121,18 @@ protected:
         leafStatus_ = CommonAPI::AvailabilityStatus::UNKNOWN;
         runtime_ = CommonAPI::Runtime::get();
 
-        proxyDBusConnection_ = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
-        ASSERT_TRUE(proxyDBusConnection_->connect());
-		stubDBusConnection_ = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
-        ASSERT_TRUE(stubDBusConnection_->connect());
-        ASSERT_TRUE(bool(stubDBusConnection_->getDBusObjectManager()));
-        ASSERT_TRUE(stubDBusConnection_->requestServiceNameAndBlock(dbusServiceName));
+        manualDBusConnection_ = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+        ASSERT_TRUE(manualDBusConnection_->connect(false));
     }
 
     virtual void TearDown() {
-        //runtime_->unregisterService(rootAddress);
-
-        stubDBusConnection_->disconnect();
-        stubDBusConnection_.reset();
-
-        proxyDBusConnection_->disconnect();
-        proxyDBusConnection_.reset();
+        manualDBusConnection_->disconnect();
+        manualDBusConnection_.reset();
     }
 
     std::shared_ptr<CommonAPI::Runtime> runtime_;
 
-    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyDBusConnection_;
-    std::shared_ptr<CommonAPI::DBus::DBusConnection> stubDBusConnection_;
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> manualDBusConnection_;
 
     CommonAPI::AvailabilityStatus leafStatus_;
 
@@ -105,37 +144,58 @@ public:
 
 TEST_F(DBusManagedTest, RegisterRoot) {
     auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
-	runtime_->registerService(domain, rootAddress, rootStub);
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
 
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
 
-    //runtime_->unregisterService(rootAddress);
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
 TEST_F(DBusManagedTest, RegisterLeafUnmanaged) {
-	auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-	runtime_->registerService(domain, leafAddress, leafStub);
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, leafInstanceNameRoot, leafStub));
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
+    //check that leaf is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceNameRoot,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
 
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    runtime_->unregisterService(domain, leafInterfaceName, leafInstanceNameRoot);
 
-    //runtime_->unregisterService(leafAddress);
+    //check that leaf is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceNameRoot,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
 TEST_F(DBusManagedTest, RegisterLeafManaged) {
-	auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
-	runtime_->registerService(domain, rootAddress, rootStub);
-
-	std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
-		VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
-                    rootAddress,
-                    rootInterfaceName,
-                    dbusServiceName,
-                    rootObjectPath,
-                    proxyDBusConnection_
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+        VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
                     );
 
     rootProxy->init();
@@ -148,55 +208,69 @@ TEST_F(DBusManagedTest, RegisterLeafManaged) {
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
     proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
                     std::bind(&DBusManagedTest::managedObjectSignalled,
-                                    this,
-                                    std::placeholders::_1,
-                                    std::placeholders::_2));
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
 
-	auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
 
-    bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
-    ASSERT_TRUE(reg);
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub, leafInstanceNameRoot));
 
-    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 50; ++i) {
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 200; ++i) {
         usleep(10 * 1000);
     }
     ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::AVAILABLE);
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
-    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    //check that root manages leaf
     dbusObjectPathAndInterfacesDict.clear();
-    dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
     ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
 
-    bool deregistered = rootStub->deregisterManagedStubLeafInterface(leafInstance);
-    EXPECT_TRUE(deregistered);
+    ASSERT_TRUE(rootStub->deregisterManagedStubLeafInterface(leafInstanceNameRoot));
 
     for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) {
         usleep(10 * 1000);
     }
-    EXPECT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+
+    //check that root no longer manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
-    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    //runtime_->unregisterService(rootAddress);
-    dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
-    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    proxyConnection->disconnect();
 }
 
 TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) {
-	auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
-	bool success = runtime_->registerService(domain, rootAddress, rootStub);
-    ASSERT_TRUE(success);
-
-	std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
-		VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
-                    rootAddress,
-                    rootInterfaceName,
-                    dbusServiceName,
-                    rootObjectPath,
-                    proxyDBusConnection_
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName , rootStub, connectionId));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+        VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
                     );
+
     rootProxy->init();
 
     for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
@@ -206,60 +280,82 @@ TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) {
 
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
     proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
-                    std::bind(
-                                    &DBusManagedTest::managedObjectSignalled,
-                                    this,
-                                    std::placeholders::_1,
-                                    std::placeholders::_2));
+                    std::bind(&DBusManagedTest::managedObjectSignalled,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
 
-	auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-    success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
-    ASSERT_TRUE(success);
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub, leafInstanceNameRoot));
 
-    usleep(2000000);
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::AVAILABLE);
 
-	auto leafProxy = proxyManagerLeafInterface.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(leafInstance);
-    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 500; ++i) {
+    //check that root manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    auto leafProxy = proxyManagerLeafInterface.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(leafInstanceNameRoot);
+    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 200; ++i) {
         usleep(10 * 1000);
     }
 
     ASSERT_TRUE(leafProxy->isAvailable());
 
     CommonAPI::CallStatus callStatus;
-	VERSION::commonapi::tests::managed::LeafInterface::testLeafMethodError error;
+    VERSION::commonapi::tests::managed::LeafInterface::testLeafMethodError error;
     int outInt;
     std::string outString;
     leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
 
-    EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
+    ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
+
+    ASSERT_TRUE(rootStub->deregisterManagedStubLeafInterface(leafInstanceNameRoot));
+
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
 
-    success = rootStub->deregisterManagedStubLeafInterface(leafInstance);
-    EXPECT_TRUE(success);
+    //check that root no longer manages leaf
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_);
-    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName));
 
-    //success = runtime_->unregisterService(rootAddress);
-    //EXPECT_TRUE(success);
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 
-    dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
-    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    proxyConnection->disconnect();
 }
 
 TEST_F(DBusManagedTest, PropagateTeardown) {
-	auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
-	bool success = runtime_->registerService(domain, rootAddress, rootStub);
-
-    ASSERT_TRUE(success);
-
-	std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
-		VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
-                    rootAddress,
-                    rootInterfaceName,
-                    dbusServiceName,
-                    rootObjectPath,
-                    proxyDBusConnection_
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub, connectionId));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+        VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
                     );
+
     rootProxy->init();
 
     for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
@@ -269,93 +365,129 @@ TEST_F(DBusManagedTest, PropagateTeardown) {
 
     CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface();
     proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(
-                    std::bind(
-                                    &DBusManagedTest::managedObjectSignalled,
-                                    this,
-                                    std::placeholders::_1,
-                                    std::placeholders::_2));
+                    std::bind(&DBusManagedTest::managedObjectSignalled,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
 
-	auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-    bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
-    ASSERT_TRUE(reg);
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub, leafInstanceNameRoot));
 
-    usleep(2000000);
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::AVAILABLE);
+
+    //check that root manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
 
-	auto leafProxy = proxyManagerLeafInterface.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(leafInstance);
+    auto leafProxy = proxyManagerLeafInterface.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(leafInstanceNameRoot);
 
-    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 500; ++i) {
+    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 200; ++i) {
         usleep(10 * 1000);
     }
 
     ASSERT_TRUE(leafProxy->isAvailable());
 
     CommonAPI::CallStatus callStatus;
-	VERSION::commonapi::tests::managed::LeafInterface::testLeafMethodError error;
+    VERSION::commonapi::tests::managed::LeafInterface::testLeafMethodError error;
     int outInt;
     std::string outString;
     leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
 
     ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
 
-    //bool dereg = runtime_->unregisterService(rootAddress);
-    //ASSERT_TRUE(dereg);
+    rootStub->getStubAdapter()->deactivateManagedInstances();
 
-    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 100; ++i) {
+    for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) {
         usleep(10 * 1000);
     }
     ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_);
+    //check that root no longer manages leaf
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
     ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root is still registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, "/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
 }
 
 class DBusManagedTestExtended: public ::testing::Test {
 protected:
     virtual void SetUp() {
         runtime_ = CommonAPI::Runtime::get();
+
         leafInstanceAvailability = CommonAPI::AvailabilityStatus::UNKNOWN;
         branchInstanceAvailability = CommonAPI::AvailabilityStatus::UNKNOWN;
 
-        manualTestDBusConnection_ = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
-        ASSERT_TRUE(manualTestDBusConnection_->connect());
-
-		auto stubDBusConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
-        ASSERT_TRUE(stubDBusConnection->connect());
-        ASSERT_TRUE(stubDBusConnection->requestServiceNameAndBlock(dbusServiceName));
+        manualDBusConnection_ = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+        ASSERT_TRUE(manualDBusConnection_->connect(false));
     }
 
     virtual void TearDown() {
-        for (auto it: rootStubs_) {
-            //runtime_->unregisterService(it.first);
-        }
+        manualDBusConnection_->disconnect();
+        manualDBusConnection_.reset();
+    }
+
+    inline const std::string getSuffixedRootInstanceName(const std::string& suffix) {
+        return rootInstanceName + suffix;
+    }
 
-        rootStubs_.clear();
-        rootProxies_.clear();
+    inline bool registerRootStubForSuffix(const std::string& suffix) {
+        auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+        const std::string instanceName = getSuffixedRootInstanceName(suffix);
+        bool registered = runtime_->registerService(domain, instanceName, rootStub);
 
-		auto stubDBusConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
-        ASSERT_TRUE(stubDBusConnection->releaseServiceName(dbusServiceName));
+        if(registered)
+            rootStubs_.insert( { instanceName, rootStub });
 
-        usleep(50000);
+        return registered;
     }
 
-    inline const std::string getSuffixedRootAddress(const std::string& suffix) {
-        return "local:commonapi.tests.managed.RootInterface" + suffix + ":commonapi.tests.managed.RootInterface";
-    }
+    inline bool unregisterRootForSuffix(const std::string& suffix) {
+        const std::string instanceName = getSuffixedRootInstanceName(suffix);
 
-    inline const std::string getSuffixedSecondRootAddress(const std::string& suffix) {
-        return "local:commonapi.tests.managed.SecondRoot" + suffix + ":commonapi.tests.managed.SecondRoot";
-    }
+        std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceStubDefault> rootStub = rootStubs_.find(instanceName)->second;
+        rootStub->getStubAdapter()->deactivateManagedInstances();
+
+        bool unregistered = runtime_->unregisterService(domain, rootInterfaceName, instanceName);
 
-    inline const bool registerRootStubForSuffix(const std::string& suffix) {
-		std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceStubDefault> rootStub = std::make_shared<
-			VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
-        const std::string rootAddress = getSuffixedRootAddress(suffix);
-        rootStubs_.insert( {rootAddress, rootStub} );
-		return runtime_->registerService(domain, rootAddress, rootStub);
+        if(unregistered)
+            rootStubs_.erase(instanceName);
+
+        return unregistered;
     }
 
     inline void createRootProxyForSuffix(const std::string& suffix) {
-		rootProxies_.push_back(runtime_->buildProxy<VERSION::commonapi::tests::managed::RootInterfaceProxy>(domain, getSuffixedRootAddress(suffix)));
+        CommonAPI::DBus::DBusAddress rootDBusAddress;
+        CommonAPI::Address rootCommonAPIAddress(domain, getSuffixedRootInstanceName(suffix), rootInterfaceName);
+        CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+        std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+        proxyConnection->connect();
+
+        std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+            VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                        rootDBusAddress,
+                        proxyConnection
+                        );
+        rootProxy->init();
+        rootProxies_.push_back(rootProxy);
     }
 
     template<typename _ProxyType>
@@ -372,18 +504,13 @@ protected:
         return allAreAvailable;
     }
 
-    bool registerXLeafStubsForAllRoots(uint32_t x, bool doSubscriptionsForLeafNotifications) {
+    bool registerXLeafStubsForAllRoots(uint32_t x) {
         bool success = true;
         bool expectedValueForRegistration = true;
         for (auto rootStubIterator: rootStubs_) {
-            if (doSubscriptionsForLeafNotifications) {
-                // CommonAPI::ProxyManager& proxyManagerForLeafInterface = rootManagerProxyArray[i]->getProxyManagerLeafInterface();
-                // auto subscription = subscribeWithAvailabilityFlag(proxyManagerForLeafInterface, stati[i]);
-                // subscriptions.push_back(subscription);
-            }
             for (uint32_t i = 0; i < x; i++) {
-				std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault> leafStub = std::make_shared<
-					VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+                std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault> leafStub = std::make_shared<
+                    VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
                 success &= (rootStubIterator.second->registerManagedStubLeafInterfaceAutoInstance(leafStub) == expectedValueForRegistration);
             }
             //As all root interfaces are registered on the same object path, the leaf interfaces also will be registered with
@@ -398,7 +525,7 @@ protected:
 
     void createXLeafProxiesForAllExistingLeafs() {
         for (auto rootProxyIterator : rootProxies_) {
-			std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceProxyDefault>> leafProxiesForRootX;
+            std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceProxyDefault>> leafProxiesForRootX;
 
             CommonAPI::ProxyManager& leafProxyManager = rootProxyIterator->getProxyManagerLeafInterface();
             std::vector<std::string> availableInstances;
@@ -406,20 +533,20 @@ protected:
             leafProxyManager.getAvailableInstances(status, availableInstances);
 
             for (const std::string& availableInstance : availableInstances) {
-				auto newLeafProxy = leafProxyManager.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(availableInstance);
+                auto newLeafProxy = leafProxyManager.buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(availableInstance);
                 leafProxiesForRootX.push_back(newLeafProxy);
             }
             leafProxies_.push_back(std::move(leafProxiesForRootX));
-        }
+         }
     }
 
     std::shared_ptr<CommonAPI::Runtime> runtime_;
 
-    std::shared_ptr<CommonAPI::DBus::DBusConnection> manualTestDBusConnection_;
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> manualDBusConnection_;
 
-	std::unordered_map<std::string, std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>> rootStubs_;
-	std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceProxyDefault>> rootProxies_;
-	std::vector<std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceProxyDefault>>>leafProxies_;
+    std::unordered_map<std::string, std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>> rootStubs_;
+    std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>> rootProxies_;
+    std::vector<std::vector<std::shared_ptr<VERSION::commonapi::tests::managed::LeafInterfaceProxyDefault>>> leafProxies_;
 
     CommonAPI::AvailabilityStatus leafInstanceAvailability;
     CommonAPI::AvailabilityStatus branchInstanceAvailability;
@@ -433,22 +560,94 @@ public:
     }
 };
 
-TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPath) {
+/*
+ * Test fails. Registering several roots on same object path is not possible.
+ */
+TEST_F(DBusManagedTestExtended, DISABLED_RegisterSeveralRootsOnSameObjectPath) {
+
+    /* set environment variable (default config: commonapi-dbus.ini) to
+     * to register the roots on the same object path
+     */
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
     ASSERT_TRUE(registerRootStubForSuffix("One"));
     ASSERT_TRUE(registerRootStubForSuffix("Two"));
     ASSERT_TRUE(registerRootStubForSuffix("Three"));
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    const std::string dbusServiceNameBase = "commonapi.tests.managed.roots.on.same.object.path";
+
+    //check that root one is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root two is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root three is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    ASSERT_TRUE(unregisterRootForSuffix("One"));
+    ASSERT_TRUE(unregisterRootForSuffix("Two"));
+    ASSERT_TRUE(unregisterRootForSuffix("Three"));
+
+    //check that root one is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root two is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root three is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
 }
 
-TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPathAndCommunicate) {
+/*
+ * Test fails. Registering several roots on same object path is not possible.
+ */
+TEST_F(DBusManagedTestExtended, DISABLED_RegisterSeveralRootsOnSameObjectPathAndCommunicate) {
+
+    /* set environment variable (default config: commonapi-dbus.ini) to
+     * to register the roots on the same object path
+     */
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
     ASSERT_TRUE(registerRootStubForSuffix("One"));
     ASSERT_TRUE(registerRootStubForSuffix("Two"));
     ASSERT_TRUE(registerRootStubForSuffix("Three"));
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    const std::string dbusServiceNameBase = "commonapi.tests.managed.roots.on.same.object.path";
+
+    //check that root one is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root two is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root three is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
 
     createRootProxyForSuffix("One");
     createRootProxyForSuffix("Two");
@@ -458,7 +657,8 @@ TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPathAndCommunica
     ASSERT_TRUE(allRootProxiesAreAvailable);
 
     CommonAPI::CallStatus callStatus;
-	VERSION::commonapi::tests::managed::RootInterface::testRootMethodError applicationError;
+    CommonAPI::CallInfo *info;
+    VERSION::commonapi::tests::managed::RootInterface::testRootMethodError applicationError;
     int32_t outInt;
     std::string outString;
 
@@ -468,48 +668,141 @@ TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPathAndCommunica
                                         callStatus,
                                         applicationError,
                                         outInt,
-                                        outString);
-        EXPECT_EQ(CommonAPI::CallStatus::SUCCESS, callStatus);
+                                        outString,
+                                        info);
+        ASSERT_EQ(CommonAPI::CallStatus::SUCCESS, callStatus);
     }
+
+    ASSERT_TRUE(unregisterRootForSuffix("One"));
+    ASSERT_TRUE(unregisterRootForSuffix("Two"));
+    ASSERT_TRUE(unregisterRootForSuffix("Three"));
+
+    //check that root one is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root two is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root three is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    rootProxies_.clear();
 }
 
-TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPath) {
+/*
+ * Test fails. Registering several roots on same object path is not possible.
+ */
+TEST_F(DBusManagedTestExtended, DISABLED_RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPath) {
+
+    /* set environment variable (default config: commonapi-dbus.ini) to
+     * to register the roots on the same object path
+     */
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
     ASSERT_TRUE(registerRootStubForSuffix("One"));
     ASSERT_TRUE(registerRootStubForSuffix("Two"));
     ASSERT_TRUE(registerRootStubForSuffix("Three"));
 
-    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false);
+    const std::string dbusServiceNameBase = "commonapi.tests.managed.roots.on.same.object.path";
+
+    //check that root one is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root two is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that root three is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5);
     ASSERT_TRUE(allLeafStubsWereRegistered);
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    //TODO check if leafs were registered
+
+    ASSERT_TRUE(unregisterRootForSuffix("One"));
+    ASSERT_TRUE(unregisterRootForSuffix("Two"));
+    ASSERT_TRUE(unregisterRootForSuffix("Three"));
+
+    //check that root one is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root two is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root three is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three","/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
-TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPathAndCommunicate) {
+/*
+ * Test fails. Registering several roots on same object path is not possible.
+ */
+TEST_F(DBusManagedTestExtended, DISABLED_RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPathAndCommunicate) {
+
+    /* set environment variable (default config: commonapi-dbus.ini) to
+     * to register the roots on the same object path
+     */
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
     ASSERT_TRUE(registerRootStubForSuffix("One"));
     ASSERT_TRUE(registerRootStubForSuffix("Two"));
     ASSERT_TRUE(registerRootStubForSuffix("Three"));
 
-    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false);
-    ASSERT_TRUE(allLeafStubsWereRegistered);
+    const std::string dbusServiceNameBase = "commonapi.tests.managed.roots.on.same.object.path";
 
-    auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_);
-    EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    //check that root one is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One", "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName,dbusObjectPathAndInterfacesDict));
+
+    //check that root two is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two", "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName,dbusObjectPathAndInterfacesDict));
+
+    //check that root three is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three", "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName,dbusObjectPathAndInterfacesDict));
 
     createRootProxyForSuffix("One");
     createRootProxyForSuffix("Two");
     createRootProxyForSuffix("Three");
 
-    //Check on existence of leaf-stubs
-
     bool allRootProxiesAreAvailable = waitForAllProxiesToBeAvailable(rootProxies_);
     ASSERT_TRUE(allRootProxiesAreAvailable);
 
-    usleep(500 * 1000);
+    bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5);
+    ASSERT_TRUE(allLeafStubsWereRegistered);
+
+    //TODO check if leafs were registered
 
     createXLeafProxiesForAllExistingLeafs();
 
-    usleep(500 * 1000);
+    usleep(50000);
 
     ASSERT_EQ(3, leafProxies_.size());
 
@@ -518,76 +811,126 @@ TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSame
         ASSERT_EQ(5, leafProxiesForCurrentRoot.size())<< "in run #" << runNr++;
 
         bool allLeafProxiesForCurrentRootAreAvailable = waitForAllProxiesToBeAvailable(leafProxiesForCurrentRoot);
-        EXPECT_TRUE(allLeafProxiesForCurrentRootAreAvailable);
+        ASSERT_TRUE(allLeafProxiesForCurrentRootAreAvailable);
 
         ++runNr;
     }
 
-//    CommonAPI::AvailabilityStatus stati[3];
-//    std::vector<CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent::Subscription> subscriptions;
-
-    //    auto leafStub = std::make_shared<commonapi::tests::managed::LeafInterfaceStubDefault>();
-    //    bool success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance);
-    //    ASSERT_TRUE(success);
-    //
-    //    sleep(2);
-    //
-    //    auto leafProxy = proxyManagerLeafInterface.buildProxy<commonapi::tests::managed::LeafInterfaceProxy>(leafInstance);
-    //    for (uint32_t i = 0; !leafProxy->isAvailable() && i < 500; ++i) {
-    //        usleep(10 * 1000);
-    //    }
-    //
-    //    ASSERT_TRUE(leafProxy->isAvailable());
-    //
-    //    CommonAPI::CallStatus callStatus;
-    //    commonapi::tests::managed::LeafInterface::testLeafMethodError error;
-    //    int outInt;
-    //    std::string outString;
-    //    leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
-    //
-    //    EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
-    //
-    //    success = rootStub->deregisterManagedStubLeafInterface(leafInstance);
-    //    EXPECT_TRUE(success);
-    //
-    //    CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
-    //    dbusObjectPathAndInterfacesDict.clear();
-    //    getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict);
-    //    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
-    //
-    //    success = runtime->getServicePublisher()->unregisterService(rootAddress);
-    //    EXPECT_TRUE(success);
-    //
-    //    dbusObjectPathAndInterfacesDict.clear();
-    //    getManagedObjects("/", dbusObjectPathAndInterfacesDict);
-    //    EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(unregisterRootForSuffix("One"));
+    ASSERT_TRUE(unregisterRootForSuffix("Two"));
+    ASSERT_TRUE(unregisterRootForSuffix("Three"));
+
+    //check that root one is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".One", "/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root two is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Two", "/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that root three is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(dbusServiceNameBase + ".Three", "/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    rootProxies_.clear();
+    leafProxies_.clear();
 }
 
 TEST_F(DBusManagedTestExtended, RegisterTwoRootsForSameLeafInterface) {
-    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    auto secondRootStub = std::make_shared<VERSION::commonapi::tests::managed::SecondRootStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, secondRootInstanceName, secondRootStub));
 
-	std::shared_ptr<VERSION::commonapi::tests::managed::SecondRootStubDefault> secondRootStub = std::make_shared<
-		VERSION::commonapi::tests::managed::SecondRootStubDefault>();
-    const std::string rootAddressLocal = getSuffixedRootAddress("Two");
-    runtime_->registerService(secondRootStub, rootAddressLocal, serviceFactory_);
+    //check that second root is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(secondRootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(secondRootDbusObjectPath, secondRootInterfaceName, dbusObjectPathAndInterfacesDict));
 
-	auto leafStub1 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-	auto leafStub2 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto leafStub1 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto leafStub2 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
 
-    bool leafStub1Registered = rootStubs_.begin()->second->registerManagedStubLeafInterface(leafStub1, leafInstance);
-    ASSERT_TRUE(leafStub1Registered);
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub1, leafInstanceNameRoot));
+    ASSERT_TRUE(secondRootStub->registerManagedStubLeafInterface(leafStub2, leafInstanceNameSecondRoot));
 
-    bool leafStub2Registered = secondRootStub->registerManagedStubLeafInterface(leafStub2, secondLeafInstance);
-    ASSERT_TRUE(leafStub2Registered);
+    //check that root manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
 
-    runtime_->unregisterService(rootAddressLocal);
+    //check that second root manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(secondRootDbusServiceName, secondRootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathSecondRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+    secondRootStub->getStubAdapter()->deactivateManagedInstances();
+
+    //check that root no longer manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that second root no longer manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(secondRootDbusServiceName, secondRootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+    runtime_->unregisterService(domain, secondRootInterfaceName, secondRootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that second root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(secondRootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
 }
 
 TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootManaged) {
-    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+        VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
+                    );
+
+    rootProxy->init();
+
+    for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(rootProxy->isAvailable());
 
-    createRootProxyForSuffix("One");
-    auto rootProxy = *(rootProxies_.begin());
     CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& leafInstanceAvailabilityStatusEvent =
                     rootProxy->getProxyManagerLeafInterface().getInstanceAvailabilityStatusChangedEvent();
     CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& branchInstanceAvailabilityStatusEvent =
@@ -604,11 +947,11 @@ TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootMan
                               std::placeholders::_1,
                               std::placeholders::_2));
 
-	auto leafStub1 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-	auto leafStub2 = std::make_shared<VERSION::commonapi::tests::managed::BranchInterfaceStubDefault>();
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto branchStub = std::make_shared<VERSION::commonapi::tests::managed::BranchInterfaceStubDefault>();
+
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub, leafInstanceNameRoot));
 
-    bool leafStub1Registered = rootStubs_.begin()->second->registerManagedStubLeafInterface(leafStub1, leafInstance);
-    ASSERT_TRUE(leafStub1Registered);
     usleep(50000);
 
     ASSERT_EQ(CommonAPI::AvailabilityStatus::AVAILABLE, leafInstanceAvailability);
@@ -616,20 +959,70 @@ TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootMan
     // check that event for branch instances is not triggered by leaf instances
     ASSERT_NE(CommonAPI::AvailabilityStatus::AVAILABLE, branchInstanceAvailability);
 
-    bool leafStub2Registered = rootStubs_.begin()->second->registerManagedStubBranchInterface(
-                    leafStub2,
-                    branchInstance);
-    ASSERT_TRUE(leafStub2Registered);
+    ASSERT_TRUE(rootStub->registerManagedStubBranchInterface(branchStub, branchInstanceNameRoot));
+
     usleep(50000);
 
     ASSERT_EQ(CommonAPI::AvailabilityStatus::AVAILABLE, branchInstanceAvailability);
+
+    //check that root manages leaf and branch
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+    ASSERT_TRUE(isManaged(branchDbusObjectPathRoot, branchInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+
+    usleep(50000);
+
+    ASSERT_TRUE(leafInstanceAvailability == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+    ASSERT_TRUE(branchInstanceAvailability == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+
+    //check that root no longer manages leaf and branch
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
 }
 
 TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootUnmanaged) {
-    ASSERT_TRUE(registerRootStubForSuffix("One"));
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+            VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
+                    );
+
+    rootProxy->init();
+
+    for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(rootProxy->isAvailable());
 
-    createRootProxyForSuffix("One");
-    auto rootProxy = *(rootProxies_.begin());
     CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& leafInstanceAvailabilityStatusEvent =
                     rootProxy->getProxyManagerLeafInterface().getInstanceAvailabilityStatusChangedEvent();
     CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& branchInstanceAvailabilityStatusEvent =
@@ -646,11 +1039,11 @@ TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootUnm
                               std::placeholders::_1,
                               std::placeholders::_2));
 
-	auto leafStub1 = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
-    runtime_->getServicePublisher()->registerService(leafStub1, leafAddress, serviceFactory_);
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    runtime_->registerService(domain, leafInstanceNameRoot, leafStub);
 
-	auto leafStub2 = std::make_shared<VERSION::commonapi::tests::managed::BranchInterfaceStubDefault>();
-    runtime_->getServicePublisher()->registerService(leafStub2, branchAddress, serviceFactory_);
+    auto branchStub = std::make_shared<VERSION::commonapi::tests::managed::BranchInterfaceStubDefault>();
+    runtime_->registerService(domain, branchInstanceNameRoot, branchStub);
 
     usleep(50000);
 
@@ -658,8 +1051,430 @@ TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootUnm
     ASSERT_EQ(CommonAPI::AvailabilityStatus::UNKNOWN, leafInstanceAvailability);
     ASSERT_EQ(CommonAPI::AvailabilityStatus::UNKNOWN, branchInstanceAvailability);
 
-    runtime_->unregisterService(leafAddress);
-    runtime_->unregisterService(branchAddress);
+    //check that root don't manages leaf and branch
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that leaf is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceNameRoot, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that branch is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(branchDbusServiceNameRoot, "/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(branchDbusObjectPathRoot, branchInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    runtime_->unregisterService(domain, leafInterfaceName, leafInstanceNameRoot);
+    runtime_->unregisterService(domain, branchInterfaceName, branchInstanceNameRoot);
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that leaf is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceNameRoot,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that branch is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(branchDbusServiceNameRoot,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
+}
+
+TEST_F(DBusManagedTestExtended, RegisterInvalidChildInstance)
+{
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    auto invalidLeafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+
+    const std::string invalidLeafInstanceName =  instanceNameBase + ".InvalidInterface.LeafInterface";
+    const std::string invalidLeafDbusServiceName = leafInterfaceName + "_" + invalidLeafInstanceName;
+
+    ASSERT_FALSE(rootStub->registerManagedStubLeafInterface(invalidLeafStub, invalidLeafInstanceName));
+
+    //check that root doesn't manage invalid leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that invalid leaf is not registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(invalidLeafDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+}
+
+TEST_F(DBusManagedTestExtended, RegsiterInvalidChildInstanceAndValidChildInstances)
+{
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+            VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
+                    );
+
+    rootProxy->init();
+
+    for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(rootProxy->isAvailable());
+
+    CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& leafInstanceAvailabilityStatusEvent =
+                    rootProxy->getProxyManagerLeafInterface().getInstanceAvailabilityStatusChangedEvent();
+    CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& branchInstanceAvailabilityStatusEvent =
+                    rootProxy->getProxyManagerBranchInterface().getInstanceAvailabilityStatusChangedEvent();
+
+    leafInstanceAvailabilityStatusEvent.subscribe(
+                    std::bind(&DBusManagedTestExtended::onLeafInstanceAvailabilityStatusChanged,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
+    branchInstanceAvailabilityStatusEvent.subscribe(
+                    std::bind(&DBusManagedTestExtended::onBranchInstanceAvailabilityStatusChanged,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
+
+    auto validLeafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto invalidLeafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    auto validBranchStub = std::make_shared<VERSION::commonapi::tests::managed::BranchInterfaceStubDefault>();
+
+    const std::string invalidLeafInstanceName = instanceNameBase + ".InvalidInterface.LeafInterface";
+    const std::string invalidLeafDbusServiceName = leafInterfaceName + "_" + invalidLeafInstanceName;
+    const std::string invalidLeafDbusObjectPath = objectPathBase + "/InvalidInterface/LeafInterface";
+
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(validLeafStub, leafInstanceNameRoot));
+
+    usleep(50000);
+
+    ASSERT_EQ(CommonAPI::AvailabilityStatus::AVAILABLE, leafInstanceAvailability);
+
+    ASSERT_FALSE(rootStub->registerManagedStubLeafInterface(invalidLeafStub, invalidLeafInstanceName));
+
+    //check that root doesn't manage invalid leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_FALSE(isManaged(invalidLeafDbusObjectPath, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    //check that invalid leaf is not registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(invalidLeafDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    ASSERT_TRUE(rootStub->registerManagedStubBranchInterface(validBranchStub, branchInstanceNameRoot));
+
+    usleep(50000);
+
+    ASSERT_EQ(CommonAPI::AvailabilityStatus::AVAILABLE, branchInstanceAvailability);
+
+    //check that root manages valid leaf and valid branch
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPathRoot, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+    ASSERT_TRUE(isManaged(branchDbusObjectPathRoot, branchInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+
+    usleep(50000);
+
+    ASSERT_TRUE(leafInstanceAvailability == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+    ASSERT_TRUE(branchInstanceAvailability == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+
+    //check that root no longer manages leaf and branch
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
+}
+
+TEST_F(DBusManagedTestExtended, ReegisterLeafsWithAutoGeneratedInstanceIds)
+{
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    int numberOfAutoGeneratedInstances = 5;
+    for(int i=0; i<numberOfAutoGeneratedInstances; i++)
+    {
+        ASSERT_TRUE(rootStub->registerManagedStubLeafInterfaceAutoInstance(leafStub));
+    }
+
+    //check that root manages the auto generated leafs
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE((int)dbusObjectPathAndInterfacesDict.size() == numberOfAutoGeneratedInstances);
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+
+    //check that root doesn't manage the auto generated leafs anymore
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+}
+
+TEST_F(DBusManagedTestExtended, RegisterLeafsWithAutoGeneratedInstanceIdsAndCommunicate)
+{
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub, connectionId));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+        VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
+                    );
+
+    rootProxy->init();
+
+    for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(rootProxy->isAvailable());
+
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+    int numberOfAutoGeneratedInstances = 5;
+    for(int i=0; i<numberOfAutoGeneratedInstances; i++)
+    {
+        ASSERT_TRUE(rootStub->registerManagedStubLeafInterfaceAutoInstance(leafStub));
+    }
+
+    //check that root manages the auto generated leafs
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE((int)dbusObjectPathAndInterfacesDict.size() == numberOfAutoGeneratedInstances);
+
+    for(int i=0; i<numberOfAutoGeneratedInstances; i++)
+    {
+        const std::string autoGeneratedInstanceName = rootInstanceName + ".i" + std::to_string(i + 1);
+        auto leafProxy = rootProxy->getProxyManagerLeafInterface().buildProxy<VERSION::commonapi::tests::managed::LeafInterfaceProxy>(autoGeneratedInstanceName);
+
+        for (uint32_t i = 0; !leafProxy->isAvailable() && i < 200; ++i) {
+            usleep(10 * 1000);
+        }
+
+        ASSERT_TRUE(leafProxy->isAvailable());
+
+        CommonAPI::CallStatus callStatus;
+        VERSION::commonapi::tests::managed::LeafInterface::testLeafMethodError error;
+        int outInt;
+        std::string outString;
+        leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString);
+
+        ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS);
+    }
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+
+    //check that root doesn't manage the auto generated leafs anymore
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
+}
+
+TEST_F(DBusManagedTestExtended, ConfigurationFileAffectsInterfaceUnmanaged) {
+
+    //set environment variable (default config: commonapi-dbus.ini)
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+
+    //match with declared addresses in commonapi-dbus.ini
+    const std::string leafInstanceName = "commonapi.tests.managed.config.affects.LeafInterface.Unmanaged";
+    const std::string leafDbusServiceName = "commonapi.tests.managed.config.affects.interface.unmanaged";
+    const std::string leafDbusObjectPath = "/commonapi/tests/managed/RootInterface/LeafInterface/Unmanaged";
+
+    ASSERT_TRUE(runtime_->registerService(domain, leafInstanceName, leafStub));
+
+    //check that leaf is registered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPath, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+    runtime_->unregisterService(domain, leafInterfaceName, leafInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    //check that leaf is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(leafDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+}
+
+TEST_F(DBusManagedTestExtended, ConfigurationFileAffectsInterfaceManaged) {
+
+    //set environment variable (default config: commonapi-dbus.ini)
+    const char *defaultConfigSet = getenv("COMMONAPI_DBUS_DEFAULT_CONFIG");
+    ASSERT_TRUE(defaultConfigSet);
+
+    auto rootStub = std::make_shared<VERSION::commonapi::tests::managed::RootInterfaceStubDefault>();
+    ASSERT_TRUE(runtime_->registerService(domain, rootInstanceName, rootStub));
+
+    //check that root is registered
+    auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(rootDbusObjectPath, rootInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    CommonAPI::DBus::DBusAddress rootDBusAddress;
+    CommonAPI::Address rootCommonAPIAddress(domain, rootInstanceName, rootInterfaceName);
+    CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress);
+
+    std::shared_ptr<CommonAPI::DBus::DBusConnection> proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION);
+    proxyConnection->connect();
+
+    std::shared_ptr<VERSION::commonapi::tests::managed::RootInterfaceDBusProxy> rootProxy = std::make_shared<
+            VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>(
+                    rootDBusAddress,
+                    proxyConnection
+                    );
+
+    rootProxy->init();
+
+    for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) {
+        usleep(10 * 1000);
+    }
+    ASSERT_TRUE(rootProxy->isAvailable());
+
+    CommonAPI::ProxyManager::InstanceAvailabilityStatusChangedEvent& leafInstanceAvailabilityStatusEvent =
+                    rootProxy->getProxyManagerLeafInterface().getInstanceAvailabilityStatusChangedEvent();
+
+    leafInstanceAvailabilityStatusEvent.subscribe(
+                    std::bind(&DBusManagedTestExtended::onLeafInstanceAvailabilityStatusChanged,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
+
+    auto leafStub = std::make_shared<VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>();
+
+    //match with declared addresses in commonapi-dbus.ini
+    const std::string leafInstanceName = "commonapi.tests.managed.config.affects.LeafInterface.Managed";
+    const std::string leafDbusServiceName = "commonapi.tests.managed.config.affects.interface.managed";
+    const std::string leafDbusObjectPath = "/commonapi/tests/managed/RootInterface/LeafInterface/Managed";
+
+    ASSERT_TRUE(rootStub->registerManagedStubLeafInterface(leafStub, leafInstanceName));
+
+    usleep(50000);
+
+    ASSERT_EQ(CommonAPI::AvailabilityStatus::AVAILABLE, leafInstanceAvailability);
+
+    //check that root manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty());
+    ASSERT_TRUE(isManaged(leafDbusObjectPath, leafInterfaceName, dbusObjectPathAndInterfacesDict));
+
+    rootStub->getStubAdapter()->deactivateManagedInstances();
+
+    usleep(50000);
+
+    ASSERT_TRUE(leafInstanceAvailability == CommonAPI::AvailabilityStatus::NOT_AVAILABLE);
+
+    //check that root no longer manages leaf
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName, rootDbusObjectPath, manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    runtime_->unregisterService(domain, rootInterfaceName, rootInstanceName);
+
+    //check that root is unregistered
+    dbusObjectPathAndInterfacesDict.clear();
+    dbusObjectPathAndInterfacesDict = getManagedObjects(rootDbusServiceName,"/", manualDBusConnection_);
+    ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty());
+
+    proxyConnection->disconnect();
 }
 
 #ifndef __NO_MAIN__
diff --git a/src/test/DBusObjectManagerStubTest.cpp b/src/test/DBusObjectManagerStubTest.cpp
index fa8a796..694887a 100644
--- a/src/test/DBusObjectManagerStubTest.cpp
+++ b/src/test/DBusObjectManagerStubTest.cpp
@@ -139,14 +139,16 @@ private:
                         CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(),
                         "InterfacesAdded",
                         "oa{sa{sv}}",
-                        this);
+                        this,
+                        false);
 
         dbusSignalHandlerRemovedToken_ = dbusConnection_->addSignalMemberHandler(
                         dbusObjectPath_,
                         CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(),
                         "InterfacesRemoved",
                         "oas",
-                        this);
+                        this,
+                        false);
     }
 
     std::string dbusObjectPath_;
diff --git a/src/test/commonapi-dbus.ini b/src/test/commonapi-dbus.ini
index ac1c897..45df7e2 100644
--- a/src/test/commonapi-dbus.ini
+++ b/src/test/commonapi-dbus.ini
@@ -39,3 +39,28 @@ path=/only/object/path
 service=fake.legacy.service.connection
 path=/some/legacy/path/6259504
 interface=fake.legacy.service.LegacyInterface
+
+[local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterfaceOne]
+service=commonapi.tests.managed.roots.on.same.object.path.RootInterfaceOne
+path=/commonapi/tests/managed/RootInterface
+interface=commonapi.tests.managed.RootInterface
+
+[local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterfaceTwo]
+service=commonapi.tests.managed.roots.on.same.object.path.RootInterfaceTwo
+path=/commonapi/tests/managed/RootInterface
+interface=commonapi.tests.managed.RootInterface
+
+[local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterfaceThree]
+service=commonapi.tests.managed.roots.on.same.object.path.RootInterfaceThree
+path=/commonapi/tests/managed/RootInterface
+interface=commonapi.tests.managed.RootInterface
+
+[local:commonapi.tests.managed.LeafInterface:commonapi.tests.managed.config.affects.LeafInterface.Unmanaged]
+service=commonapi.tests.managed.config.affects.interface.unmanaged
+path=/commonapi/tests/managed/RootInterface/LeafInterface/Unmanaged
+interface=commonapi.tests.managed.LeafInterface
+
+[local:commonapi.tests.managed.LeafInterface:commonapi.tests.managed.config.affects.LeafInterface.Managed]
+service=commonapi.tests.managed.config.affects.interface.managed
+path=/commonapi/tests/managed/RootInterface/LeafInterface/Managed
+interface=commonapi.tests.managed.LeafInterface
diff --git a/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.cpp b/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.cpp
index f1e1b69..46c9704 100644
--- a/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.cpp
+++ b/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -27,7 +27,7 @@ std::shared_ptr<DerivedTypeCollection::TestPolymorphicStruct> DerivedTypeCollect
 	switch (_serial) {
 	case DerivedTypeCollection::TESTPOLYMORPHICSTRUCT_SERIAL:
 		return std::make_shared<DerivedTypeCollection::TestPolymorphicStruct>();
-	case DerivedTypeCollection::TESTEXTENDEDPOLYMORPHICSTRUCT_SERIAL:
+	case TESTEXTENDEDPOLYMORPHICSTRUCT_SERIAL:
 		return std::make_shared<DerivedTypeCollection::TestExtendedPolymorphicStruct>();
 	default:
 		break;
diff --git a/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.hpp b/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.hpp
index 70675c4..90589dc 100644
--- a/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.hpp
+++ b/src/test/src-gen/core/commonapi/tests/DerivedTypeCollection.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -59,7 +59,7 @@ struct DerivedTypeCollection {
     
     };
     typedef std::vector<TestStruct> TestArrayTestStruct;
-    typedef std::unordered_map<uint32_t, TestArrayTestStruct> TestMap;
+    typedef std::unordered_map<uint32_t, ::commonapi::tests::DerivedTypeCollection::TestArrayTestStruct> TestMap;
     /**
      * description: Common errors.
      */
@@ -178,7 +178,7 @@ struct DerivedTypeCollection {
     	}
     
     };
-    typedef std::unordered_map<TestEnum, std::string, CommonAPI::EnumHasher<TestEnum>> TestEnumMap;
+    typedef std::unordered_map<::commonapi::tests::DerivedTypeCollection::TestEnum, std::string, CommonAPI::EnumHasher<::commonapi::tests::DerivedTypeCollection::TestEnum>> TestEnumMap;
     
     struct TestEnumMissingValue : CommonAPI::Enumeration<int32_t> {
         enum Literal : int32_t {
diff --git a/src/test/src-gen/core/commonapi/tests/PredefinedTypeCollection.hpp b/src/test/src-gen/core/commonapi/tests/PredefinedTypeCollection.hpp
index cfcdb44..b9f894a 100644
--- a/src/test/src-gen/core/commonapi/tests/PredefinedTypeCollection.hpp
+++ b/src/test/src-gen/core/commonapi/tests/PredefinedTypeCollection.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterface.hpp
index 2bf3f5c..219ef38 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxy.hpp
index 66951e6..36d9fc0 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -51,7 +51,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestIntMethodExtended with asynchronous semantics.
      * 
@@ -114,8 +114,8 @@ ExtendedInterfaceProxy<_AttributeExtensions...>::~ExtendedInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void ExtendedInterfaceProxy<_AttributeExtensions...>::TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->TestIntMethodExtended(_inInt, _status, _info);
+void ExtendedInterfaceProxy<_AttributeExtensions...>::TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->TestIntMethodExtended(_inInt, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxyBase.hpp
index 4b5bed2..852ff96 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -39,7 +39,7 @@ public:
 
 
 
-    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestIntMethodExtendedAsync(const uint32_t &_inInt, TestIntMethodExtendedAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
 };
 
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStub.hpp
index 09d23ca..551fc0f 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.cpp
index 8e81969..09d45b0 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.hpp
index 906fc03..07f0218 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/ExtendedInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterface.hpp
index 7356067..9227a55 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxy.hpp
index 184de9d..8ec26d8 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxyBase.hpp
index 878fc6a..6af057d 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStub.hpp
index 7276fd0..c37b764 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.cpp
index dfccb28..f9ea339 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -39,9 +39,9 @@ const uint32_t& TestFreedesktopDerivedInterfaceStubDefault::getTestAttributedFro
 
 void TestFreedesktopDerivedInterfaceStubDefault::setTestAttributedFromDerivedInterfaceAttribute(uint32_t _value) {
     const bool valueChanged = trySetTestAttributedFromDerivedInterfaceAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        CommonAPI::Stub<TestFreedesktopDerivedInterfaceStubAdapter, TestFreedesktopDerivedInterfaceStubRemoteEvent>::stubAdapter_->fireTestAttributedFromDerivedInterfaceAttributeChanged(testAttributedFromDerivedInterfaceAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestFreedesktopDerivedInterfaceStubAdapter, TestFreedesktopDerivedInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestFreedesktopDerivedInterfaceStubAdapter, TestFreedesktopDerivedInterfaceStubRemoteEvent>::stubAdapter_->fireTestAttributedFromDerivedInterfaceAttributeChanged(testAttributedFromDerivedInterfaceAttributeValue_);
+     }
 }
 
 bool TestFreedesktopDerivedInterfaceStubDefault::trySetTestAttributedFromDerivedInterfaceAttribute(uint32_t _value) {
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.hpp
index 1e7554f..1eac976 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterface.hpp
index cbfb596..06a274f 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxy.hpp
index 2cd92b5..db831bd 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxyBase.hpp
index 0b50008..e78cfc2 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStub.hpp
index 740b733..6bf5ad2 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.cpp
index 89b004d..ff96aed 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -38,9 +38,9 @@ const uint32_t& TestFreedesktopInterfaceStubDefault::getTestPredefinedTypeAttrib
 
 void TestFreedesktopInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(uint32_t _value) {
     const bool valueChanged = trySetTestPredefinedTypeAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
+     }
 }
 
 bool TestFreedesktopInterfaceStubDefault::trySetTestPredefinedTypeAttributeAttribute(uint32_t _value) {
@@ -88,9 +88,9 @@ const uint32_t& TestFreedesktopInterfaceStubDefault::getTestReadonlyAttributeAtt
 
 void TestFreedesktopInterfaceStubDefault::setTestReadonlyAttributeAttribute(uint32_t _value) {
     const bool valueChanged = trySetTestReadonlyAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestReadonlyAttributeAttributeChanged(testReadonlyAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_->fireTestReadonlyAttributeAttributeChanged(testReadonlyAttributeAttributeValue_);
+     }
 }
 
 bool TestFreedesktopInterfaceStubDefault::trySetTestReadonlyAttributeAttribute(uint32_t _value) {
@@ -117,9 +117,9 @@ const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& TestFreedes
 
 void TestFreedesktopInterfaceStubDefault::setTestDerivedStructAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestStructExtended _value) {
     const bool valueChanged = trySetTestDerivedStructAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
+     }
 }
 
 bool TestFreedesktopInterfaceStubDefault::trySetTestDerivedStructAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestStructExtended _value) {
@@ -167,9 +167,9 @@ const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& TestFreedeskto
 
 void TestFreedesktopInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestArrayUInt64 _value) {
     const bool valueChanged = trySetTestDerivedArrayAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestFreedesktopInterfaceStubAdapter, TestFreedesktopInterfaceStubRemoteEvent>::stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
+     }
 }
 
 bool TestFreedesktopInterfaceStubDefault::trySetTestDerivedArrayAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestArrayUInt64 _value) {
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.hpp
index a45fcd7..c473858 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestFreedesktopInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterface.hpp
index f651daf..c4de980 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxy.hpp
index 669f62a..f284f07 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -83,7 +83,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testEmptyMethod(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testEmptyMethod(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testEmptyMethod with asynchronous semantics.
      * 
@@ -103,7 +103,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testVoidPredefinedTypeMethod with asynchronous semantics.
      * 
@@ -124,7 +124,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_status, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_internalCallStatus, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testPredefinedTypeMethod with asynchronous semantics.
      * 
@@ -144,7 +144,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testVoidDerivedTypeMethod with asynchronous semantics.
      * 
@@ -165,7 +165,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_status, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_internalCallStatus, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testDerivedTypeMethod with asynchronous semantics.
      * 
@@ -185,7 +185,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestArrayOfPolymorphicStructMethod with asynchronous semantics.
      * 
@@ -205,7 +205,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestMapOfPolymorphicStructMethod with asynchronous semantics.
      * 
@@ -225,7 +225,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestStructWithPolymorphicMemberMethod with asynchronous semantics.
      * 
@@ -245,7 +245,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestStructWithEnumKeyMapMember with asynchronous semantics.
      * 
@@ -375,8 +375,8 @@ TestInterfaceProxy<_AttributeExtensions...>::~TestInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethod(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->testEmptyMethod(_status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethod(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->testEmptyMethod(_internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -384,8 +384,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testEmptyMethodAsync(_callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->testVoidPredefinedTypeMethod(_uint32Value, _stringValue, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->testVoidPredefinedTypeMethod(_uint32Value, _stringValue, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -393,8 +393,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testVoidPredefinedTypeMethodAsync(_uint32Value, _stringValue, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_status, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info) {
-    delegate_->testPredefinedTypeMethod(_uint32InValue, _stringInValue, _status, _uint32OutValue, _stringOutValue, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_internalCallStatus, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info) {
+    delegate_->testPredefinedTypeMethod(_uint32InValue, _stringInValue, _internalCallStatus, _uint32OutValue, _stringOutValue, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -402,8 +402,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testPredefinedTypeMethodAsync(_uint32InValue, _stringInValue, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->testVoidDerivedTypeMethod(_testEnumExtended2Value, _testMapValue, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->testVoidDerivedTypeMethod(_testEnumExtended2Value, _testMapValue, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -411,8 +411,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testVoidDerivedTypeMethodAsync(_testEnumExtended2Value, _testMapValue, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_status, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info) {
-    delegate_->testDerivedTypeMethod(_testEnumExtended2InValue, _testMapInValue, _status, _testEnumExtended2OutValue, _testMapOutValue, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_internalCallStatus, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info) {
+    delegate_->testDerivedTypeMethod(_testEnumExtended2InValue, _testMapInValue, _internalCallStatus, _testEnumExtended2OutValue, _testMapOutValue, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -420,8 +420,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testDerivedTypeMethodAsync(_testEnumExtended2InValue, _testMapInValue, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->TestArrayOfPolymorphicStructMethod(_inArray, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->TestArrayOfPolymorphicStructMethod(_inArray, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -429,8 +429,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->TestArrayOfPolymorphicStructMethodAsync(_inArray, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->TestMapOfPolymorphicStructMethod(_inMap, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->TestMapOfPolymorphicStructMethod(_inMap, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -438,8 +438,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->TestMapOfPolymorphicStructMethodAsync(_inMap, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->TestStructWithPolymorphicMemberMethod(_inStruct, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->TestStructWithPolymorphicMemberMethod(_inStruct, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -447,8 +447,8 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->TestStructWithPolymorphicMemberMethodAsync(_inStruct, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void TestInterfaceProxy<_AttributeExtensions...>::TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->TestStructWithEnumKeyMapMember(_inStruct, _status, _info);
+void TestInterfaceProxy<_AttributeExtensions...>::TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->TestStructWithEnumKeyMapMember(_inStruct, _internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxyBase.hpp
index 4fc7e7f..45f0d2c 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -71,23 +71,23 @@ public:
     virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent() = 0;
     virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent() = 0;
 
-    virtual void testEmptyMethod(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testEmptyMethod(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t &_uint32Value, const std::string &_stringValue, TestVoidPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_status, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_internalCallStatus, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t &_uint32InValue, const std::string &_stringInValue, TestPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, TestVoidDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_status, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_internalCallStatus, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, TestDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestArrayOfPolymorphicStructMethodAsync(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, TestArrayOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestMapOfPolymorphicStructMethodAsync(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, TestMapOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestStructWithPolymorphicMemberMethodAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, TestStructWithPolymorphicMemberMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestStructWithEnumKeyMapMemberAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, TestStructWithEnumKeyMapMemberAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
 };
 
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStub.hpp
index b079d8a..2039044 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.cpp
index e51777c..90efb99 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -38,9 +38,9 @@ const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribut
 
 void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(uint32_t _value) {
     const bool valueChanged = trySetTestPredefinedTypeAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
+     }
 }
 
 bool TestInterfaceStubDefault::trySetTestPredefinedTypeAttributeAttribute(uint32_t _value) {
@@ -88,9 +88,9 @@ const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& TestInterfa
 
 void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestStructExtended _value) {
     const bool valueChanged = trySetTestDerivedStructAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
+     }
 }
 
 bool TestInterfaceStubDefault::trySetTestDerivedStructAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestStructExtended _value) {
@@ -138,9 +138,9 @@ const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& TestInterfaceS
 
 void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestArrayUInt64 _value) {
     const bool valueChanged = trySetTestDerivedArrayAttributeAttribute(std::move(_value));
-    if (valueChanged && stubAdapter_ != NULL) {
-        stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
-    }
+    if (valueChanged && CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_ != NULL) {
+         CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
+     }
 }
 
 bool TestInterfaceStubDefault::trySetTestDerivedArrayAttributeAttribute(::commonapi::tests::DerivedTypeCollection::TestArrayUInt64 _value) {
@@ -221,12 +221,12 @@ void TestInterfaceStubDefault::TestStructWithEnumKeyMapMember(const std::shared_
 
 
 void TestInterfaceStubDefault::fireTestPredefinedTypeBroadcastEvent(const uint32_t &_uint32Value, const std::string &_stringValue) {
-	assert(stubAdapter_ !=NULL);
-    stubAdapter_->fireTestPredefinedTypeBroadcastEvent(_uint32Value, _stringValue);
+	assert((CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->fireTestPredefinedTypeBroadcastEvent(_uint32Value, _stringValue);
 }
 void TestInterfaceStubDefault::fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientIdList> _receivers) {
-	assert(stubAdapter_ !=NULL);
-    stubAdapter_->sendTestSelectiveBroadcastSelective(_receivers);
+	assert((CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->sendTestSelectiveBroadcastSelective(_receivers);
 }
 void TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> _client, const CommonAPI::SelectiveBroadcastSubscriptionEvent _event) {
     // No operation in default
@@ -236,13 +236,13 @@ bool TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionRequ
     return true;
 }
 std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceStubDefault::getSubscribersForTestSelectiveBroadcastSelective() {
-	assert(stubAdapter_ !=NULL);
-    return(stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective());
+	assert((CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return(CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective());
 }
 
 void TestInterfaceStubDefault::fireTestBroadcastWithOutArgsSelective(const uint32_t &_uint32Value, const std::string &_stringValue, const std::shared_ptr<CommonAPI::ClientIdList> _receivers) {
-	assert(stubAdapter_ !=NULL);
-    stubAdapter_->sendTestBroadcastWithOutArgsSelective(_uint32Value, _stringValue, _receivers);
+	assert((CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->sendTestBroadcastWithOutArgsSelective(_uint32Value, _stringValue, _receivers);
 }
 void TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> _client, const CommonAPI::SelectiveBroadcastSubscriptionEvent _event) {
     // No operation in default
@@ -252,8 +252,8 @@ bool TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionRe
     return true;
 }
 std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceStubDefault::getSubscribersForTestBroadcastWithOutArgsSelective() {
-	assert(stubAdapter_ !=NULL);
-    return(stubAdapter_->getSubscribersForTestBroadcastWithOutArgsSelective());
+	assert((CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return(CommonAPI::Stub<TestInterfaceStubAdapter, TestInterfaceStubRemoteEvent>::stubAdapter_->getSubscribersForTestBroadcastWithOutArgsSelective());
 }
 
 
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.hpp
index c475a56..aec9e54 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/TestInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.cpp
index 3af84f9..f0c9365 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.hpp
index 812e409..2070910 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxy.hpp
index 12c7ce9..bff2547 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -48,7 +48,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testBranchMethod with asynchronous semantics.
      * 
@@ -110,8 +110,8 @@ BranchInterfaceProxy<_AttributeExtensions...>::~BranchInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void BranchInterfaceProxy<_AttributeExtensions...>::testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-    delegate_->testBranchMethod(_inInt, _inString, _status, _error, _outInt, _outString, _info);
+void BranchInterfaceProxy<_AttributeExtensions...>::testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+    delegate_->testBranchMethod(_inInt, _inString, _internalCallStatus, _error, _outInt, _outString, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxyBase.hpp
index 1aea848..4296bca 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -39,7 +39,7 @@ public:
 
 
 
-    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testBranchMethodAsync(const int32_t &_inInt, const std::string &_inString, TestBranchMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
 };
 
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStub.hpp
index a277f1d..9b7a01d 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
index c916b6c..10b02a7 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.hpp
index 0885835..3cdd147 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/BranchInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.cpp
index 1e88326..e2f172b 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.hpp
index 3072907..ac7e377 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxy.hpp
index 5e49c09..a0382f4 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -48,7 +48,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testLeafMethod with asynchronous semantics.
      * 
@@ -110,8 +110,8 @@ LeafInterfaceProxy<_AttributeExtensions...>::~LeafInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void LeafInterfaceProxy<_AttributeExtensions...>::testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-    delegate_->testLeafMethod(_inInt, _inString, _status, _error, _outInt, _outString, _info);
+void LeafInterfaceProxy<_AttributeExtensions...>::testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+    delegate_->testLeafMethod(_inInt, _inString, _internalCallStatus, _error, _outInt, _outString, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxyBase.hpp
index 7c9fa8f..f00bd30 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -39,7 +39,7 @@ public:
 
 
 
-    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testLeafMethodAsync(const int32_t &_inInt, const std::string &_inString, TestLeafMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
 };
 
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStub.hpp
index fb2336a..62e2a0a 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.cpp
index 4d35c2c..89bad18 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.hpp
index d9b1d07..9d9dd2b 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/LeafInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.cpp
index 7442064..42e6cea 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.hpp
index 8eada5e..72ab4f2 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxy.hpp
index 61f6722..04e4002 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -48,7 +48,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls testRootMethod with asynchronous semantics.
      * 
@@ -112,8 +112,8 @@ RootInterfaceProxy<_AttributeExtensions...>::~RootInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void RootInterfaceProxy<_AttributeExtensions...>::testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-    delegate_->testRootMethod(_inInt, _inString, _status, _error, _outInt, _outString, _info);
+void RootInterfaceProxy<_AttributeExtensions...>::testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+    delegate_->testRootMethod(_inInt, _inString, _internalCallStatus, _error, _outInt, _outString, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxyBase.hpp
index 3c93161..60d512c 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -42,7 +42,7 @@ public:
 
 
 
-    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> testRootMethodAsync(const int32_t &_inInt, const std::string &_inString, TestRootMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual CommonAPI::ProxyManager& getProxyManagerLeafInterface() = 0;
     virtual CommonAPI::ProxyManager& getProxyManagerBranchInterface() = 0;
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStub.hpp
index c8912e0..f78527e 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.cpp
index dfda3aa..9fc6c40 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -43,42 +43,42 @@ void RootInterfaceStubDefault::testRootMethod(const std::shared_ptr<CommonAPI::C
 bool RootInterfaceStubDefault::registerManagedStubLeafInterfaceAutoInstance(std::shared_ptr<LeafInterfaceStub> _stub) {
     autoInstanceCounter_++;
     std::stringstream ss;
-    ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
+    ss << CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
     std::string instance = ss.str();
-    assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubLeafInterface(_stub, instance);
+    assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->registerManagedStubLeafInterface(_stub, instance);
 }
 bool RootInterfaceStubDefault::registerManagedStubLeafInterface(std::shared_ptr<LeafInterfaceStub> _stub, const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubLeafInterface(_stub, _instance);
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->registerManagedStubLeafInterface(_stub, _instance);
 }
 bool RootInterfaceStubDefault::deregisterManagedStubLeafInterface(const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->deregisterManagedStubLeafInterface(_instance);
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->deregisterManagedStubLeafInterface(_instance);
 }
 std::set<std::string>& RootInterfaceStubDefault::getLeafInterfaceInstances() {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->getLeafInterfaceInstances();
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->getLeafInterfaceInstances();
 }
 bool RootInterfaceStubDefault::registerManagedStubBranchInterfaceAutoInstance(std::shared_ptr<BranchInterfaceStub> _stub) {
     autoInstanceCounter_++;
     std::stringstream ss;
-    ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
+    ss << CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
     std::string instance = ss.str();
-    assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubBranchInterface(_stub, instance);
+    assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->registerManagedStubBranchInterface(_stub, instance);
 }
 bool RootInterfaceStubDefault::registerManagedStubBranchInterface(std::shared_ptr<BranchInterfaceStub> _stub, const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubBranchInterface(_stub, _instance);
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->registerManagedStubBranchInterface(_stub, _instance);
 }
 bool RootInterfaceStubDefault::deregisterManagedStubBranchInterface(const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->deregisterManagedStubBranchInterface(_instance);
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->deregisterManagedStubBranchInterface(_instance);
 }
 std::set<std::string>& RootInterfaceStubDefault::getBranchInterfaceInstances() {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->getBranchInterfaceInstances();
+	assert((CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<RootInterfaceStubAdapter, RootInterfaceStubRemoteEvent>::stubAdapter_->getBranchInterfaceInstances();
 }
 
 RootInterfaceStubDefault::RemoteEventHandler::RemoteEventHandler(RootInterfaceStubDefault *_defaultStub)
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.hpp
index 70c1f6d..ae51dab 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/RootInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRoot.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRoot.hpp
index c55881b..9a7a6b8 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRoot.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRoot.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxy.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxy.hpp
index c79b601..5c2a9e8 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxy.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxyBase.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxyBase.hpp
index ceb80a9..9fc8c35 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStub.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStub.hpp
index 2f07c1c..01cb65d 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStub.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.cpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.cpp
index a42a8ac..452aadc 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -36,22 +36,22 @@ SecondRootStubRemoteEvent* SecondRootStubDefault::initStubAdapter(const std::sha
 bool SecondRootStubDefault::registerManagedStubLeafInterfaceAutoInstance(std::shared_ptr<LeafInterfaceStub> _stub) {
     autoInstanceCounter_++;
     std::stringstream ss;
-    ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
+    ss << CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_;
     std::string instance = ss.str();
-    assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubLeafInterface(_stub, instance);
+    assert((CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_->registerManagedStubLeafInterface(_stub, instance);
 }
 bool SecondRootStubDefault::registerManagedStubLeafInterface(std::shared_ptr<LeafInterfaceStub> _stub, const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->registerManagedStubLeafInterface(_stub, _instance);
+	assert((CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_->registerManagedStubLeafInterface(_stub, _instance);
 }
 bool SecondRootStubDefault::deregisterManagedStubLeafInterface(const std::string &_instance) {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->deregisterManagedStubLeafInterface(_instance);
+	assert((CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_->deregisterManagedStubLeafInterface(_instance);
 }
 std::set<std::string>& SecondRootStubDefault::getLeafInterfaceInstances() {
-	assert(stubAdapter_ !=NULL);
-    return stubAdapter_->getLeafInterfaceInstances();
+	assert((CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_) !=NULL);
+    return CommonAPI::Stub<SecondRootStubAdapter, SecondRootStubRemoteEvent>::stubAdapter_->getLeafInterfaceInstances();
 }
 
 SecondRootStubDefault::RemoteEventHandler::RemoteEventHandler(SecondRootStubDefault *_defaultStub)
diff --git a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp
index 55d0741..c56d7ac 100644
--- a/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/commonapi/tests/managed/SecondRootStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp
index e9efaf6..5106b3e 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp
index d163090..94c54c1 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -48,7 +48,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls TestMethod with asynchronous semantics.
      * 
@@ -68,7 +68,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls OtherTestMethod with asynchronous semantics.
      * 
@@ -87,7 +87,7 @@ public:
      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
      * will be set.
      */
-    virtual void finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr);
+    virtual void finish(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
     /**
      * Calls finish with asynchronous semantics.
      * 
@@ -149,8 +149,8 @@ LegacyInterfaceProxy<_AttributeExtensions...>::~LegacyInterfaceProxy() {
 }
 
 template <typename ... _AttributeExtensions>
-void LegacyInterfaceProxy<_AttributeExtensions...>::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) {
-    delegate_->TestMethod(_input, _status, _val1, _val2, _info);
+void LegacyInterfaceProxy<_AttributeExtensions...>::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) {
+    delegate_->TestMethod(_input, _internalCallStatus, _val1, _val2, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -158,8 +158,8 @@ std::future<CommonAPI::CallStatus> LegacyInterfaceProxy<_AttributeExtensions...>
     return delegate_->TestMethodAsync(_input, _callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void LegacyInterfaceProxy<_AttributeExtensions...>::OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) {
-    delegate_->OtherTestMethod(_status, _greeting, _identifier, _info);
+void LegacyInterfaceProxy<_AttributeExtensions...>::OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) {
+    delegate_->OtherTestMethod(_internalCallStatus, _greeting, _identifier, _info);
 }
 
 template <typename ... _AttributeExtensions>
@@ -167,8 +167,8 @@ std::future<CommonAPI::CallStatus> LegacyInterfaceProxy<_AttributeExtensions...>
     return delegate_->OtherTestMethodAsync(_callback, _info);
 }
 template <typename ... _AttributeExtensions>
-void LegacyInterfaceProxy<_AttributeExtensions...>::finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-    delegate_->finish(_status, _info);
+void LegacyInterfaceProxy<_AttributeExtensions...>::finish(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+    delegate_->finish(_internalCallStatus, _info);
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp
index 62d43e5..86f4f54 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -41,11 +41,11 @@ public:
 
 
 
-    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
-    virtual void finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0;
+    virtual void finish(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
     virtual std::future<CommonAPI::CallStatus> finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0;
 };
 
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp
index f38834c..e95255b 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp
index e9e58f0..aebd241 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp
index 4326894..50754c7 100644
--- a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp
+++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.cpp b/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.cpp
new file mode 100644
index 0000000..102ab6f
--- /dev/null
+++ b/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.cpp
@@ -0,0 +1,21 @@
+
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "DerivedTypeCollectionDBusDeployment.hpp"
+
+namespace commonapi {
+namespace tests {
+namespace DerivedTypeCollection_ {
+
+// typecollection-specific deployments
+
+} // namespace DerivedTypeCollection_
+} // namespace tests
+} // namespace commonapi
diff --git a/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp b/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp
new file mode 100644
index 0000000..289f537
--- /dev/null
+++ b/src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp
@@ -0,0 +1,102 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_DERIVEDTYPECOLLECTION_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_DERIVEDTYPECOLLECTION_DEPLOYMENT_HPP_
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace commonapi {
+namespace tests {
+namespace DerivedTypeCollection_ {
+
+// typecollection-specific deployment types
+typedef CommonAPI::MapDeployment<
+    CommonAPI::EmptyDeployment,
+    CommonAPI::DBus::ArrayDeployment<
+        CommonAPI::DBus::StructDeployment<
+            CommonAPI::DBus::StringDeployment,
+            CommonAPI::EmptyDeployment
+        >
+    >
+> TestMapDeployment_t;
+
+typedef CommonAPI::DBus::StructDeployment<
+    CommonAPI::DBus::StringDeployment,
+    CommonAPI::EmptyDeployment,
+    CommonAPI::EmptyDeployment
+> TestStructExtendedDeployment_t;
+
+typedef CommonAPI::MapDeployment<
+    CommonAPI::EmptyDeployment,
+    CommonAPI::DBus::StringDeployment
+> TestEnumMapDeployment_t;
+
+typedef CommonAPI::EmptyDeployment TestEnumDeployment_t;
+
+typedef CommonAPI::DBus::ArrayDeployment<
+    CommonAPI::DBus::StructDeployment<
+        CommonAPI::DBus::StringDeployment,
+        CommonAPI::EmptyDeployment
+    >
+> TestArrayTestStructDeployment_t;
+
+typedef CommonAPI::EmptyDeployment TestEnumExtended2Deployment_t;
+
+typedef CommonAPI::EmptyDeployment TestEnumMissingValueDeployment_t;
+
+typedef CommonAPI::EmptyDeployment TestEnumExtendedDeployment_t;
+
+typedef CommonAPI::DBus::ArrayDeployment<
+    CommonAPI::EmptyDeployment
+> TestArrayUInt64Deployment_t;
+
+typedef CommonAPI::DBus::StructDeployment<
+    CommonAPI::DBus::StringDeployment,
+    CommonAPI::EmptyDeployment
+> TestStructDeployment_t;
+
+typedef CommonAPI::EmptyDeployment TestPolymorphicStructDeployment_t;
+
+typedef CommonAPI::DBus::StructDeployment<
+    CommonAPI::DBus::StringDeployment,
+    CommonAPI::EmptyDeployment,
+    CommonAPI::EmptyDeployment
+> TestExtendedPolymorphicStructDeployment_t;
+
+typedef CommonAPI::MapDeployment<
+    CommonAPI::EmptyDeployment,
+    CommonAPI::EmptyDeployment
+> MapIntToPolymorphicDeployment_t;
+
+typedef CommonAPI::DBus::StructDeployment<
+    CommonAPI::EmptyDeployment,
+    CommonAPI::EmptyDeployment
+> StructWithPolymorphicMemberDeployment_t;
+
+typedef CommonAPI::DBus::StructDeployment<
+    CommonAPI::MapDeployment<
+        CommonAPI::EmptyDeployment,
+        CommonAPI::DBus::StringDeployment
+    >
+> StructWithEnumKeyMapDeployment_t;
+
+
+// typecollection-specific deployments
+
+} // namespace DerivedTypeCollection_
+} // namespace tests
+} // namespace commonapi
+
+#endif // COMMONAPI_DBUS_DERIVEDTYPECOLLECTION_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..a267c64
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.cpp
@@ -0,0 +1,28 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "ExtendedInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace ExtendedInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace ExtendedInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..aa20be0
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp
@@ -0,0 +1,43 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_EXTENDEDINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_EXTENDEDINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace ExtendedInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace ExtendedInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_EXTENDEDINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
index ea7cc5f..48758f3 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -35,27 +35,40 @@ ExtendedInterfaceDBusProxy::ExtendedInterfaceDBusProxy(
 
 
 
-        void ExtendedInterfaceDBusProxy::TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void ExtendedInterfaceDBusProxy::TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "TestIntMethodExtended",
             "u",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt,
-            _status
-            );
+            deploy_inInt,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> ExtendedInterfaceDBusProxy::TestIntMethodExtendedAsync(const uint32_t &_inInt, TestIntMethodExtendedAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "TestIntMethodExtended",
             "u",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_inInt,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.hpp
index 7d95904..a3358bf 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -41,7 +41,7 @@ public:
 
 
 
-    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestIntMethodExtendedAsync(const uint32_t &_inInt, TestIntMethodExtendedAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.cpp
index 3e3fdac..40578de 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -56,7 +56,10 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
         uint32_t
-        > ExtendedInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(&ExtendedInterfaceStub::getTestPredefinedTypeAttributeAttribute, "u");
+        > ExtendedInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(
+            &ExtendedInterfaceStub::getTestPredefinedTypeAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
         uint32_t
@@ -69,11 +72,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
-        > ExtendedInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(&ExtendedInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqi)");
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+        > ExtendedInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(
+            &ExtendedInterfaceStub::getTestDerivedStructAttributeAttribute
+            , "(sqi)"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
         > ExtendedInterfaceDBusStubAdapterInternal::setTestDerivedStructAttributeAttributeStubDispatcher(
                 &ExtendedInterfaceStub::getTestDerivedStructAttributeAttribute,
                 &ExtendedInterfaceStubRemoteEvent::onRemoteSetTestDerivedStructAttributeAttribute,
@@ -83,11 +91,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
-        > ExtendedInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(&ExtendedInterfaceStub::getTestDerivedArrayAttributeAttribute, "at");
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+        > ExtendedInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(
+            &ExtendedInterfaceStub::getTestDerivedArrayAttributeAttribute
+            , "at"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
         > ExtendedInterfaceDBusStubAdapterInternal::setTestDerivedArrayAttributeAttributeStubDispatcher(
                 &ExtendedInterfaceStub::getTestDerivedArrayAttributeAttribute,
                 &ExtendedInterfaceStubRemoteEvent::onRemoteSetTestDerivedArrayAttributeAttribute,
@@ -97,58 +110,128 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 #endif
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testIntMethodExtendedStubDispatcher(&ExtendedInterfaceStub::TestIntMethodExtended, "", std::tuple<uint32_t>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testIntMethodExtendedStubDispatcher(
+    &ExtendedInterfaceStub::TestIntMethodExtended, "",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr)),
+                	std::make_tuple());
 
 #ifdef WIN32
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testEmptyMethodStubDispatcher(&ExtendedInterfaceStub::testEmptyMethod, "", std::tuple<>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testEmptyMethodStubDispatcher(
+    &ExtendedInterfaceStub::testEmptyMethod, "",
+					std::make_tuple(),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t, std::string>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testVoidPredefinedTypeMethod, "", std::tuple<uint32_t, std::string>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(
+    &ExtendedInterfaceStub::testVoidPredefinedTypeMethod, "",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t, std::string>,
-    std::tuple<uint32_t, std::string>
-    > ExtendedInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testPredefinedTypeMethod, "us", std::tuple<uint32_t, std::string, uint32_t, std::string>());
+    std::tuple<uint32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(
+    &ExtendedInterfaceStub::testPredefinedTypeMethod, "us",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testVoidDerivedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testVoidDerivedTypeMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testVoidDerivedTypeMethodStubDispatcher(
+    &ExtendedInterfaceStub::testVoidDerivedTypeMethod, "",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>
-    > ExtendedInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}", std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>());
+    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher(
+    &ExtendedInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(&ExtendedInterfaceStub::TestArrayOfPolymorphicStructMethod, "", std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(
+    &ExtendedInterfaceStub::TestArrayOfPolymorphicStructMethod, "",
+					std::make_tuple(static_cast<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testMapOfPolymorphicStructMethodStubDispatcher(&ExtendedInterfaceStub::TestMapOfPolymorphicStructMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testMapOfPolymorphicStructMethodStubDispatcher(
+    &ExtendedInterfaceStub::TestMapOfPolymorphicStructMethod, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testStructWithPolymorphicMemberMethodStubDispatcher(&ExtendedInterfaceStub::TestStructWithPolymorphicMemberMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testStructWithPolymorphicMemberMethodStubDispatcher(
+    &ExtendedInterfaceStub::TestStructWithPolymorphicMemberMethod, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t>,
     std::tuple<>
-    > ExtendedInterfaceDBusStubAdapterInternal::testStructWithEnumKeyMapMemberStubDispatcher(&ExtendedInterfaceStub::TestStructWithEnumKeyMapMember, "", std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>());
+    
+    > ExtendedInterfaceDBusStubAdapterInternal::testStructWithEnumKeyMapMemberStubDispatcher(
+    &ExtendedInterfaceStub::TestStructWithEnumKeyMapMember, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t*>(nullptr)),
+                	std::make_tuple());
 #endif
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.hpp
index ff1545c..acbce43 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -12,6 +12,7 @@
 
 #include <v1_0/commonapi/tests/ExtendedInterfaceStub.hpp>
 #include <v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp>
+#include "v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -20,6 +21,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -81,81 +83,125 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 #ifdef WIN32
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        uint32_t
+        uint32_t                    
         > setTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                
         > getTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                    
         > setTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                
         > getTestDerivedArrayAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         ExtendedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                    
         > setTestDerivedArrayAttributeAttributeStubDispatcher;
 #endif
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment>,
     std::tuple<>
+    
     > testIntMethodExtendedStubDispatcher;
 
 #ifdef WIN32
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
+    
     > testEmptyMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t, std::string>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
     std::tuple<>
+    
     > testVoidPredefinedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<uint32_t, std::string>,
-    std::tuple<uint32_t, std::string>
+    std::tuple<uint32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
     > testPredefinedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
     std::tuple<>
+    
     > testVoidDerivedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>
+    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+    
     > testDerivedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>>,
     std::tuple<>
+    
     > testArrayOfPolymorphicStructMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t>,
     std::tuple<>
+    
     > testMapOfPolymorphicStructMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t>,
     std::tuple<>
+    
     > testStructWithPolymorphicMemberMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     ExtendedInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t>,
     std::tuple<>
+    
     > testStructWithEnumKeyMapMemberStubDispatcher;
 #endif
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..c96b62e
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.cpp
@@ -0,0 +1,28 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "TestFreedesktopDerivedInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestFreedesktopDerivedInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace TestFreedesktopDerivedInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..bdb1c56
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp
@@ -0,0 +1,43 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_TESTFREEDESKTOPDERIVEDINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_TESTFREEDESKTOPDERIVEDINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestFreedesktopDerivedInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace TestFreedesktopDerivedInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_TESTFREEDESKTOPDERIVEDINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.cpp
index ada72a5..d46a6cc 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -30,7 +30,7 @@ TestFreedesktopDerivedInterfaceDBusProxy::TestFreedesktopDerivedInterfaceDBusPro
 	const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection> &_connection)
 	:	CommonAPI::DBus::DBusProxy(_address, _connection),
 		TestFreedesktopInterfaceDBusProxy(_address, _connection)
-,		testAttributedFromDerivedInterface_(*this, "onTestAttributedFromDerivedInterfaceAttributeChanged", "setTestAttributedFromDerivedInterfaceAttribute", "u", "getTestAttributedFromDerivedInterfaceAttribute")
+,		testAttributedFromDerivedInterface_(*this, "onTestAttributedFromDerivedInterfaceAttributeChanged", "setTestAttributedFromDerivedInterfaceAttribute", "u", "getTestAttributedFromDerivedInterfaceAttribute", static_cast<CommonAPI::EmptyDeployment*>(nullptr))
 {
 }
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.hpp
index 34f0472..24cfb5c 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.cpp
index e301425..75505eb 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -61,7 +61,10 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
         uint32_t
-        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestAttributedFromDerivedInterfaceAttributeStubDispatcher(&TestFreedesktopDerivedInterfaceStub::getTestAttributedFromDerivedInterfaceAttribute, "u");
+        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestAttributedFromDerivedInterfaceAttributeStubDispatcher(
+            &TestFreedesktopDerivedInterfaceStub::getTestAttributedFromDerivedInterfaceAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
         uint32_t
@@ -77,7 +80,10 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
         uint32_t
-        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(&TestFreedesktopDerivedInterfaceStub::getTestPredefinedTypeAttributeAttribute, "u");
+        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(
+            &TestFreedesktopDerivedInterfaceStub::getTestPredefinedTypeAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
         uint32_t
@@ -91,14 +97,22 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
         uint32_t
-        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestReadonlyAttributeAttributeStubDispatcher(&TestFreedesktopDerivedInterfaceStub::getTestReadonlyAttributeAttribute, "u");
+        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestReadonlyAttributeAttributeStubDispatcher(
+            &TestFreedesktopDerivedInterfaceStub::getTestReadonlyAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
-        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(&TestFreedesktopDerivedInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqi)");
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(
+            &TestFreedesktopDerivedInterfaceStub::getTestDerivedStructAttributeAttribute
+            , "(sqi)"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
         > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::setTestDerivedStructAttributeAttributeStubDispatcher(
                 &TestFreedesktopDerivedInterfaceStub::getTestDerivedStructAttributeAttribute,
                 &TestFreedesktopDerivedInterfaceStubRemoteEvent::onRemoteSetTestDerivedStructAttributeAttribute,
@@ -108,11 +122,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
-        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(&TestFreedesktopDerivedInterfaceStub::getTestDerivedArrayAttributeAttribute, "at");
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+        > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(
+            &TestFreedesktopDerivedInterfaceStub::getTestDerivedArrayAttributeAttribute
+            , "at"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
         > TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::setTestDerivedArrayAttributeAttributeStubDispatcher(
                 &TestFreedesktopDerivedInterfaceStub::getTestDerivedArrayAttributeAttribute,
                 &TestFreedesktopDerivedInterfaceStubRemoteEvent::onRemoteSetTestDerivedArrayAttributeAttribute,
@@ -127,12 +146,15 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
 #endif
 
 void TestFreedesktopDerivedInterfaceDBusStubAdapterInternal::fireTestAttributedFromDerivedInterfaceAttributeChanged(const uint32_t& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    uint32_t
+    >>
         ::sendSignal(
             *this,
             "onTestAttributedFromDerivedInterfaceAttributeChanged",
             "u",
             value
+    
     );
 }
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.hpp
index 05fd337..7b940ef 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -12,6 +12,7 @@
 
 #include <v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceStub.hpp>
 #include <v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.hpp>
+#include "v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -20,6 +21,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -80,41 +82,45 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestAttributedFromDerivedInterfaceAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        uint32_t
+        uint32_t                    
         > setTestAttributedFromDerivedInterfaceAttributeStubDispatcher;
 
 #ifdef WIN32
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        uint32_t
+        uint32_t                    
         > setTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestReadonlyAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                
         > getTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                    
         > setTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                
         > getTestDerivedArrayAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopDerivedInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                    
         > setTestDerivedArrayAttributeAttributeStubDispatcher;
 #endif
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..f2f2a15
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.cpp
@@ -0,0 +1,28 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "TestFreedesktopInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestFreedesktopInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace TestFreedesktopInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..c5df423
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp
@@ -0,0 +1,44 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_TESTFREEDESKTOPINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_TESTFREEDESKTOPINTERFACE_DEPLOYMENT_HPP_
+
+
+#include <commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp>
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestFreedesktopInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace TestFreedesktopInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_TESTFREEDESKTOPINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.cpp
index 2fe18ce..82a772c 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -29,10 +29,10 @@ TestFreedesktopInterfaceDBusProxy::TestFreedesktopInterfaceDBusProxy(
 	const CommonAPI::DBus::DBusAddress &_address,
 	const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection> &_connection)
 	:	CommonAPI::DBus::DBusProxy(_address, _connection)
-,		testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute"),
-		testReadonlyAttribute_(*this, "onTestReadonlyAttributeAttributeChanged", "u", "getTestReadonlyAttributeAttribute"),
-		testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute"),
-		testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute")
+,		testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute", static_cast<CommonAPI::EmptyDeployment*>(nullptr)),
+		testReadonlyAttribute_(*this, "onTestReadonlyAttributeAttributeChanged", "u", "getTestReadonlyAttributeAttribute", static_cast<CommonAPI::EmptyDeployment*>(nullptr)),
+		testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute", static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr)),
+		testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute", static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr))
 {
 }
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.hpp
index d041c8f..d2a3aa2 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_Test_Freedesktop_Interface_DBUS_PROXY_HPP_
 
 #include <v1_0/commonapi/tests/TestFreedesktopInterfaceProxyBase.hpp>
+#include <commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp>
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -53,8 +54,8 @@ private:
     
     CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestPredefinedTypeAttributeAttribute>> testPredefinedTypeAttribute_;
     CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusReadonlyAttribute<TestReadonlyAttributeAttribute>> testReadonlyAttribute_;
-    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedStructAttributeAttribute>> testDerivedStructAttribute_;
-    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute>> testDerivedArrayAttribute_;
+    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedStructAttributeAttribute, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t>> testDerivedStructAttribute_;
+    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t>> testDerivedArrayAttribute_;
 
 
 };
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.cpp
index 2f1258c..11b53d4 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -89,7 +89,10 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
         uint32_t
-        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(&TestFreedesktopInterfaceStub::getTestPredefinedTypeAttributeAttribute, "u");
+        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(
+            &TestFreedesktopInterfaceStub::getTestPredefinedTypeAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
         uint32_t
@@ -103,14 +106,22 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
         uint32_t
-        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestReadonlyAttributeAttributeStubDispatcher(&TestFreedesktopInterfaceStub::getTestReadonlyAttributeAttribute, "u");
+        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestReadonlyAttributeAttributeStubDispatcher(
+            &TestFreedesktopInterfaceStub::getTestReadonlyAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
-        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(&TestFreedesktopInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqi)");
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(
+            &TestFreedesktopInterfaceStub::getTestDerivedStructAttributeAttribute
+            , "(sqi)"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
         > TestFreedesktopInterfaceDBusStubAdapterInternal::setTestDerivedStructAttributeAttributeStubDispatcher(
                 &TestFreedesktopInterfaceStub::getTestDerivedStructAttributeAttribute,
                 &TestFreedesktopInterfaceStubRemoteEvent::onRemoteSetTestDerivedStructAttributeAttribute,
@@ -120,11 +131,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
-        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(&TestFreedesktopInterfaceStub::getTestDerivedArrayAttributeAttribute, "at");
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+        > TestFreedesktopInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(
+            &TestFreedesktopInterfaceStub::getTestDerivedArrayAttributeAttribute
+            , "at"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
         > TestFreedesktopInterfaceDBusStubAdapterInternal::setTestDerivedArrayAttributeAttributeStubDispatcher(
                 &TestFreedesktopInterfaceStub::getTestDerivedArrayAttributeAttribute,
                 &TestFreedesktopInterfaceStubRemoteEvent::onRemoteSetTestDerivedArrayAttributeAttribute,
@@ -137,39 +153,59 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
 
 
 void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    uint32_t
+    >>
         ::sendSignal(
             *this,
             "onTestPredefinedTypeAttributeAttributeChanged",
             "u",
             value
+    
     );
 }
 void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestReadonlyAttributeAttributeChanged(const uint32_t& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    uint32_t
+    >>
         ::sendSignal(
             *this,
             "onTestReadonlyAttributeAttributeChanged",
             "u",
             value
+    
     );
 }
 void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestDerivedStructAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestStructExtended>>
+    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestStructExtended, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr));
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    CommonAPI::Deployable<
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+    >
+    >>
         ::sendSignal(
             *this,
             "onTestDerivedStructAttributeAttributeChanged",
             "(sqi)",
-            value
+            deployedValue
+    
     );
 }
 void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestDerivedArrayAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64>>
+    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr));
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    CommonAPI::Deployable<
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+    >
+    >>
         ::sendSignal(
             *this,
             "onTestDerivedArrayAttributeAttributeChanged",
             "at",
-            value
+            deployedValue
+    
     );
 }
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.hpp
index 5c165b3..0705da8 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_Test_Freedesktop_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/TestFreedesktopInterfaceStub.hpp>
+#include "v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -19,6 +20,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -62,31 +64,35 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        uint32_t
+        uint32_t                    
         > setTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestReadonlyAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                
         > getTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                    
         > setTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                
         > getTestDerivedArrayAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestFreedesktopInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                    
         > setTestDerivedArrayAttributeAttributeStubDispatcher;
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..e9d2049
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.cpp
@@ -0,0 +1,28 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "TestInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace TestInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..a857619
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp
@@ -0,0 +1,44 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_TESTINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_TESTINTERFACE_DEPLOYMENT_HPP_
+
+
+#include <commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp>
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace TestInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace TestInterface_
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_TESTINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.cpp
index b202588..94240f6 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -29,12 +29,12 @@ TestInterfaceDBusProxy::TestInterfaceDBusProxy(
 	const CommonAPI::DBus::DBusAddress &_address,
 	const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection> &_connection)
 	:	CommonAPI::DBus::DBusProxy(_address, _connection)
-,		testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute"),
-		testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute"),
-		testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute")
-,		testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us", std::tuple<uint32_t, std::string>()),
-		testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", "", std::tuple<>()),
-		testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us", std::tuple<uint32_t, std::string>())
+,		testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute", static_cast<CommonAPI::EmptyDeployment*>(nullptr)),
+		testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute", static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr)),
+		testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute", static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr))
+,		testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us", std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr))),
+		testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", "", std::make_tuple()),
+		testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us", std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)))
 {
 }
 
@@ -58,201 +58,352 @@ TestInterfaceDBusProxy::TestInterfaceDBusProxy(
             return testBroadcastWithOutArgsSelective_;
         }
 
-        void TestInterfaceDBusProxy::testEmptyMethod(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::testEmptyMethod(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "testEmptyMethod",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _status
-            );
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testEmptyMethodAsync(TestEmptyMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "testEmptyMethod",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            std::move(_callback),
-            std::tuple<>());
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32Value(_uint32Value, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringValue(_stringValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "testVoidPredefinedTypeMethod",
             "us",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _uint32Value, _stringValue,
-            _status
-            );
+            deploy_uint32Value, deploy_stringValue,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testVoidPredefinedTypeMethodAsync(const uint32_t &_uint32Value, const std::string &_stringValue, TestVoidPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32Value(_uint32Value, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringValue(_stringValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "testVoidPredefinedTypeMethod",
             "us",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _uint32Value, _stringValue,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_uint32Value, deploy_stringValue,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_status, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_internalCallStatus, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32InValue(_uint32InValue, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringInValue(_stringInValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32OutValue(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringOutValue(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<uint32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "testPredefinedTypeMethod",
             "us",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _uint32InValue, _stringInValue,
-            _status
-            , _uint32OutValue, _stringOutValue);
+            deploy_uint32InValue, deploy_stringInValue,
+            _internalCallStatus,
+            deploy_uint32OutValue, deploy_stringOutValue);
+            _uint32OutValue = deploy_uint32OutValue.getValue();
+            _stringOutValue = deploy_stringOutValue.getValue();
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testPredefinedTypeMethodAsync(const uint32_t &_uint32InValue, const std::string &_stringInValue, TestPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string> >::callMethodAsync(
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32InValue(_uint32InValue, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringInValue(_stringInValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> deploy_uint32OutValue(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_stringOutValue(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<uint32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "testPredefinedTypeMethod",
             "us",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _uint32InValue, _stringInValue,
-            std::move(_callback),
-            std::tuple<uint32_t, std::string>());
+            deploy_uint32InValue, deploy_stringInValue,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment> _uint32OutValue, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> _stringOutValue) {
+            	_callback(_status, _uint32OutValue.getValue(), _stringOutValue.getValue());
+            },
+            std::make_tuple(deploy_uint32OutValue, deploy_stringOutValue));
         }
-        void TestInterfaceDBusProxy::testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2Value(_testEnumExtended2Value, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapValue(_testMapValue, static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "testVoidDerivedTypeMethod",
             "ia{ua(sq)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _testEnumExtended2Value, _testMapValue,
-            _status
-            );
+            deploy_testEnumExtended2Value, deploy_testMapValue,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testVoidDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, TestVoidDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2Value(_testEnumExtended2Value, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapValue(_testMapValue, static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "testVoidDerivedTypeMethod",
             "ia{ua(sq)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _testEnumExtended2Value, _testMapValue,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_testEnumExtended2Value, deploy_testMapValue,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_status, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_internalCallStatus, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2InValue(_testEnumExtended2InValue, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapInValue(_testMapInValue, static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2OutValue(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapOutValue(static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap,::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+                >
+            >::callMethodWithReply(
             *this,
             "testDerivedTypeMethod",
             "ia{ua(sq)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _testEnumExtended2InValue, _testMapInValue,
-            _status
-            , _testEnumExtended2OutValue, _testMapOutValue);
+            deploy_testEnumExtended2InValue, deploy_testMapInValue,
+            _internalCallStatus,
+            deploy_testEnumExtended2OutValue, deploy_testMapOutValue);
+            _testEnumExtended2OutValue = deploy_testEnumExtended2OutValue.getValue();
+            _testMapOutValue = deploy_testMapOutValue.getValue();
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, TestDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap> >::callMethodAsync(
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2InValue(_testEnumExtended2InValue, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapInValue(_testMapInValue, static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2OutValue(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> deploy_testMapOutValue(static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap,::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+                >
+            >::callMethodAsync(
             *this,
             "testDerivedTypeMethod",
             "ia{ua(sq)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _testEnumExtended2InValue, _testMapInValue,
-            std::move(_callback),
-            std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>());
+            deploy_testEnumExtended2InValue, deploy_testMapInValue,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> _testEnumExtended2OutValue, CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t> _testMapOutValue) {
+            	_callback(_status, _testEnumExtended2OutValue.getValue(), _testMapOutValue.getValue());
+            },
+            std::make_tuple(deploy_testEnumExtended2OutValue, deploy_testMapOutValue));
         }
-        void TestInterfaceDBusProxy::TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>> deploy_inArray(_inArray, static_cast<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t> >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "TestArrayOfPolymorphicStructMethod",
             "a(uv)",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inArray,
-            _status
-            );
+            deploy_inArray,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::TestArrayOfPolymorphicStructMethodAsync(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, TestArrayOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>> deploy_inArray(_inArray, static_cast<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t> >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "TestArrayOfPolymorphicStructMethod",
             "a(uv)",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inArray,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_inArray,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic, ::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t> deploy_inMap(_inMap, static_cast<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic, ::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "TestMapOfPolymorphicStructMethod",
             "a{y(uv)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inMap,
-            _status
-            );
+            deploy_inMap,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::TestMapOfPolymorphicStructMethodAsync(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, TestMapOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic, ::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t> deploy_inMap(_inMap, static_cast<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic, ::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "TestMapOfPolymorphicStructMethod",
             "a{y(uv)}",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inMap,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_inMap,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember, ::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t> deploy_inStruct(_inStruct, static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember, ::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "TestStructWithPolymorphicMemberMethod",
             "(u(uv))",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inStruct,
-            _status
-            );
+            deploy_inStruct,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::TestStructWithPolymorphicMemberMethodAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, TestStructWithPolymorphicMemberMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember, ::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t> deploy_inStruct(_inStruct, static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember, ::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "TestStructWithPolymorphicMemberMethod",
             "(u(uv))",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inStruct,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_inStruct,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
-        void TestInterfaceDBusProxy::TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void TestInterfaceDBusProxy::TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap, ::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t> deploy_inStruct(_inStruct, static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap, ::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "TestStructWithEnumKeyMapMember",
             "(a{is})",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inStruct,
-            _status
-            );
+            deploy_inStruct,
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::TestStructWithEnumKeyMapMemberAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, TestStructWithEnumKeyMapMemberAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap, ::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t> deploy_inStruct(_inStruct, static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap, ::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "TestStructWithEnumKeyMapMember",
             "(a{is})",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inStruct,
-            std::move(_callback),
-            std::tuple<>());
+            deploy_inStruct,
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.hpp
index 8ed6873..7ac21db 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_Test_Interface_DBUS_PROXY_HPP_
 
 #include <v1_0/commonapi/tests/TestInterfaceProxyBase.hpp>
+#include <commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp>
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -50,23 +51,23 @@ public:
     virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent();
     virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent();
 
-    virtual void testEmptyMethod(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void testEmptyMethod(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t &_uint32Value, const std::string &_stringValue, TestVoidPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_status, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info);
+    virtual void testPredefinedTypeMethod(const uint32_t &_uint32InValue, const std::string &_stringInValue, CommonAPI::CallStatus &_internalCallStatus, uint32_t &_uint32OutValue, std::string &_stringOutValue, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t &_uint32InValue, const std::string &_stringInValue, TestPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void testVoidDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2Value, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapValue, TestVoidDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_status, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info);
+    virtual void testDerivedTypeMethod(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, CommonAPI::CallStatus &_internalCallStatus, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2OutValue, ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapOutValue, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2 &_testEnumExtended2InValue, const ::commonapi::tests::DerivedTypeCollection::TestMap &_testMapInValue, TestDerivedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void TestArrayOfPolymorphicStructMethod(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestArrayOfPolymorphicStructMethodAsync(const std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>> &_inArray, TestArrayOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void TestMapOfPolymorphicStructMethod(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestMapOfPolymorphicStructMethodAsync(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, TestMapOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void TestStructWithPolymorphicMemberMethod(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestStructWithPolymorphicMemberMethodAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, TestStructWithPolymorphicMemberMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void TestStructWithEnumKeyMapMember(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestStructWithEnumKeyMapMemberAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, TestStructWithEnumKeyMapMemberAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
 
@@ -75,12 +76,12 @@ public:
 private:
     
     CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestPredefinedTypeAttributeAttribute>> testPredefinedTypeAttribute_;
-    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedStructAttributeAttribute>> testDerivedStructAttribute_;
-    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute>> testDerivedArrayAttribute_;
+    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedStructAttributeAttribute, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t>> testDerivedStructAttribute_;
+    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t>> testDerivedArrayAttribute_;
 
-    CommonAPI::DBus::DBusEvent<TestPredefinedTypeBroadcastEvent, uint32_t, std::string> testPredefinedTypeBroadcast_;
+    CommonAPI::DBus::DBusEvent<TestPredefinedTypeBroadcastEvent, CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment>, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>> testPredefinedTypeBroadcast_;
     CommonAPI::DBus::DBusSelectiveEvent<TestSelectiveBroadcastSelectiveEvent> testSelectiveBroadcastSelective_;
-    CommonAPI::DBus::DBusSelectiveEvent<TestBroadcastWithOutArgsSelectiveEvent, uint32_t, std::string> testBroadcastWithOutArgsSelective_;
+    CommonAPI::DBus::DBusSelectiveEvent<TestBroadcastWithOutArgsSelectiveEvent, CommonAPI::Deployable<uint32_t, CommonAPI::EmptyDeployment>, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>> testBroadcastWithOutArgsSelective_;
 
 };
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
index c237cd6..52eed4e 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -127,7 +127,10 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
         uint32_t
-        > TestInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(&TestInterfaceStub::getTestPredefinedTypeAttributeAttribute, "u");
+        > TestInterfaceDBusStubAdapterInternal::getTestPredefinedTypeAttributeAttributeStubDispatcher(
+            &TestInterfaceStub::getTestPredefinedTypeAttributeAttribute
+            , "u"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
         uint32_t
@@ -140,11 +143,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
-        > TestInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(&TestInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqi)");
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+        > TestInterfaceDBusStubAdapterInternal::getTestDerivedStructAttributeAttributeStubDispatcher(
+            &TestInterfaceStub::getTestDerivedStructAttributeAttribute
+            , "(sqi)"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
         > TestInterfaceDBusStubAdapterInternal::setTestDerivedStructAttributeAttributeStubDispatcher(
                 &TestInterfaceStub::getTestDerivedStructAttributeAttribute,
                 &TestInterfaceStubRemoteEvent::onRemoteSetTestDerivedStructAttributeAttribute,
@@ -154,11 +162,16 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
-        > TestInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(&TestInterfaceStub::getTestDerivedArrayAttributeAttribute, "at");
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+        > TestInterfaceDBusStubAdapterInternal::getTestDerivedArrayAttributeAttributeStubDispatcher(
+            &TestInterfaceStub::getTestDerivedArrayAttributeAttribute
+            , "at"
+            );
 CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
         > TestInterfaceDBusStubAdapterInternal::setTestDerivedArrayAttributeAttributeStubDispatcher(
                 &TestInterfaceStub::getTestDerivedArrayAttributeAttribute,
                 &TestInterfaceStubRemoteEvent::onRemoteSetTestDerivedArrayAttributeAttribute,
@@ -168,89 +181,172 @@ CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
                 );
 
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testEmptyMethodStubDispatcher(&TestInterfaceStub::testEmptyMethod, "", std::tuple<>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testEmptyMethodStubDispatcher(
+    &TestInterfaceStub::testEmptyMethod, "",
+					std::make_tuple(),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<uint32_t, std::string>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(&TestInterfaceStub::testVoidPredefinedTypeMethod, "", std::tuple<uint32_t, std::string>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(
+    &TestInterfaceStub::testVoidPredefinedTypeMethod, "",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<uint32_t, std::string>,
-    std::tuple<uint32_t, std::string>
-    > TestInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(&TestInterfaceStub::testPredefinedTypeMethod, "us", std::tuple<uint32_t, std::string, uint32_t, std::string>());
+    std::tuple<uint32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
+    > TestInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(
+    &TestInterfaceStub::testPredefinedTypeMethod, "us",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testVoidDerivedTypeMethodStubDispatcher(&TestInterfaceStub::testVoidDerivedTypeMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testVoidDerivedTypeMethodStubDispatcher(
+    &TestInterfaceStub::testVoidDerivedTypeMethod, "",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>
-    > TestInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher(&TestInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}", std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap, ::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>());
+    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+    
+    > TestInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher(
+    &TestInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(&TestInterfaceStub::TestArrayOfPolymorphicStructMethod, "", std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(
+    &TestInterfaceStub::TestArrayOfPolymorphicStructMethod, "",
+					std::make_tuple(static_cast<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testMapOfPolymorphicStructMethodStubDispatcher(&TestInterfaceStub::TestMapOfPolymorphicStructMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testMapOfPolymorphicStructMethodStubDispatcher(
+    &TestInterfaceStub::TestMapOfPolymorphicStructMethod, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testStructWithPolymorphicMemberMethodStubDispatcher(&TestInterfaceStub::TestStructWithPolymorphicMemberMethod, "", std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testStructWithPolymorphicMemberMethodStubDispatcher(
+    &TestInterfaceStub::TestStructWithPolymorphicMemberMethod, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t*>(nullptr)),
+                	std::make_tuple());
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t>,
     std::tuple<>
-    > TestInterfaceDBusStubAdapterInternal::testStructWithEnumKeyMapMemberStubDispatcher(&TestInterfaceStub::TestStructWithEnumKeyMapMember, "", std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>());
+    
+    > TestInterfaceDBusStubAdapterInternal::testStructWithEnumKeyMapMemberStubDispatcher(
+    &TestInterfaceStub::TestStructWithEnumKeyMapMember, "",
+					std::make_tuple(static_cast<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t*>(nullptr)),
+                	std::make_tuple());
 
 
 void TestInterfaceDBusStubAdapterInternal::fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    uint32_t
+    >>
         ::sendSignal(
             *this,
             "onTestPredefinedTypeAttributeAttributeChanged",
             "u",
             value
+    
     );
 }
 void TestInterfaceDBusStubAdapterInternal::fireTestDerivedStructAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestStructExtended>>
+    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestStructExtended, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr));
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    CommonAPI::Deployable<
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t
+    >
+    >>
         ::sendSignal(
             *this,
             "onTestDerivedStructAttributeAttributeChanged",
             "(sqi)",
-            value
+            deployedValue
+    
     );
 }
 void TestInterfaceDBusStubAdapterInternal::fireTestDerivedArrayAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& value) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64>>
+    CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr));
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    CommonAPI::Deployable<
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t
+    >
+    >>
         ::sendSignal(
             *this,
             "onTestDerivedArrayAttributeAttributeChanged",
             "at",
-            value
+            deployedValue
+    
     );
 }
 
 void TestInterfaceDBusStubAdapterInternal::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) {
-    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>>
-            ::sendSignal(
-                *this,
-                "TestPredefinedTypeBroadcast",
-                "us",
-                uint32Value, stringValue
-        );
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+    uint32_t,
+    CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>
+    >>::sendSignal(
+            *this,
+            "TestPredefinedTypeBroadcast",
+            "us",
+    uint32Value,
+    CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>(stringValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr))
+    );
 }
 CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
     TestInterfaceStub,
@@ -271,8 +367,8 @@ void TestInterfaceDBusStubAdapterInternal::fireTestSelectiveBroadcastSelective(c
 
     if(dbusClient)
     {
-        CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<>>
-            ::sendSignal(
+        CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+        >>::sendSignal(
                 dbusClient->getDBusId(),
                 *this,
                 "TestSelectiveBroadcast",
@@ -295,26 +391,24 @@ void TestInterfaceDBusStubAdapterInternal::sendTestSelectiveBroadcastSelective(c
 }
 
 void TestInterfaceDBusStubAdapterInternal::subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
-    bool ok = stub_->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
+    bool ok = TestInterfaceDBusStubAdapterHelper::stub_->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
     if (ok) {
         subscribersForTestSelectiveBroadcastSelective_->insert(clientId);
-        stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+        TestInterfaceDBusStubAdapterHelper::stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
         success = true;
     } else {
         success = false;
     }
 }
 
-
 void TestInterfaceDBusStubAdapterInternal::unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     subscribersForTestSelectiveBroadcastSelective_->erase(clientId);
-    stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+    TestInterfaceDBusStubAdapterHelper::stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
 }
 
 std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestSelectiveBroadcastSelective() {
     return subscribersForTestSelectiveBroadcastSelective_;
 }
-
 CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
     TestInterfaceStub,
     TestInterfaceStubAdapter,
@@ -334,13 +428,16 @@ void TestInterfaceDBusStubAdapterInternal::fireTestBroadcastWithOutArgsSelective
 
     if(dbusClient)
     {
-        CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, std::string>>
-            ::sendSignal(
+        CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<
+        uint32_t,
+        CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>
+        >>::sendSignal(
                 dbusClient->getDBusId(),
                 *this,
                 "TestBroadcastWithOutArgs",
                 "us",
-                _uint32Value, _stringValue
+        _uint32Value,
+        CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment>(_stringValue, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr))
         );
     }
 }
@@ -359,20 +456,19 @@ void TestInterfaceDBusStubAdapterInternal::sendTestBroadcastWithOutArgsSelective
 }
 
 void TestInterfaceDBusStubAdapterInternal::subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
-    bool ok = stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
+    bool ok = TestInterfaceDBusStubAdapterHelper::stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
     if (ok) {
         subscribersForTestBroadcastWithOutArgsSelective_->insert(clientId);
-        stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+        TestInterfaceDBusStubAdapterHelper::stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
         success = true;
     } else {
         success = false;
     }
 }
 
-
 void TestInterfaceDBusStubAdapterInternal::unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     subscribersForTestBroadcastWithOutArgsSelective_->erase(clientId);
-    stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+    TestInterfaceDBusStubAdapterHelper::stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
 }
 
 std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestBroadcastWithOutArgsSelective() {
@@ -380,7 +476,6 @@ std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceDBusStubAdapterInter
 }
 
 
-
 const TestInterfaceDBusStubAdapterHelper::StubDispatcherTable& TestInterfaceDBusStubAdapterInternal::getStubDispatcherTable() {
     return stubDispatcherTable_;
 }
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp
index 7f7d7b1..2a3ad56 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_Test_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/TestInterfaceStub.hpp>
+#include "v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -19,6 +20,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -72,74 +74,114 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
-        uint32_t
+        uint32_t                
         > getTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
-        uint32_t
+        uint32_t                    
         > setTestPredefinedTypeAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                
         > getTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestStructExtended
+        ::commonapi::tests::DerivedTypeCollection::TestStructExtended,
+        ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t                    
         > setTestDerivedStructAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                
         > getTestDerivedArrayAttributeAttributeStubDispatcher;
 static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher<
         TestInterfaceStub,
-        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64
+        ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64,
+        ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t                    
         > setTestDerivedArrayAttributeAttributeStubDispatcher;
 
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
+    
     > testEmptyMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<uint32_t, std::string>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
     std::tuple<>
+    
     > testVoidPredefinedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<uint32_t, std::string>,
-    std::tuple<uint32_t, std::string>
+    std::tuple<uint32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
     > testPredefinedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
     std::tuple<>
+    
     > testVoidDerivedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
-    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>
+    std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>,
+    std::tuple<CommonAPI::EmptyDeployment, ::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t>
+    
     > testDerivedTypeMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<std::vector<std::shared_ptr<::commonapi::tests::DerivedTypeCollection::TestPolymorphicStruct>>>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>>,
     std::tuple<>
+    
     > testArrayOfPolymorphicStructMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::MapIntToPolymorphicDeployment_t>,
     std::tuple<>
+    
     > testMapOfPolymorphicStructMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithPolymorphicMemberDeployment_t>,
     std::tuple<>
+    
     > testStructWithPolymorphicMemberMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     TestInterfaceStub,
     std::tuple<::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap>,
+    std::tuple<>,
+    std::tuple<::commonapi::tests::DerivedTypeCollection_::StructWithEnumKeyMapDeployment_t>,
     std::tuple<>
+    
     > testStructWithEnumKeyMapMemberStubDispatcher;
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..f58b844
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.cpp
@@ -0,0 +1,30 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "BranchInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace BranchInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace BranchInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..f87fdb9
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp
@@ -0,0 +1,45 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_BRANCHINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_BRANCHINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace BranchInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace BranchInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_BRANCHINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
index 25fa000..0c7c6ce 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -35,28 +35,61 @@ BranchInterfaceDBusProxy::BranchInterfaceDBusProxy(
 
 
 
-        void BranchInterfaceDBusProxy::testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<BranchInterface::testBranchMethodError, int32_t, std::string> >::callMethodWithReply(
+        void BranchInterfaceDBusProxy::testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<BranchInterface::testBranchMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<BranchInterface::testBranchMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "testBranchMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            _status,
-            _error
-            , _outInt, _outString);
+            deploy_inInt, deploy_inString,
+            _internalCallStatus,
+            deploy_error,
+            deploy_outInt, deploy_outString);
+            _error = deploy_error.getValue();
+            _outInt = deploy_outInt.getValue();
+            _outString = deploy_outString.getValue();
         }
         std::future<CommonAPI::CallStatus> BranchInterfaceDBusProxy::testBranchMethodAsync(const int32_t &_inInt, const std::string &_inString, TestBranchMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<BranchInterface::testBranchMethodError, int32_t, std::string> >::callMethodAsync(
+            CommonAPI::Deployable<BranchInterface::testBranchMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<BranchInterface::testBranchMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "testBranchMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            std::move(_callback),
-            std::tuple<BranchInterface::testBranchMethodError, int32_t, std::string>());
+            deploy_inInt, deploy_inString,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<BranchInterface::testBranchMethodError, CommonAPI::EmptyDeployment> _deploy_error, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _outInt, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> _outString) {
+            	_callback(_status, _deploy_error.getValue(), _outInt.getValue(), _outString.getValue());
+            },
+            std::make_tuple(deploy_error, deploy_outInt, deploy_outString));
         }
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.hpp
index 3738f3d..4f66233 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -41,7 +41,7 @@ public:
 
 
 
-    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
+    virtual void testBranchMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, BranchInterface::testBranchMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testBranchMethodAsync(const int32_t &_inInt, const std::string &_inString, TestBranchMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
index e833d10..ce8f413 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -60,11 +60,18 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     BranchInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<BranchInterface::testBranchMethodError, int32_t, std::string>
-    > BranchInterfaceDBusStubAdapterInternal::testBranchMethodStubDispatcher(&BranchInterfaceStub::testBranchMethod, "iis", std::tuple<int32_t, std::string, BranchInterface::testBranchMethodError, int32_t, std::string>());
+    std::tuple<BranchInterface::testBranchMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
+    > BranchInterfaceDBusStubAdapterInternal::testBranchMethodStubDispatcher(
+    &BranchInterfaceStub::testBranchMethod, "iis",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment *>(nullptr), static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)));
 
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.hpp
index ab1e41b..1da6539 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_MANAGED_Branch_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/managed/BranchInterfaceStub.hpp>
+#include "v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -19,6 +20,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -59,10 +61,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     BranchInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<BranchInterface::testBranchMethodError, int32_t, std::string>
+    std::tuple<BranchInterface::testBranchMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
     > testBranchMethodStubDispatcher;
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..d28ab96
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.cpp
@@ -0,0 +1,30 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "LeafInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace LeafInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace LeafInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..71e0f4c
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp
@@ -0,0 +1,45 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_LEAFINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_LEAFINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace LeafInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace LeafInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_LEAFINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
index 6fe152e..6a26285 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -35,28 +35,61 @@ LeafInterfaceDBusProxy::LeafInterfaceDBusProxy(
 
 
 
-        void LeafInterfaceDBusProxy::testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<LeafInterface::testLeafMethodError, int32_t, std::string> >::callMethodWithReply(
+        void LeafInterfaceDBusProxy::testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<LeafInterface::testLeafMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<LeafInterface::testLeafMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "testLeafMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            _status,
-            _error
-            , _outInt, _outString);
+            deploy_inInt, deploy_inString,
+            _internalCallStatus,
+            deploy_error,
+            deploy_outInt, deploy_outString);
+            _error = deploy_error.getValue();
+            _outInt = deploy_outInt.getValue();
+            _outString = deploy_outString.getValue();
         }
         std::future<CommonAPI::CallStatus> LeafInterfaceDBusProxy::testLeafMethodAsync(const int32_t &_inInt, const std::string &_inString, TestLeafMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<LeafInterface::testLeafMethodError, int32_t, std::string> >::callMethodAsync(
+            CommonAPI::Deployable<LeafInterface::testLeafMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<LeafInterface::testLeafMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "testLeafMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            std::move(_callback),
-            std::tuple<LeafInterface::testLeafMethodError, int32_t, std::string>());
+            deploy_inInt, deploy_inString,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<LeafInterface::testLeafMethodError, CommonAPI::EmptyDeployment> _deploy_error, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _outInt, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> _outString) {
+            	_callback(_status, _deploy_error.getValue(), _outInt.getValue(), _outString.getValue());
+            },
+            std::make_tuple(deploy_error, deploy_outInt, deploy_outString));
         }
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.hpp
index 0dae7b3..8fec7ca 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -41,7 +41,7 @@ public:
 
 
 
-    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
+    virtual void testLeafMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, LeafInterface::testLeafMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testLeafMethodAsync(const int32_t &_inInt, const std::string &_inString, TestLeafMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
index 7e4473e..d622168 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -60,11 +60,18 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LeafInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<LeafInterface::testLeafMethodError, int32_t, std::string>
-    > LeafInterfaceDBusStubAdapterInternal::testLeafMethodStubDispatcher(&LeafInterfaceStub::testLeafMethod, "iis", std::tuple<int32_t, std::string, LeafInterface::testLeafMethodError, int32_t, std::string>());
+    std::tuple<LeafInterface::testLeafMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
+    > LeafInterfaceDBusStubAdapterInternal::testLeafMethodStubDispatcher(
+    &LeafInterfaceStub::testLeafMethod, "iis",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment *>(nullptr), static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)));
 
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.hpp
index e1b739c..853dbfb 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_MANAGED_Leaf_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/managed/LeafInterfaceStub.hpp>
+#include "v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -19,6 +20,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -59,10 +61,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LeafInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<LeafInterface::testLeafMethodError, int32_t, std::string>
+    std::tuple<LeafInterface::testLeafMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
     > testLeafMethodStubDispatcher;
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..c514b7e
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.cpp
@@ -0,0 +1,30 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "RootInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace RootInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace RootInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..63a1fdf
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp
@@ -0,0 +1,45 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_ROOTINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_ROOTINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace RootInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace RootInterface_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_ROOTINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
index c694796..4ad729e 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -37,28 +37,61 @@ RootInterfaceDBusProxy::RootInterfaceDBusProxy(
 
 
 
-        void RootInterfaceDBusProxy::testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<RootInterface::testRootMethodError, int32_t, std::string> >::callMethodWithReply(
+        void RootInterfaceDBusProxy::testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<RootInterface::testRootMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<RootInterface::testRootMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "testRootMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            _status,
-            _error
-            , _outInt, _outString);
+            deploy_inInt, deploy_inString,
+            _internalCallStatus,
+            deploy_error,
+            deploy_outInt, deploy_outString);
+            _error = deploy_error.getValue();
+            _outInt = deploy_outInt.getValue();
+            _outString = deploy_outString.getValue();
         }
         std::future<CommonAPI::CallStatus> RootInterfaceDBusProxy::testRootMethodAsync(const int32_t &_inInt, const std::string &_inString, TestRootMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t, std::string>,
-                                             CommonAPI::DBus::DBusSerializableArguments<RootInterface::testRootMethodError, int32_t, std::string> >::callMethodAsync(
+            CommonAPI::Deployable<RootInterface::testRootMethodError, CommonAPI::EmptyDeployment> deploy_error(static_cast<CommonAPI::EmptyDeployment *>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_inInt(_inInt, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_inString(_inString, static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_outInt(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_outString(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >,
+                CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<RootInterface::testRootMethodError, CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "testRootMethod",
             "is",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _inInt, _inString,
-            std::move(_callback),
-            std::tuple<RootInterface::testRootMethodError, int32_t, std::string>());
+            deploy_inInt, deploy_inString,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<RootInterface::testRootMethodError, CommonAPI::EmptyDeployment> _deploy_error, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _outInt, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> _outString) {
+            	_callback(_status, _deploy_error.getValue(), _outInt.getValue(), _outString.getValue());
+            },
+            std::make_tuple(deploy_error, deploy_outInt, deploy_outString));
         }
 
         CommonAPI::ProxyManager& RootInterfaceDBusProxy::getProxyManagerLeafInterface() {
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.hpp
index 67920ba..a0c7443 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -42,7 +42,7 @@ public:
 
 
 
-    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_status, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
+    virtual void testRootMethod(const int32_t &_inInt, const std::string &_inString, CommonAPI::CallStatus &_internalCallStatus, RootInterface::testRootMethodError &_error, int32_t &_outInt, std::string &_outString, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> testRootMethodAsync(const int32_t &_inInt, const std::string &_inString, TestRootMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
     virtual CommonAPI::ProxyManager& getProxyManagerLeafInterface();
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
index 06a6667..c414d4c 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -84,11 +84,18 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     RootInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<RootInterface::testRootMethodError, int32_t, std::string>
-    > RootInterfaceDBusStubAdapterInternal::testRootMethodStubDispatcher(&RootInterfaceStub::testRootMethod, "iis", std::tuple<int32_t, std::string, RootInterface::testRootMethodError, int32_t, std::string>());
+    std::tuple<RootInterface::testRootMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
+    > RootInterfaceDBusStubAdapterInternal::testRootMethodStubDispatcher(
+    &RootInterfaceStub::testRootMethod, "iis",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment *>(nullptr), static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::DBus::StringDeployment*>(nullptr)));
 
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.hpp
index d5828a3..d50ebe4 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_MANAGED_Root_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/managed/RootInterfaceStub.hpp>
+#include "v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -21,6 +22,7 @@
 #include <CommonAPI/DBus/DBusObjectManager.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -67,10 +69,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     RootInterfaceStub,
     std::tuple<int32_t, std::string>,
-    std::tuple<RootInterface::testRootMethodError, int32_t, std::string>
+    std::tuple<RootInterface::testRootMethodError, int32_t, std::string>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment, CommonAPI::DBus::StringDeployment>
+    
     > testRootMethodStubDispatcher;
 
 
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.cpp
new file mode 100644
index 0000000..855d2af
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.cpp
@@ -0,0 +1,30 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "SecondRootDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace SecondRoot_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace SecondRoot_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp
new file mode 100644
index 0000000..d328176
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp
@@ -0,0 +1,45 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_SECONDROOT_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_SECONDROOT_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace commonapi {
+namespace tests {
+namespace managed {
+namespace SecondRoot_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace SecondRoot_
+} // namespace managed
+} // namespace tests
+} // namespace commonapi
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_SECONDROOT_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.cpp
index ba66245..767912b 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.hpp
index 80053ed..82e6e06 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
index c42347e..36b8c10 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
diff --git a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.hpp
index ee4b556..eaf9944 100644
--- a/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define COMMONAPI_TESTS_MANAGED_Second_Root_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/commonapi/tests/managed/SecondRootStub.hpp>
+#include "v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -21,6 +22,7 @@
 #include <CommonAPI/DBus/DBusObjectManager.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.cpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.cpp
new file mode 100644
index 0000000..19d9740
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.cpp
@@ -0,0 +1,30 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+#include "LegacyInterfaceDBusDeployment.hpp"
+
+namespace v1_0 {
+namespace fake {
+namespace legacy {
+namespace service {
+namespace LegacyInterface_ {
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+ 
+} // namespace LegacyInterface_
+} // namespace service
+} // namespace legacy
+} // namespace fake
+} // namespace v1_0
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp
new file mode 100644
index 0000000..b06463d
--- /dev/null
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp
@@ -0,0 +1,45 @@
+/*
+* This file was generated by the CommonAPI Generators.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
+* Used org.franca.core 0.9.1.201412191134.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+* If a copy of the MPL was not distributed with this file, You can obtain one at
+* http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef COMMONAPI_DBUS_LEGACYINTERFACE_DEPLOYMENT_HPP_
+#define COMMONAPI_DBUS_LEGACYINTERFACE_DEPLOYMENT_HPP_
+
+
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
+#include <CommonAPI/DBus/DBusDeployment.hpp>
+#undef COMMONAPI_INTERNAL_COMPILATION
+
+namespace v1_0 {
+namespace fake {
+namespace legacy {
+namespace service {
+namespace LegacyInterface_ {
+
+// Interface-specific deployment types
+
+// Type-specific deployments
+
+// Attribute-specific deployments
+
+// Argument-specific deployments
+
+// Broadcast-specific deployments
+
+
+} // namespace LegacyInterface_
+} // namespace service
+} // namespace legacy
+} // namespace fake
+} // namespace v1_0
+
+#endif // COMMONAPI_DBUS_LEGACYINTERFACE_DEPLOYMENT_HPP_
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.cpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.cpp
index 2d93d6d..0a14ba3 100644
--- a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.cpp
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -35,67 +35,120 @@ LegacyInterfaceDBusProxy::LegacyInterfaceDBusProxy(
 
 
 
-        void LegacyInterfaceDBusProxy::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t>,
-                                             CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodWithReply(
+        void LegacyInterfaceDBusProxy::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_input(_input, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_val1(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_val2(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "TestMethod",
             "i",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _input,
-            _status
-            , _val1, _val2);
+            deploy_input,
+            _internalCallStatus,
+            deploy_val1, deploy_val2);
+            _val1 = deploy_val1.getValue();
+            _val2 = deploy_val2.getValue();
         }
         std::future<CommonAPI::CallStatus> LegacyInterfaceDBusProxy::TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t>,
-                                             CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodAsync(
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_input(_input, static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_val1(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_val2(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment >
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "TestMethod",
             "i",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _input,
-            std::move(_callback),
-            std::tuple<int32_t, int32_t>());
+            deploy_input,
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _val1, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _val2) {
+            	_callback(_status, _val1.getValue(), _val2.getValue());
+            },
+            std::make_tuple(deploy_val1, deploy_val2));
         }
-        void LegacyInterfaceDBusProxy::OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<std::string, int32_t> >::callMethodWithReply(
+        void LegacyInterfaceDBusProxy::OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) {
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_greeting(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_identifier(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>
+                >
+            >::callMethodWithReply(
             *this,
             "OtherTestMethod",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _status
-            , _greeting, _identifier);
+            _internalCallStatus,
+            deploy_greeting, deploy_identifier);
+            _greeting = deploy_greeting.getValue();
+            _identifier = deploy_identifier.getValue();
         }
         std::future<CommonAPI::CallStatus> LegacyInterfaceDBusProxy::OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<std::string, int32_t> >::callMethodAsync(
+            CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> deploy_greeting(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr));
+            CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> deploy_identifier(static_cast<CommonAPI::EmptyDeployment*>(nullptr));
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                    CommonAPI::Deployable<std::string,CommonAPI::DBus::StringDeployment>,
+                    CommonAPI::Deployable<int32_t,CommonAPI::EmptyDeployment>
+                >
+            >::callMethodAsync(
             *this,
             "OtherTestMethod",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            std::move(_callback),
-            std::tuple<std::string, int32_t>());
+            [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable<std::string, CommonAPI::DBus::StringDeployment> _greeting, CommonAPI::Deployable<int32_t, CommonAPI::EmptyDeployment> _identifier) {
+            	_callback(_status, _greeting.getValue(), _identifier.getValue());
+            },
+            std::make_tuple(deploy_greeting, deploy_identifier));
         }
-        void LegacyInterfaceDBusProxy::finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) {
-            CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply(
+        void LegacyInterfaceDBusProxy::finish(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
+            CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodWithReply(
             *this,
             "finish",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            _status
-            );
+            _internalCallStatus);
         }
         std::future<CommonAPI::CallStatus> LegacyInterfaceDBusProxy::finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
-            return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
-                                             CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync(
+            return CommonAPI::DBus::DBusProxyHelper<
+                CommonAPI::DBus::DBusSerializableArguments<
+                >,
+                CommonAPI::DBus::DBusSerializableArguments<
+                >
+            >::callMethodAsync(
             *this,
             "finish",
             "",
             (_info ? _info : &CommonAPI::DBus::defaultCallInfo),
-            std::move(_callback),
-            std::tuple<>());
+            [_callback] (CommonAPI::CallStatus _status) {
+            	_callback(_status);
+            },
+            std::make_tuple());
         }
 
 
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.hpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.hpp
index b66df50..dbebd0f 100644
--- a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.hpp
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusProxy.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -41,11 +41,11 @@ public:
 
 
 
-    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info);
+    virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info);
+    virtual void OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info);
-    virtual void finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info);
+    virtual void finish(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
     virtual std::future<CommonAPI::CallStatus> finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info);
 
 
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.cpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.cpp
index 7866ba7..6cae1e8 100644
--- a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.cpp
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.cpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -64,21 +64,42 @@ CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<int32_t>,
-    std::tuple<int32_t, int32_t>
-    > LegacyInterfaceDBusStubAdapterInternal::testMethodStubDispatcher(&LegacyInterfaceStub::TestMethod, "ii", std::tuple<int32_t, int32_t, int32_t>());
+    std::tuple<int32_t, int32_t>,
+    std::tuple<CommonAPI::EmptyDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment>
+    
+    > LegacyInterfaceDBusStubAdapterInternal::testMethodStubDispatcher(
+    &LegacyInterfaceStub::TestMethod, "ii",
+					std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr)),
+                	std::make_tuple(static_cast<CommonAPI::EmptyDeployment*>(nullptr), static_cast<CommonAPI::EmptyDeployment*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<>,
-    std::tuple<std::string, int32_t>
-    > LegacyInterfaceDBusStubAdapterInternal::otherTestMethodStubDispatcher(&LegacyInterfaceStub::OtherTestMethod, "si", std::tuple<std::string, int32_t>());
+    std::tuple<std::string, int32_t>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::StringDeployment, CommonAPI::EmptyDeployment>
+    
+    > LegacyInterfaceDBusStubAdapterInternal::otherTestMethodStubDispatcher(
+    &LegacyInterfaceStub::OtherTestMethod, "si",
+					std::make_tuple(),
+                	std::make_tuple(static_cast<CommonAPI::DBus::StringDeployment*>(nullptr), static_cast<CommonAPI::EmptyDeployment*>(nullptr)));
+
 CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
-    > LegacyInterfaceDBusStubAdapterInternal::finishStubDispatcher(&LegacyInterfaceStub::finish, "", std::tuple<>());
+    
+    > LegacyInterfaceDBusStubAdapterInternal::finishStubDispatcher(
+    &LegacyInterfaceStub::finish, "",
+					std::make_tuple(),
+                	std::make_tuple());
 
 
 
diff --git a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.hpp b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.hpp
index 5041822..8aec0a1 100644
--- a/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.hpp
+++ b/src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusStubAdapter.hpp
@@ -1,6 +1,6 @@
 /*
 * This file was generated by the CommonAPI Generators.
-* Used org.genivi.commonapi.core 3.1.2.v201506150834.
+* Used org.genivi.commonapi.core 3.1.2.v201507021046.
 * Used org.franca.core 0.9.1.201412191134.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
@@ -11,6 +11,7 @@
 #define FAKE_LEGACY_SERVICE_Legacy_Interface_DBUS_STUB_ADAPTER_HPP_
 
 #include <v1_0/fake/legacy/service/LegacyInterfaceStub.hpp>
+#include "v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp"        
 
 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
 #define COMMONAPI_INTERNAL_COMPILATION
@@ -19,6 +20,7 @@
 #include <CommonAPI/DBus/DBusFactory.hpp>
 #include <CommonAPI/DBus/DBusStubAdapterHelper.hpp>
 #include <CommonAPI/DBus/DBusStubAdapter.hpp>
+#include <CommonAPI/DBus/DBusDeployment.hpp>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -59,20 +61,32 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 
 
 
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<int32_t>,
-    std::tuple<int32_t, int32_t>
+    std::tuple<int32_t, int32_t>,
+    std::tuple<CommonAPI::EmptyDeployment>,
+    std::tuple<CommonAPI::EmptyDeployment, CommonAPI::EmptyDeployment>
+    
     > testMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<>,
-    std::tuple<std::string, int32_t>
+    std::tuple<std::string, int32_t>,
+    std::tuple<>,
+    std::tuple<CommonAPI::DBus::StringDeployment, CommonAPI::EmptyDeployment>
+    
     > otherTestMethodStubDispatcher;
+
 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     LegacyInterfaceStub,
     std::tuple<>,
+    std::tuple<>,
+    std::tuple<>,
     std::tuple<>
+    
     > finishStubDispatcher;
 
 
diff --git a/src/test/test-freedesktop-interface.fdepl b/src/test/test-freedesktop-interface.fdepl
index 0f309db..067ccec 100644
--- a/src/test/test-freedesktop-interface.fdepl
+++ b/src/test/test-freedesktop-interface.fdepl
@@ -3,14 +3,14 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-import "platform:/plugin/org.genivi.commonapi.dbus/deployment/CommonAPI-DBus_deployment.fdepl"
+import "platform:/plugin/org.genivi.commonapi.dbus/deployment/CommonAPI-DBus_deployment_spec.fdepl"
 import "test-freedesktop-interface.fidl"
 
 
 define org.genivi.commonapi.dbus.deployment for interface commonapi.tests.TestFreedesktopInterface {
-    PropertiesType = freedesktop
+	DBusDefaultAttributeType = freedesktop
 }
 
 define org.genivi.commonapi.dbus.deployment for interface commonapi.tests.TestFreedesktopDerivedInterface {
-    PropertiesType = freedesktop
-}
-\ No newline at end of file
+    DBusDefaultAttributeType = freedesktop
+}
author	Jürgen Gehring <juergen.gehring@bmw.de>	2015-07-29 00:04:02 -0700
committer	Jürgen Gehring <juergen.gehring@bmw.de>	2015-07-29 00:04:02 -0700
commit	db96446ece67ba1f495811e29838e8c7bc7984ff (patch)
tree	ad49d3368287caf7d201057989db4bd19e37fd0c
parent	49d0b428ca19852d49965f35328a314f22d88807 (diff)
download	genivi-common-api-dbus-runtime-db96446ece67ba1f495811e29838e8c7bc7984ff.tar.gz