From db96446ece67ba1f495811e29838e8c7bc7984ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=BCrgen=20Gehring?= Date: Wed, 29 Jul 2015 00:04:02 -0700 Subject: CommonAPI-D-Bus 3.1.3 --- CMakeLists.txt | 23 +- README | 3 + cmake/CommonAPI-DBusConfigVersion.cmake.in | 2 +- include/CommonAPI/DBus/CommonAPIDBus.hpp | 18 + include/CommonAPI/DBus/DBusAddressTranslator.hpp | 19 +- include/CommonAPI/DBus/DBusAttribute.hpp | 2 +- include/CommonAPI/DBus/DBusConnection.hpp | 15 +- include/CommonAPI/DBus/DBusDeployment.hpp | 26 +- include/CommonAPI/DBus/DBusEvent.hpp | 50 +- .../CommonAPI/DBus/DBusFreedesktopAttribute.hpp | 31 +- .../DBus/DBusFreedesktopStubAdapterHelper.hpp | 67 +- include/CommonAPI/DBus/DBusInputStream.hpp | 38 +- .../DBusInstanceAvailabilityStatusChangedEvent.hpp | 20 +- include/CommonAPI/DBus/DBusMainLoopContext.hpp | 8 + include/CommonAPI/DBus/DBusOutputStream.hpp | 46 +- include/CommonAPI/DBus/DBusProxy.hpp | 53 +- .../DBusProxyAsyncSignalMemberCallbackHandler.hpp | 68 + include/CommonAPI/DBus/DBusProxyBase.hpp | 30 +- include/CommonAPI/DBus/DBusProxyConnection.hpp | 3 + include/CommonAPI/DBus/DBusProxyHelper.hpp | 8 +- include/CommonAPI/DBus/DBusStubAdapterHelper.hpp | 96 +- include/CommonAPI/DBus/DBusTypeOutputStream.hpp | 18 +- src/CommonAPI/DBus/DBusAddressTranslator.cpp | 68 +- src/CommonAPI/DBus/DBusConnection.cpp | 380 +++--- src/CommonAPI/DBus/DBusDaemonProxy.cpp | 2 +- src/CommonAPI/DBus/DBusFactory.cpp | 8 +- src/CommonAPI/DBus/DBusMainLoopContext.cpp | 14 +- src/CommonAPI/DBus/DBusProxy.cpp | 237 +++- src/CommonAPI/DBus/DBusProxyBase.cpp | 35 +- src/CommonAPI/DBus/DBusServiceRegistry.cpp | 18 +- ...orrect-dbus-connection-block-pending-call.patch | 13 + src/test/CMakeLists.txt | 13 +- src/test/DBusManagedTest.cpp | 1339 ++++++++++++++++---- src/test/DBusObjectManagerStubTest.cpp | 6 +- src/test/commonapi-dbus.ini | 25 + .../core/commonapi/tests/DerivedTypeCollection.cpp | 4 +- .../core/commonapi/tests/DerivedTypeCollection.hpp | 6 +- .../commonapi/tests/PredefinedTypeCollection.hpp | 2 +- .../v1_0/commonapi/tests/ExtendedInterface.hpp | 2 +- .../commonapi/tests/ExtendedInterfaceProxy.hpp | 8 +- .../commonapi/tests/ExtendedInterfaceProxyBase.hpp | 4 +- .../v1_0/commonapi/tests/ExtendedInterfaceStub.hpp | 2 +- .../tests/ExtendedInterfaceStubDefault.cpp | 2 +- .../tests/ExtendedInterfaceStubDefault.hpp | 2 +- .../tests/TestFreedesktopDerivedInterface.hpp | 2 +- .../tests/TestFreedesktopDerivedInterfaceProxy.hpp | 2 +- .../TestFreedesktopDerivedInterfaceProxyBase.hpp | 2 +- .../tests/TestFreedesktopDerivedInterfaceStub.hpp | 2 +- .../TestFreedesktopDerivedInterfaceStubDefault.cpp | 8 +- .../TestFreedesktopDerivedInterfaceStubDefault.hpp | 2 +- .../commonapi/tests/TestFreedesktopInterface.hpp | 2 +- .../tests/TestFreedesktopInterfaceProxy.hpp | 2 +- .../tests/TestFreedesktopInterfaceProxyBase.hpp | 2 +- .../tests/TestFreedesktopInterfaceStub.hpp | 2 +- .../tests/TestFreedesktopInterfaceStubDefault.cpp | 26 +- .../tests/TestFreedesktopInterfaceStubDefault.hpp | 2 +- .../core/v1_0/commonapi/tests/TestInterface.hpp | 2 +- .../v1_0/commonapi/tests/TestInterfaceProxy.hpp | 56 +- .../commonapi/tests/TestInterfaceProxyBase.hpp | 20 +- .../v1_0/commonapi/tests/TestInterfaceStub.hpp | 2 +- .../commonapi/tests/TestInterfaceStubDefault.cpp | 40 +- .../commonapi/tests/TestInterfaceStubDefault.hpp | 2 +- .../commonapi/tests/managed/BranchInterface.cpp | 2 +- .../commonapi/tests/managed/BranchInterface.hpp | 2 +- .../tests/managed/BranchInterfaceProxy.hpp | 8 +- .../tests/managed/BranchInterfaceProxyBase.hpp | 4 +- .../tests/managed/BranchInterfaceStub.hpp | 2 +- .../tests/managed/BranchInterfaceStubDefault.cpp | 2 +- .../tests/managed/BranchInterfaceStubDefault.hpp | 2 +- .../v1_0/commonapi/tests/managed/LeafInterface.cpp | 2 +- .../v1_0/commonapi/tests/managed/LeafInterface.hpp | 2 +- .../commonapi/tests/managed/LeafInterfaceProxy.hpp | 8 +- .../tests/managed/LeafInterfaceProxyBase.hpp | 4 +- .../commonapi/tests/managed/LeafInterfaceStub.hpp | 2 +- .../tests/managed/LeafInterfaceStubDefault.cpp | 2 +- .../tests/managed/LeafInterfaceStubDefault.hpp | 2 +- .../v1_0/commonapi/tests/managed/RootInterface.cpp | 2 +- .../v1_0/commonapi/tests/managed/RootInterface.hpp | 2 +- .../commonapi/tests/managed/RootInterfaceProxy.hpp | 8 +- .../tests/managed/RootInterfaceProxyBase.hpp | 4 +- .../commonapi/tests/managed/RootInterfaceStub.hpp | 2 +- .../tests/managed/RootInterfaceStubDefault.cpp | 38 +- .../tests/managed/RootInterfaceStubDefault.hpp | 2 +- .../v1_0/commonapi/tests/managed/SecondRoot.hpp | 2 +- .../commonapi/tests/managed/SecondRootProxy.hpp | 2 +- .../tests/managed/SecondRootProxyBase.hpp | 2 +- .../commonapi/tests/managed/SecondRootStub.hpp | 2 +- .../tests/managed/SecondRootStubDefault.cpp | 20 +- .../tests/managed/SecondRootStubDefault.hpp | 2 +- .../v1_0/fake/legacy/service/LegacyInterface.hpp | 2 +- .../fake/legacy/service/LegacyInterfaceProxy.hpp | 20 +- .../legacy/service/LegacyInterfaceProxyBase.hpp | 8 +- .../fake/legacy/service/LegacyInterfaceStub.hpp | 2 +- .../legacy/service/LegacyInterfaceStubDefault.cpp | 2 +- .../legacy/service/LegacyInterfaceStubDefault.hpp | 2 +- .../tests/DerivedTypeCollectionDBusDeployment.cpp | 21 + .../tests/DerivedTypeCollectionDBusDeployment.hpp | 102 ++ .../tests/ExtendedInterfaceDBusDeployment.cpp | 28 + .../tests/ExtendedInterfaceDBusDeployment.hpp | 43 + .../commonapi/tests/ExtendedInterfaceDBusProxy.cpp | 37 +- .../commonapi/tests/ExtendedInterfaceDBusProxy.hpp | 4 +- .../tests/ExtendedInterfaceDBusStubAdapter.cpp | 123 +- .../tests/ExtendedInterfaceDBusStubAdapter.hpp | 64 +- ...stFreedesktopDerivedInterfaceDBusDeployment.cpp | 28 + ...stFreedesktopDerivedInterfaceDBusDeployment.hpp | 43 + .../TestFreedesktopDerivedInterfaceDBusProxy.cpp | 4 +- .../TestFreedesktopDerivedInterfaceDBusProxy.hpp | 2 +- ...tFreedesktopDerivedInterfaceDBusStubAdapter.cpp | 44 +- ...tFreedesktopDerivedInterfaceDBusStubAdapter.hpp | 26 +- .../TestFreedesktopInterfaceDBusDeployment.cpp | 28 + .../TestFreedesktopInterfaceDBusDeployment.hpp | 44 + .../tests/TestFreedesktopInterfaceDBusProxy.cpp | 10 +- .../tests/TestFreedesktopInterfaceDBusProxy.hpp | 7 +- .../TestFreedesktopInterfaceDBusStubAdapter.cpp | 66 +- .../TestFreedesktopInterfaceDBusStubAdapter.hpp | 22 +- .../tests/TestInterfaceDBusDeployment.cpp | 28 + .../tests/TestInterfaceDBusDeployment.hpp | 44 + .../commonapi/tests/TestInterfaceDBusProxy.cpp | 359 ++++-- .../commonapi/tests/TestInterfaceDBusProxy.hpp | 29 +- .../tests/TestInterfaceDBusStubAdapter.cpp | 187 ++- .../tests/TestInterfaceDBusStubAdapter.hpp | 60 +- .../managed/BranchInterfaceDBusDeployment.cpp | 30 + .../managed/BranchInterfaceDBusDeployment.hpp | 45 + .../tests/managed/BranchInterfaceDBusProxy.cpp | 59 +- .../tests/managed/BranchInterfaceDBusProxy.hpp | 4 +- .../managed/BranchInterfaceDBusStubAdapter.cpp | 13 +- .../managed/BranchInterfaceDBusStubAdapter.hpp | 10 +- .../tests/managed/LeafInterfaceDBusDeployment.cpp | 30 + .../tests/managed/LeafInterfaceDBusDeployment.hpp | 45 + .../tests/managed/LeafInterfaceDBusProxy.cpp | 59 +- .../tests/managed/LeafInterfaceDBusProxy.hpp | 4 +- .../tests/managed/LeafInterfaceDBusStubAdapter.cpp | 13 +- .../tests/managed/LeafInterfaceDBusStubAdapter.hpp | 10 +- .../tests/managed/RootInterfaceDBusDeployment.cpp | 30 + .../tests/managed/RootInterfaceDBusDeployment.hpp | 45 + .../tests/managed/RootInterfaceDBusProxy.cpp | 59 +- .../tests/managed/RootInterfaceDBusProxy.hpp | 4 +- .../tests/managed/RootInterfaceDBusStubAdapter.cpp | 13 +- .../tests/managed/RootInterfaceDBusStubAdapter.hpp | 10 +- .../tests/managed/SecondRootDBusDeployment.cpp | 30 + .../tests/managed/SecondRootDBusDeployment.hpp | 45 + .../tests/managed/SecondRootDBusProxy.cpp | 2 +- .../tests/managed/SecondRootDBusProxy.hpp | 2 +- .../tests/managed/SecondRootDBusStubAdapter.cpp | 2 +- .../tests/managed/SecondRootDBusStubAdapter.hpp | 4 +- .../service/LegacyInterfaceDBusDeployment.cpp | 30 + .../service/LegacyInterfaceDBusDeployment.hpp | 45 + .../legacy/service/LegacyInterfaceDBusProxy.cpp | 113 +- .../legacy/service/LegacyInterfaceDBusProxy.hpp | 8 +- .../service/LegacyInterfaceDBusStubAdapter.cpp | 33 +- .../service/LegacyInterfaceDBusStubAdapter.hpp | 20 +- src/test/test-freedesktop-interface.fdepl | 8 +- 152 files changed, 4232 insertions(+), 1224 deletions(-) create mode 100644 README create mode 100644 include/CommonAPI/DBus/CommonAPIDBus.hpp create mode 100644 include/CommonAPI/DBus/DBusProxyAsyncSignalMemberCallbackHandler.hpp create mode 100644 src/dbus-patches/capi-dbus-correct-dbus-connection-block-pending-call.patch create mode 100644 src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/commonapi/tests/DerivedTypeCollectionDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp create mode 100644 src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.cpp create mode 100644 src/test/src-gen/dbus/v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp 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 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 #include +#include #include #include #include @@ -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 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(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 connection_; DBusConnection* dbusConnection_; @@ -130,6 +130,8 @@ public: COMMONAPI_EXPORT bool isDispatchReady(); COMMONAPI_EXPORT bool singleDispatch(); + COMMONAPI_EXPORT virtual bool hasDispatchThread(); + typedef std::tuple DBusSignalMatchRuleTuple; typedef std::pair DBusSignalMatchRuleMapping; typedef std::unordered_map 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 MainloopTimeout_t; + typedef std::tuple< + DBusMessageReplyAsyncHandler *, + DBusMessage, + CommonAPI::CallStatus, + ::DBusPendingCall* + > MainloopTimeout_t; mutable std::list mainloopTimeouts_; mutable std::mutex enforceTimeoutMutex_; mutable std::condition_variable enforceTimeoutCondition_; - + mutable std::shared_ptr 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 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 +struct StructDeployment : CommonAPI::Deployment<_Types...> { + StructDeployment(_Types*... t) + : CommonAPI::Deployment<_Types...>(t...) {}; +}; + +template +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 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::type()); } + + virtual void onInitialValueSignalDBusMessage(const DBusMessage&_message, const uint32_t tag) { + handleSignalDBusMessage(tag, _message, typename make_sequence::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 @@ -74,12 +107,23 @@ public: } } + template + 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 +template 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 @@ -145,16 +149,15 @@ protected: std::string propertyName_; }; -template +template 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()); 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 &_clientId) = 0; }; -template +template 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 &_clientId) { CommonAPI::Deployable, 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 clientId = std::make_shared(std::string(_message.getSender())); - CommonAPI::Deployable, VariantDeployment<>> deployedVariant( - (_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::getStubFunctor_))(clientId), &freedesktopVariant); + CommonAPI::Deployable, VariantDeployment<_AttributeDepl>> deployedVariant( + (_stub.get()->*(DBusGetAttributeStubDispatcher<_StubClass, _AttributeType, _AttributeDepl>::getStubFunctor_))(clientId), &actualDepl); DBusOutputStream output(reply); output << deployedVariant; @@ -66,13 +67,13 @@ protected: } }; -template +template 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, _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, VariantDeployment<>> deployedVariant(&freedesktopVariant); @@ -102,28 +104,29 @@ protected: } }; -template +template 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(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 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(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& getDependentDispatchSources(); void addDependentDispatchSource(DispatchSource* dispatchSource); private: @@ -57,6 +61,10 @@ class DBusWatch: public Watch { std::vector dependentDispatchSources_; std::weak_ptr 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 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); @@ -288,6 +292,15 @@ public: return (*this); } + /** + * 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 @@ -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(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(); @@ -360,15 +389,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_; @@ -77,6 +124,10 @@ private: mutable std::mutex availabilityMutex_; mutable std::condition_variable availabilityCondition_; + + std::list 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 can be included directly, this file may disappear or change contents." +#endif + +#ifndef COMMONAPI_DBUS_DBUSPROXYASYNCSIGNALMEMBERCALLBACKHANDLER_HPP_ +#define COMMONAPI_DBUS_DBUSPROXYASYNCSIGNALMEMBERCALLBACKHANDLER_HPP_ + +#include +#include +#include + +//#include +#include +#include + +namespace CommonAPI { +namespace DBus { + +class DBusProxyAsyncSignalMemberCallbackHandler: public DBusProxyConnection::DBusMessageReplyAsyncHandler { + public: + typedef std::function FunctionType; + + static std::unique_ptr create( + FunctionType& callback, DBusProxyConnection::DBusSignalHandler* dbusSignalHandler, + const int tag) { + return std::unique_ptr( + 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 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 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, 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, 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, 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 clientId = std::make_shared(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(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> } }; -template< class, class > +template< class, class, class > class DBusMethodStubDispatcher; template < typename _StubClass, - template class _In, class... _InArgs> -class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAdapterHelper<_StubClass>::StubDispatcher { + template class _In, class... _InArgs, + template 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, _InArgs...); - DBusMethodStubDispatcher(_StubFunctor stubFunctor): + DBusMethodStubDispatcher(_StubFunctor stubFunctor, std::tuple<_DeplInArgs*...> _in): stubFunctor_(stubFunctor) { + initialize(typename make_sequence_range::type(), _in); } bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) { - return handleDBusMessage(dbusMessage, stub, dbusStubAdapterHelper, typename make_sequence::type()); + return handleDBusMessage(dbusMessage, stub, dbusStubAdapterHelper, typename make_sequence_range::type()); } private: + template + inline void initialize(index_sequence<_DeplInArgIndices...>, std::tuple<_DeplInArgs*...> &_in) { + in_ = std::make_tuple(std::get<_DeplInArgIndices>(_in)...); + } + template 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...>::deserialize(dbusInputStream, std::get<_InArgIndices>(in_)...); if (!success) return false; } std::shared_ptr clientId = std::make_shared(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...> in_; }; -template< class, class, class> +template< class, class, class, class, class> class DBusMethodWithReplyStubDispatcher; template < typename _StubClass, template class _In, class... _InArgs, - template class _Out, class... _OutArgs> -class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutArgs...> >: + template class _Out, class... _OutArgs, + template class _DeplIn, class... _DeplInArgs, + template 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, _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::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::type(), - typename make_sequence_range::type(), args_); + typename make_sequence_range::type()); } - bool sendReply(CommonAPI::CallId_t _call, std::tuple<_OutArgs...> args = std::make_tuple()) { + bool sendReply(CommonAPI::CallId_t _call, + std::tuple...> args = std::make_tuple()) { return sendReplyInternal(_call, typename make_sequence_range::type(), args); } private: + + template + inline void initialize(index_sequence<_DeplInArgIndices...>, std::tuple<_DeplInArgs*...> &_in) { + in_ = std::make_tuple(std::get<_DeplInArgIndices>(_in)...); + } + + template 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...>::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 bool sendReplyInternal(CommonAPI::CallId_t _call, index_sequence<_OutArgIndices...>, - std::tuple<_OutArgs...> args) { + std::tuple...> args) { std::lock_guard 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...>::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...> in_; + std::tuple<_DeplOutArgs*...> out_; CommonAPI::CallId_t currentCall_; std::map 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 TypeOutputStream &writeType(const Variant<_Types...> &_value, const _Deployment *_depl) { - if (_depl != nullptr && _depl->isFreeDesktop_) { - signature_.append("v"); - } else { - signature_.append("(yv)"); - } - TypeOutputStreamWriteVisitor typeVisitor(*this); - ApplyVoidVisitor, - Variant<_Types...>, _Types...>::visit(typeVisitor, _value); + if (_depl != nullptr && _depl->isDBus_) { + signature_.append("v"); + } else { + signature_.append("(yv)"); + } + TypeOutputStreamWriteVisitor typeVisitor(*this); + ApplyVoidVisitor, + Variant<_Types...>, _Types...>::visit(typeVisitor, _value); return (*this); } template 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::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 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 #include + 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 selfReference = this->shared_from_this(); - while (!stopDispatching_ && readWriteDispatch(10) && selfReference.use_count() > ownUseCount) { - if (pauseDispatching_) { - dispatchSuspendLock_.lock(); - dispatchSuspendLock_.unlock(); - } - } + std::shared_ptr 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 itsRegistry = DBusServiceRegistry::get(shared_from_this()); - disconnect(); + //std::shared_ptr 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 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 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::bind(&DBusConnection::enforceAsynchronousTimeouts, shared_from_this())); + enforcerThread_ = std::make_shared( + 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 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(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(_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 itsLock(enforcerThreadMutex_); + std::unique_lock itsLock(enforcerThreadMutex_); - while (!enforcerThreadCancelled_) { + while (!enforcerThreadCancelled_) { enforceTimeoutMutex_.lock(); int timeout = std::numeric_limits::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(minTimeout - now).count(); + timeout = (int)std::chrono::duration_cast(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 DBusConnection::sendDBusMessageWithReplyAsync( const DBusMessage& dbusMessage, std::unique_ptr dbusMessageReplyAsyncHandler, - const CommonAPI::CallInfo *_info) const { + const CommonAPI::CallInfo *_info) const { assert(dbusMessage); assert(isConnected()); @@ -555,56 +570,47 @@ std::future 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, - DBusMessageReplyAsyncHandler*, - DBusMessage> toInsert { - timeoutPoint, - replyAsyncHandler, - dbusMessage - }; + std::chrono::time_point, + DBusMessageReplyAsyncHandler*, + DBusMessage> toInsert { + timeoutPoint, + replyAsyncHandler, + dbusMessage + }; enforceTimeoutMutex_.lock(); timeoutMap_.insert( { libdbusPendingCall, toInsert } ); @@ -622,7 +628,7 @@ std::future 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::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& 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 itsConnection - = std::make_shared(dBusBusType_); + = std::make_shared(dbusType); connections_.insert({ _connectionId, itsConnection }); itsConnection->connect(true); @@ -244,7 +244,7 @@ Factory::getConnection(std::shared_ptr _context) { // No connection found, lets create and initialize one std::shared_ptr itsConnection - = std::make_shared(dBusBusType_); + = std::make_shared(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& 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 #include #include +#include +#include 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 lock(availabilityMutex_); + std::unique_lock 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 @@ -35,20 +35,6 @@ DBusProxyBase::getDBusConnection() const { return connection_; } -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, @@ -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 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 #include @@ -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 connection) { + +const CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict getManagedObjects(const std::string& _dbusServiceName, const std::string& _dbusObjectPath, + std::shared_ptr _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 runtime_; - std::shared_ptr proxyDBusConnection_; - std::shared_ptr stubDBusConnection_; + std::shared_ptr manualDBusConnection_; CommonAPI::AvailabilityStatus leafStatus_; @@ -105,37 +144,58 @@ public: TEST_F(DBusManagedTest, RegisterRoot) { auto rootStub = std::make_shared(); - 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(); - runtime_->registerService(domain, leafAddress, leafStub); + auto leafStub = std::make_shared(); + 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(); - runtime_->registerService(domain, rootAddress, rootStub); - - std::shared_ptr rootProxy = std::make_shared< - VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>( - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + auto rootStub = std::make_shared(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); + auto leafStub = std::make_shared(); - 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(); - bool success = runtime_->registerService(domain, rootAddress, rootStub); - ASSERT_TRUE(success); - - std::shared_ptr rootProxy = std::make_shared< - VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>( - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + auto rootStub = std::make_shared(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); - success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); - ASSERT_TRUE(success); + auto leafStub = std::make_shared(); + 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(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(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(); - bool success = runtime_->registerService(domain, rootAddress, rootStub); - - ASSERT_TRUE(success); - - std::shared_ptr rootProxy = std::make_shared< - VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>( - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + auto rootStub = std::make_shared(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); - bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); - ASSERT_TRUE(reg); + auto leafStub = std::make_shared(); + 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(leafInstance); + auto leafProxy = proxyManagerLeafInterface.buildProxy(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(); + 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 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 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(domain, getSuffixedRootAddress(suffix))); + CommonAPI::DBus::DBusAddress rootDBusAddress; + CommonAPI::Address rootCommonAPIAddress(domain, getSuffixedRootInstanceName(suffix), rootInterfaceName); + CommonAPI::DBus::DBusAddressTranslator::get()->translate(rootCommonAPIAddress, rootDBusAddress); + + std::shared_ptr proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr rootProxy = std::make_shared< + VERSION::commonapi::tests::managed::RootInterfaceDBusProxy>( + rootDBusAddress, + proxyConnection + ); + rootProxy->init(); + rootProxies_.push_back(rootProxy); } template @@ -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 leafStub = std::make_shared< - VERSION::commonapi::tests::managed::LeafInterfaceStubDefault>(); + std::shared_ptr 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> leafProxiesForRootX; + std::vector> leafProxiesForRootX; CommonAPI::ProxyManager& leafProxyManager = rootProxyIterator->getProxyManagerLeafInterface(); std::vector availableInstances; @@ -406,20 +533,20 @@ protected: leafProxyManager.getAvailableInstances(status, availableInstances); for (const std::string& availableInstance : availableInstances) { - auto newLeafProxy = leafProxyManager.buildProxy(availableInstance); + auto newLeafProxy = leafProxyManager.buildProxy(availableInstance); leafProxiesForRootX.push_back(newLeafProxy); } leafProxies_.push_back(std::move(leafProxiesForRootX)); - } + } } std::shared_ptr runtime_; - std::shared_ptr manualTestDBusConnection_; + std::shared_ptr manualDBusConnection_; - std::unordered_map> rootStubs_; - std::vector> rootProxies_; - std::vector>>leafProxies_; + std::unordered_map> rootStubs_; + std::vector> rootProxies_; + std::vector>> 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 subscriptions; - - // auto leafStub = std::make_shared(); - // bool success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); - // ASSERT_TRUE(success); - // - // sleep(2); - // - // auto leafProxy = proxyManagerLeafInterface.buildProxy(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(); + 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(); + ASSERT_TRUE(runtime_->registerService(domain, secondRootInstanceName, secondRootStub)); - std::shared_ptr 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(); - auto leafStub2 = std::make_shared(); + auto leafStub1 = std::make_shared(); + auto leafStub2 = std::make_shared(); - 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(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); - auto leafStub2 = std::make_shared(); + auto leafStub = std::make_shared(); + auto branchStub = std::make_shared(); + + 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(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); - runtime_->getServicePublisher()->registerService(leafStub1, leafAddress, serviceFactory_); + auto leafStub = std::make_shared(); + runtime_->registerService(domain, leafInstanceNameRoot, leafStub); - auto leafStub2 = std::make_shared(); - runtime_->getServicePublisher()->registerService(leafStub2, branchAddress, serviceFactory_); + auto branchStub = std::make_shared(); + 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(); + 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(); + + 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(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); + auto invalidLeafStub = std::make_shared(); + auto validBranchStub = std::make_shared(); + + 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(); + 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(); + int numberOfAutoGeneratedInstances = 5; + for(int i=0; iregisterManagedStubLeafInterfaceAutoInstance(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(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); + int numberOfAutoGeneratedInstances = 5; + for(int i=0; iregisterManagedStubLeafInterfaceAutoInstance(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; igetProxyManagerLeafInterface().buildProxy(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(); + 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(); + + //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(); + 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 proxyConnection = CommonAPI::DBus::DBusConnection::getBus(CommonAPI::DBus::DBusType_t::SESSION); + proxyConnection->connect(); + + std::shared_ptr 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(); + + //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 DerivedTypeCollect switch (_serial) { case DerivedTypeCollection::TESTPOLYMORPHICSTRUCT_SERIAL: return std::make_shared(); - case DerivedTypeCollection::TESTEXTENDEDPOLYMORPHICSTRUCT_SERIAL: + case TESTEXTENDEDPOLYMORPHICSTRUCT_SERIAL: return std::make_shared(); 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 TestArrayTestStruct; - typedef std::unordered_map TestMap; + typedef std::unordered_map TestMap; /** * description: Common errors. */ @@ -178,7 +178,7 @@ struct DerivedTypeCollection { } }; - typedef std::unordered_map> TestEnumMap; + typedef std::unordered_map<::commonapi::tests::DerivedTypeCollection::TestEnum, std::string, CommonAPI::EnumHasher<::commonapi::tests::DerivedTypeCollection::TestEnum>> TestEnumMap; struct TestEnumMissingValue : CommonAPI::Enumeration { 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 -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 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 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::stubAdapter_->fireTestAttributedFromDerivedInterfaceAttributeChanged(testAttributedFromDerivedInterfaceAttributeValue_); - } + if (valueChanged && CommonAPI::Stub::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr); + virtual void TestArrayOfPolymorphicStructMethod(const std::vector> &_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 -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 @@ -384,8 +384,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->testEmptyMethodAsync(_callback, _info); } template -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 @@ -393,8 +393,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->testVoidPredefinedTypeMethodAsync(_uint32Value, _stringValue, _callback, _info); } template -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 @@ -402,8 +402,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->testPredefinedTypeMethodAsync(_uint32InValue, _stringInValue, _callback, _info); } template -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 @@ -411,8 +411,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->testVoidDerivedTypeMethodAsync(_testEnumExtended2Value, _testMapValue, _callback, _info); } template -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 @@ -420,8 +420,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->testDerivedTypeMethodAsync(_testEnumExtended2InValue, _testMapInValue, _callback, _info); } template -void TestInterfaceProxy<_AttributeExtensions...>::TestArrayOfPolymorphicStructMethod(const std::vector> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) { - delegate_->TestArrayOfPolymorphicStructMethod(_inArray, _status, _info); +void TestInterfaceProxy<_AttributeExtensions...>::TestArrayOfPolymorphicStructMethod(const std::vector> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) { + delegate_->TestArrayOfPolymorphicStructMethod(_inArray, _internalCallStatus, _info); } template @@ -429,8 +429,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->TestArrayOfPolymorphicStructMethodAsync(_inArray, _callback, _info); } template -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 @@ -438,8 +438,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->TestMapOfPolymorphicStructMethodAsync(_inMap, _callback, _info); } template -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 @@ -447,8 +447,8 @@ std::future TestInterfaceProxy<_AttributeExtensions...>:: return delegate_->TestStructWithPolymorphicMemberMethodAsync(_inStruct, _callback, _info); } template -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 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 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 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 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 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 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> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual void TestArrayOfPolymorphicStructMethod(const std::vector> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0; virtual std::future TestArrayOfPolymorphicStructMethodAsync(const std::vector> &_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 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 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 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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_ != NULL) { + CommonAPI::Stub::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::stubAdapter_) !=NULL); + CommonAPI::Stub::stubAdapter_->fireTestPredefinedTypeBroadcastEvent(_uint32Value, _stringValue); } void TestInterfaceStubDefault::fireTestSelectiveBroadcastSelective(const std::shared_ptr _receivers) { - assert(stubAdapter_ !=NULL); - stubAdapter_->sendTestSelectiveBroadcastSelective(_receivers); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + CommonAPI::Stub::stubAdapter_->sendTestSelectiveBroadcastSelective(_receivers); } void TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr _client, const CommonAPI::SelectiveBroadcastSubscriptionEvent _event) { // No operation in default @@ -236,13 +236,13 @@ bool TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionRequ return true; } std::shared_ptr const TestInterfaceStubDefault::getSubscribersForTestSelectiveBroadcastSelective() { - assert(stubAdapter_ !=NULL); - return(stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective()); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return(CommonAPI::Stub::stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective()); } void TestInterfaceStubDefault::fireTestBroadcastWithOutArgsSelective(const uint32_t &_uint32Value, const std::string &_stringValue, const std::shared_ptr _receivers) { - assert(stubAdapter_ !=NULL); - stubAdapter_->sendTestBroadcastWithOutArgsSelective(_uint32Value, _stringValue, _receivers); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + CommonAPI::Stub::stubAdapter_->sendTestBroadcastWithOutArgsSelective(_uint32Value, _stringValue, _receivers); } void TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr _client, const CommonAPI::SelectiveBroadcastSubscriptionEvent _event) { // No operation in default @@ -252,8 +252,8 @@ bool TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionRe return true; } std::shared_ptr const TestInterfaceStubDefault::getSubscribersForTestBroadcastWithOutArgsSelective() { - assert(stubAdapter_ !=NULL); - return(stubAdapter_->getSubscribersForTestBroadcastWithOutArgsSelective()); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return(CommonAPI::Stub::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 -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 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 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 -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 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 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 -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 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 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 _stub) { autoInstanceCounter_++; std::stringstream ss; - ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; + ss << CommonAPI::Stub::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; std::string instance = ss.str(); - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubLeafInterface(_stub, instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubLeafInterface(_stub, instance); } bool RootInterfaceStubDefault::registerManagedStubLeafInterface(std::shared_ptr _stub, const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubLeafInterface(_stub, _instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubLeafInterface(_stub, _instance); } bool RootInterfaceStubDefault::deregisterManagedStubLeafInterface(const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->deregisterManagedStubLeafInterface(_instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->deregisterManagedStubLeafInterface(_instance); } std::set& RootInterfaceStubDefault::getLeafInterfaceInstances() { - assert(stubAdapter_ !=NULL); - return stubAdapter_->getLeafInterfaceInstances(); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->getLeafInterfaceInstances(); } bool RootInterfaceStubDefault::registerManagedStubBranchInterfaceAutoInstance(std::shared_ptr _stub) { autoInstanceCounter_++; std::stringstream ss; - ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; + ss << CommonAPI::Stub::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; std::string instance = ss.str(); - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubBranchInterface(_stub, instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubBranchInterface(_stub, instance); } bool RootInterfaceStubDefault::registerManagedStubBranchInterface(std::shared_ptr _stub, const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubBranchInterface(_stub, _instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubBranchInterface(_stub, _instance); } bool RootInterfaceStubDefault::deregisterManagedStubBranchInterface(const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->deregisterManagedStubBranchInterface(_instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->deregisterManagedStubBranchInterface(_instance); } std::set& RootInterfaceStubDefault::getBranchInterfaceInstances() { - assert(stubAdapter_ !=NULL); - return stubAdapter_->getBranchInterfaceInstances(); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::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 _stub) { autoInstanceCounter_++; std::stringstream ss; - ss << stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; + ss << CommonAPI::Stub::stubAdapter_->getAddress().getInstance() << ".i" << autoInstanceCounter_; std::string instance = ss.str(); - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubLeafInterface(_stub, instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubLeafInterface(_stub, instance); } bool SecondRootStubDefault::registerManagedStubLeafInterface(std::shared_ptr _stub, const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->registerManagedStubLeafInterface(_stub, _instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->registerManagedStubLeafInterface(_stub, _instance); } bool SecondRootStubDefault::deregisterManagedStubLeafInterface(const std::string &_instance) { - assert(stubAdapter_ !=NULL); - return stubAdapter_->deregisterManagedStubLeafInterface(_instance); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::stubAdapter_->deregisterManagedStubLeafInterface(_instance); } std::set& SecondRootStubDefault::getLeafInterfaceInstances() { - assert(stubAdapter_ !=NULL); - return stubAdapter_->getLeafInterfaceInstances(); + assert((CommonAPI::Stub::stubAdapter_) !=NULL); + return CommonAPI::Stub::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 -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 @@ -158,8 +158,8 @@ std::future LegacyInterfaceProxy<_AttributeExtensions...> return delegate_->TestMethodAsync(_input, _callback, _info); } template -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 @@ -167,8 +167,8 @@ std::future LegacyInterfaceProxy<_AttributeExtensions...> return delegate_->OtherTestMethodAsync(_callback, _info); } template -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 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 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 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 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 +#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 +#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<> >::callMethodWithReply( + void ExtendedInterfaceDBusProxy::TestIntMethodExtended(const uint32_t &_inInt, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) { + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + > + >::callMethodWithReply( *this, "TestIntMethodExtended", "u", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _inInt, - _status - ); + deploy_inInt, + _internalCallStatus); } std::future ExtendedInterfaceDBusProxy::TestIntMethodExtendedAsync(const uint32_t &_inInt, TestIntMethodExtendedAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync( + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable + >, + 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 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, + std::tuple<>, + std::tuple, std::tuple<> - > ExtendedInterfaceDBusStubAdapterInternal::testIntMethodExtendedStubDispatcher(&ExtendedInterfaceStub::TestIntMethodExtended, "", std::tuple()); + + > ExtendedInterfaceDBusStubAdapterInternal::testIntMethodExtendedStubDispatcher( + &ExtendedInterfaceStub::TestIntMethodExtended, "", + std::make_tuple(static_cast(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, + std::tuple<>, + std::tuple, std::tuple<> - > ExtendedInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testVoidPredefinedTypeMethod, "", std::tuple()); + + > ExtendedInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher( + &ExtendedInterfaceStub::testVoidPredefinedTypeMethod, "", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple()); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple, - std::tuple - > ExtendedInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(&ExtendedInterfaceStub::testPredefinedTypeMethod, "us", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > ExtendedInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher( + &ExtendedInterfaceStub::testPredefinedTypeMethod, "us", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr))); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>, + std::tuple<>, + std::tuple, 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(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, + std::tuple + + > ExtendedInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher( + &ExtendedInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}", + std::make_tuple(static_cast(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr))); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple>>, + std::tuple<>, + std::tuple>, std::tuple<> - > ExtendedInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(&ExtendedInterfaceStub::TestArrayOfPolymorphicStructMethod, "", std::tuple>>()); + + > ExtendedInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher( + &ExtendedInterfaceStub::TestArrayOfPolymorphicStructMethod, "", + std::make_tuple(static_cast*>(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 #include +#include "v1_0/commonapi/tests/ExtendedInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -20,6 +21,7 @@ #include #include #include +#include #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, + std::tuple<>, + std::tuple, 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, + std::tuple<>, + std::tuple, std::tuple<> + > testVoidPredefinedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > testPredefinedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>, + std::tuple<>, + std::tuple, 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, + std::tuple + > testDerivedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< ExtendedInterfaceStub, std::tuple>>, + std::tuple<>, + std::tuple>, 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 +#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 &_connection) : CommonAPI::DBus::DBusProxy(_address, _connection), TestFreedesktopInterfaceDBusProxy(_address, _connection) -, testAttributedFromDerivedInterface_(*this, "onTestAttributedFromDerivedInterfaceAttributeChanged", "setTestAttributedFromDerivedInterfaceAttribute", "u", "getTestAttributedFromDerivedInterfaceAttribute") +, testAttributedFromDerivedInterface_(*this, "onTestAttributedFromDerivedInterfaceAttributeChanged", "setTestAttributedFromDerivedInterfaceAttribute", "u", "getTestAttributedFromDerivedInterfaceAttribute", static_cast(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::DBusStubSignalHelper> ::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 #include +#include "v1_0/commonapi/tests/TestFreedesktopDerivedInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -20,6 +21,7 @@ #include #include #include +#include #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 + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif +#include +#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 &_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(nullptr)), + testReadonlyAttribute_(*this, "onTestReadonlyAttributeAttributeChanged", "u", "getTestReadonlyAttributeAttribute", static_cast(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 +#include #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -53,8 +54,8 @@ private: CommonAPI::DBus::DBusObservableAttribute> testPredefinedTypeAttribute_; CommonAPI::DBus::DBusObservableAttribute> testReadonlyAttribute_; - CommonAPI::DBus::DBusObservableAttribute> testDerivedStructAttribute_; - CommonAPI::DBus::DBusObservableAttribute> testDerivedArrayAttribute_; + CommonAPI::DBus::DBusObservableAttribute> testDerivedStructAttribute_; + CommonAPI::DBus::DBusObservableAttribute> 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::DBusStubSignalHelper> ::sendSignal( *this, "onTestPredefinedTypeAttributeAttributeChanged", "u", value + ); } void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestReadonlyAttributeAttributeChanged(const uint32_t& value) { - CommonAPI::DBus::DBusStubSignalHelper> + CommonAPI::DBus::DBusStubSignalHelper> ::sendSignal( *this, "onTestReadonlyAttributeAttributeChanged", "u", value + ); } void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestDerivedStructAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& value) { - CommonAPI::DBus::DBusStubSignalHelper> + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestStructExtended, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr)); + CommonAPI::DBus::DBusStubSignalHelper + >> ::sendSignal( *this, "onTestDerivedStructAttributeAttributeChanged", "(sqi)", - value + deployedValue + ); } void TestFreedesktopInterfaceDBusStubAdapterInternal::fireTestDerivedArrayAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& value) { - CommonAPI::DBus::DBusStubSignalHelper> + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr)); + CommonAPI::DBus::DBusStubSignalHelper + >> ::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 +#include "v1_0/commonapi/tests/TestFreedesktopInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -19,6 +20,7 @@ #include #include #include +#include #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 + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif +#include +#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 &_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()), - testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", "", std::tuple<>()), - testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us", std::tuple()) +, testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute", static_cast(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(nullptr), static_cast(nullptr))), + testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", "", std::make_tuple()), + testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us", std::make_tuple(static_cast(nullptr), static_cast(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<> >::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 TestInterfaceDBusProxy::testEmptyMethodAsync(TestEmptyMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - 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<> >::callMethodWithReply( + void TestInterfaceDBusProxy::testVoidPredefinedTypeMethod(const uint32_t &_uint32Value, const std::string &_stringValue, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) { + CommonAPI::Deployable deploy_uint32Value(_uint32Value, static_cast(nullptr)); + CommonAPI::Deployable deploy_stringValue(_stringValue, static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + > + >::callMethodWithReply( *this, "testVoidPredefinedTypeMethod", "us", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _uint32Value, _stringValue, - _status - ); + deploy_uint32Value, deploy_stringValue, + _internalCallStatus); } std::future TestInterfaceDBusProxy::testVoidPredefinedTypeMethodAsync(const uint32_t &_uint32Value, const std::string &_stringValue, TestVoidPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync( + CommonAPI::Deployable deploy_uint32Value(_uint32Value, static_cast(nullptr)); + CommonAPI::Deployable deploy_stringValue(_stringValue, static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + 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 >::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 deploy_uint32InValue(_uint32InValue, static_cast(nullptr)); + CommonAPI::Deployable deploy_stringInValue(_stringInValue, static_cast(nullptr)); + CommonAPI::Deployable deploy_uint32OutValue(static_cast(nullptr)); + CommonAPI::Deployable deploy_stringOutValue(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 TestInterfaceDBusProxy::testPredefinedTypeMethodAsync(const uint32_t &_uint32InValue, const std::string &_stringInValue, TestPredefinedTypeMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_uint32InValue(_uint32InValue, static_cast(nullptr)); + CommonAPI::Deployable deploy_stringInValue(_stringInValue, static_cast(nullptr)); + CommonAPI::Deployable deploy_uint32OutValue(static_cast(nullptr)); + CommonAPI::Deployable deploy_stringOutValue(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "testPredefinedTypeMethod", "us", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _uint32InValue, _stringInValue, - std::move(_callback), - std::tuple()); + deploy_uint32InValue, deploy_stringInValue, + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _uint32OutValue, CommonAPI::Deployable _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<> >::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(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 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<> >::callMethodAsync( + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2Value(_testEnumExtended2Value, static_cast(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> >::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(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(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 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> >::callMethodAsync( + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, CommonAPI::EmptyDeployment> deploy_testEnumExtended2InValue(_testEnumExtended2InValue, static_cast(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(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> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) { - CommonAPI::DBus::DBusProxyHelper>>, - CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply( + void TestInterfaceDBusProxy::TestArrayOfPolymorphicStructMethod(const std::vector> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) { + CommonAPI::Deployable>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>> deploy_inArray(_inArray, static_cast*>(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable>, 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 TestInterfaceDBusProxy::TestArrayOfPolymorphicStructMethodAsync(const std::vector> &_inArray, TestArrayOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper>>, - CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync( + CommonAPI::Deployable>, CommonAPI::DBus::ArrayDeployment<::commonapi::tests::DerivedTypeCollection_::TestPolymorphicStructDeployment_t>> deploy_inArray(_inArray, static_cast*>(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable>, 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<> >::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 TestInterfaceDBusProxy::TestMapOfPolymorphicStructMethodAsync(const ::commonapi::tests::DerivedTypeCollection::MapIntToPolymorphic &_inMap, TestMapOfPolymorphicStructMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - 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<> >::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 TestInterfaceDBusProxy::TestStructWithPolymorphicMemberMethodAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithPolymorphicMember &_inStruct, TestStructWithPolymorphicMemberMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - 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<> >::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 TestInterfaceDBusProxy::TestStructWithEnumKeyMapMemberAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, TestStructWithEnumKeyMapMemberAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - 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 +#include #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 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 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 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 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 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> &_inArray, CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info); + virtual void TestArrayOfPolymorphicStructMethod(const std::vector> &_inArray, CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info); virtual std::future TestArrayOfPolymorphicStructMethodAsync(const std::vector> &_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 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 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 TestStructWithEnumKeyMapMemberAsync(const ::commonapi::tests::DerivedTypeCollection::StructWithEnumKeyMap &_inStruct, TestStructWithEnumKeyMapMemberAsyncCallback _callback, const CommonAPI::CallInfo *_info); @@ -75,12 +76,12 @@ public: private: CommonAPI::DBus::DBusObservableAttribute> testPredefinedTypeAttribute_; - CommonAPI::DBus::DBusObservableAttribute> testDerivedStructAttribute_; - CommonAPI::DBus::DBusObservableAttribute> testDerivedArrayAttribute_; + CommonAPI::DBus::DBusObservableAttribute> testDerivedStructAttribute_; + CommonAPI::DBus::DBusObservableAttribute> testDerivedArrayAttribute_; - CommonAPI::DBus::DBusEvent testPredefinedTypeBroadcast_; + CommonAPI::DBus::DBusEvent, CommonAPI::Deployable> testPredefinedTypeBroadcast_; CommonAPI::DBus::DBusSelectiveEvent testSelectiveBroadcastSelective_; - CommonAPI::DBus::DBusSelectiveEvent testBroadcastWithOutArgsSelective_; + CommonAPI::DBus::DBusSelectiveEvent, CommonAPI::Deployable> 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, + std::tuple<>, + std::tuple, std::tuple<> - > TestInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher(&TestInterfaceStub::testVoidPredefinedTypeMethod, "", std::tuple()); + + > TestInterfaceDBusStubAdapterInternal::testVoidPredefinedTypeMethodStubDispatcher( + &TestInterfaceStub::testVoidPredefinedTypeMethod, "", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple()); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple, - std::tuple - > TestInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher(&TestInterfaceStub::testPredefinedTypeMethod, "us", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > TestInterfaceDBusStubAdapterInternal::testPredefinedTypeMethodStubDispatcher( + &TestInterfaceStub::testPredefinedTypeMethod, "us", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr))); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>, + std::tuple<>, + std::tuple, 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(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, + std::tuple + + > TestInterfaceDBusStubAdapterInternal::testDerivedTypeMethodStubDispatcher( + &TestInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}", + std::make_tuple(static_cast(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast<::commonapi::tests::DerivedTypeCollection_::TestMapDeployment_t*>(nullptr))); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple>>, + std::tuple<>, + std::tuple>, std::tuple<> - > TestInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher(&TestInterfaceStub::TestArrayOfPolymorphicStructMethod, "", std::tuple>>()); + + > TestInterfaceDBusStubAdapterInternal::testArrayOfPolymorphicStructMethodStubDispatcher( + &TestInterfaceStub::TestArrayOfPolymorphicStructMethod, "", + std::make_tuple(static_cast*>(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::DBusStubSignalHelper> ::sendSignal( *this, "onTestPredefinedTypeAttributeAttributeChanged", "u", value + ); } void TestInterfaceDBusStubAdapterInternal::fireTestDerivedStructAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestStructExtended& value) { - CommonAPI::DBus::DBusStubSignalHelper> + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestStructExtended, ::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestStructExtendedDeployment_t*>(nullptr)); + CommonAPI::DBus::DBusStubSignalHelper + >> ::sendSignal( *this, "onTestDerivedStructAttributeAttributeChanged", "(sqi)", - value + deployedValue + ); } void TestInterfaceDBusStubAdapterInternal::fireTestDerivedArrayAttributeAttributeChanged(const ::commonapi::tests::DerivedTypeCollection::TestArrayUInt64& value) { - CommonAPI::DBus::DBusStubSignalHelper> + CommonAPI::Deployable<::commonapi::tests::DerivedTypeCollection::TestArrayUInt64, ::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t> deployedValue(value, static_cast<::commonapi::tests::DerivedTypeCollection_::TestArrayUInt64Deployment_t*>(nullptr)); + CommonAPI::DBus::DBusStubSignalHelper + >> ::sendSignal( *this, "onTestDerivedArrayAttributeAttributeChanged", "at", - value + deployedValue + ); } void TestInterfaceDBusStubAdapterInternal::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) { - CommonAPI::DBus::DBusStubSignalHelper> - ::sendSignal( - *this, - "TestPredefinedTypeBroadcast", - "us", - uint32Value, stringValue - ); + CommonAPI::DBus::DBusStubSignalHelper + >>::sendSignal( + *this, + "TestPredefinedTypeBroadcast", + "us", + uint32Value, + CommonAPI::Deployable(stringValue, static_cast(nullptr)) + ); } CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher< TestInterfaceStub, @@ -271,8 +367,8 @@ void TestInterfaceDBusStubAdapterInternal::fireTestSelectiveBroadcastSelective(c if(dbusClient) { - CommonAPI::DBus::DBusStubSignalHelper> - ::sendSignal( + CommonAPI::DBus::DBusStubSignalHelper>::sendSignal( dbusClient->getDBusId(), *this, "TestSelectiveBroadcast", @@ -295,26 +391,24 @@ void TestInterfaceDBusStubAdapterInternal::sendTestSelectiveBroadcastSelective(c } void TestInterfaceDBusStubAdapterInternal::subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr 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 clientId) { subscribersForTestSelectiveBroadcastSelective_->erase(clientId); - stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED); + TestInterfaceDBusStubAdapterHelper::stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED); } std::shared_ptr const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestSelectiveBroadcastSelective() { return subscribersForTestSelectiveBroadcastSelective_; } - CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher< TestInterfaceStub, TestInterfaceStubAdapter, @@ -334,13 +428,16 @@ void TestInterfaceDBusStubAdapterInternal::fireTestBroadcastWithOutArgsSelective if(dbusClient) { - CommonAPI::DBus::DBusStubSignalHelper> - ::sendSignal( + CommonAPI::DBus::DBusStubSignalHelper + >>::sendSignal( dbusClient->getDBusId(), *this, "TestBroadcastWithOutArgs", "us", - _uint32Value, _stringValue + _uint32Value, + CommonAPI::Deployable(_stringValue, static_cast(nullptr)) ); } } @@ -359,20 +456,19 @@ void TestInterfaceDBusStubAdapterInternal::sendTestBroadcastWithOutArgsSelective } void TestInterfaceDBusStubAdapterInternal::subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr 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 clientId) { subscribersForTestBroadcastWithOutArgsSelective_->erase(clientId); - stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED); + TestInterfaceDBusStubAdapterHelper::stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED); } std::shared_ptr const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestBroadcastWithOutArgsSelective() { @@ -380,7 +476,6 @@ std::shared_ptr 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 +#include "v1_0/commonapi/tests/TestInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -19,6 +20,7 @@ #include #include #include +#include #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, + std::tuple<>, + std::tuple, std::tuple<> + > testVoidPredefinedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > testPredefinedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple<::commonapi::tests::DerivedTypeCollection::TestEnumExtended2, ::commonapi::tests::DerivedTypeCollection::TestMap>, + std::tuple<>, + std::tuple, 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, + std::tuple + > testDerivedTypeMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple>>, + std::tuple<>, + std::tuple>, 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 +#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 >::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 deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 BranchInterfaceDBusProxy::testBranchMethodAsync(const int32_t &_inInt, const std::string &_inString, TestBranchMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "testBranchMethod", "is", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _inInt, _inString, - std::move(_callback), - std::tuple()); + deploy_inInt, deploy_inString, + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _deploy_error, CommonAPI::Deployable _outInt, CommonAPI::Deployable _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 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, - std::tuple - > BranchInterfaceDBusStubAdapterInternal::testBranchMethodStubDispatcher(&BranchInterfaceStub::testBranchMethod, "iis", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > BranchInterfaceDBusStubAdapterInternal::testBranchMethodStubDispatcher( + &BranchInterfaceStub::testBranchMethod, "iis", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr), static_cast(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 +#include "v1_0/commonapi/tests/managed/BranchInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -19,6 +20,7 @@ #include #include #include +#include #undef COMMONAPI_INTERNAL_COMPILATION @@ -59,10 +61,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher< + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< BranchInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > 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 +#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 >::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 deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 LeafInterfaceDBusProxy::testLeafMethodAsync(const int32_t &_inInt, const std::string &_inString, TestLeafMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "testLeafMethod", "is", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _inInt, _inString, - std::move(_callback), - std::tuple()); + deploy_inInt, deploy_inString, + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _deploy_error, CommonAPI::Deployable _outInt, CommonAPI::Deployable _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 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, - std::tuple - > LeafInterfaceDBusStubAdapterInternal::testLeafMethodStubDispatcher(&LeafInterfaceStub::testLeafMethod, "iis", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > LeafInterfaceDBusStubAdapterInternal::testLeafMethodStubDispatcher( + &LeafInterfaceStub::testLeafMethod, "iis", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr), static_cast(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 +#include "v1_0/commonapi/tests/managed/LeafInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -19,6 +20,7 @@ #include #include #include +#include #undef COMMONAPI_INTERNAL_COMPILATION @@ -59,10 +61,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher< + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< LeafInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > 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 +#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 >::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 deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 RootInterfaceDBusProxy::testRootMethodAsync(const int32_t &_inInt, const std::string &_inString, TestRootMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_error(static_cast(nullptr)); + CommonAPI::Deployable deploy_inInt(_inInt, static_cast(nullptr)); + CommonAPI::Deployable deploy_inString(_inString, static_cast(nullptr)); + CommonAPI::Deployable deploy_outInt(static_cast(nullptr)); + CommonAPI::Deployable deploy_outString(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "testRootMethod", "is", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _inInt, _inString, - std::move(_callback), - std::tuple()); + deploy_inInt, deploy_inString, + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _deploy_error, CommonAPI::Deployable _outInt, CommonAPI::Deployable _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 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, - std::tuple - > RootInterfaceDBusStubAdapterInternal::testRootMethodStubDispatcher(&RootInterfaceStub::testRootMethod, "iis", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > RootInterfaceDBusStubAdapterInternal::testRootMethodStubDispatcher( + &RootInterfaceStub::testRootMethod, "iis", + std::make_tuple(static_cast(nullptr), static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr), static_cast(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 +#include "v1_0/commonapi/tests/managed/RootInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -21,6 +22,7 @@ #include #include #include +#include #undef COMMONAPI_INTERNAL_COMPILATION @@ -67,10 +69,14 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher< + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< RootInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > 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 +#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 +#include "v1_0/commonapi/tests/managed/SecondRootDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -21,6 +22,7 @@ #include #include #include +#include #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 +#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 >::callMethodWithReply( + void LegacyInterfaceDBusProxy::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_internalCallStatus, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) { + CommonAPI::Deployable deploy_input(_input, static_cast(nullptr)); + CommonAPI::Deployable deploy_val1(static_cast(nullptr)); + CommonAPI::Deployable deploy_val2(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 LegacyInterfaceDBusProxy::TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_input(_input, static_cast(nullptr)); + CommonAPI::Deployable deploy_val1(static_cast(nullptr)); + CommonAPI::Deployable deploy_val2(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "TestMethod", "i", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - _input, - std::move(_callback), - std::tuple()); + deploy_input, + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _val1, CommonAPI::Deployable _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 >::callMethodWithReply( + void LegacyInterfaceDBusProxy::OtherTestMethod(CommonAPI::CallStatus &_internalCallStatus, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) { + CommonAPI::Deployable deploy_greeting(static_cast(nullptr)); + CommonAPI::Deployable deploy_identifier(static_cast(nullptr)); + CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::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 LegacyInterfaceDBusProxy::OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - CommonAPI::DBus::DBusSerializableArguments >::callMethodAsync( + CommonAPI::Deployable deploy_greeting(static_cast(nullptr)); + CommonAPI::Deployable deploy_identifier(static_cast(nullptr)); + return CommonAPI::DBus::DBusProxyHelper< + CommonAPI::DBus::DBusSerializableArguments< + >, + CommonAPI::DBus::DBusSerializableArguments< + CommonAPI::Deployable, + CommonAPI::Deployable + > + >::callMethodAsync( *this, "OtherTestMethod", "", (_info ? _info : &CommonAPI::DBus::defaultCallInfo), - std::move(_callback), - std::tuple()); + [_callback] (CommonAPI::CallStatus _status, CommonAPI::Deployable _greeting, CommonAPI::Deployable _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<> >::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 LegacyInterfaceDBusProxy::finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info) { - return CommonAPI::DBus::DBusProxyHelper, - 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 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 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 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, - std::tuple - > LegacyInterfaceDBusStubAdapterInternal::testMethodStubDispatcher(&LegacyInterfaceStub::TestMethod, "ii", std::tuple()); + std::tuple, + std::tuple, + std::tuple + + > LegacyInterfaceDBusStubAdapterInternal::testMethodStubDispatcher( + &LegacyInterfaceStub::TestMethod, "ii", + std::make_tuple(static_cast(nullptr)), + std::make_tuple(static_cast(nullptr), static_cast(nullptr))); + CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< LegacyInterfaceStub, std::tuple<>, - std::tuple - > LegacyInterfaceDBusStubAdapterInternal::otherTestMethodStubDispatcher(&LegacyInterfaceStub::OtherTestMethod, "si", std::tuple()); + std::tuple, + std::tuple<>, + std::tuple + + > LegacyInterfaceDBusStubAdapterInternal::otherTestMethodStubDispatcher( + &LegacyInterfaceStub::OtherTestMethod, "si", + std::make_tuple(), + std::make_tuple(static_cast(nullptr), static_cast(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 +#include "v1_0/fake/legacy/service/LegacyInterfaceDBusDeployment.hpp" #if !defined (COMMONAPI_INTERNAL_COMPILATION) #define COMMONAPI_INTERNAL_COMPILATION @@ -19,6 +20,7 @@ #include #include #include +#include #undef COMMONAPI_INTERNAL_COMPILATION @@ -59,20 +61,32 @@ static CommonAPI::DBus::DBusGetAttributeStubDispatcher< + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< LegacyInterfaceStub, std::tuple, - std::tuple + std::tuple, + std::tuple, + std::tuple + > testMethodStubDispatcher; + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< LegacyInterfaceStub, std::tuple<>, - std::tuple + std::tuple, + std::tuple<>, + std::tuple + > 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 +} -- cgit v1.2.1