src/CommonAPI/DBus/DBusFactory.h \
src/CommonAPI/DBus/DBusProxyHelper.h \
src/CommonAPI/DBus/DBusRuntime.h \
+ src/CommonAPI/DBus/DBusSelectiveEvent.h \
src/CommonAPI/DBus/DBusSerializableArguments.h \
src/CommonAPI/DBus/DBusServicePublisher.h \
src/CommonAPI/DBus/DBusServiceRegistry.h \
DBusCommunicationTest \
DBusMultipleConnectionTest \
DBusServicePublisherTest \
- DBusClientIdTest
+ DBusClientIdTest \
+ DBusSelectiveBroadcastTest
TESTS = ${check_PROGRAMS}
DBusDynamicLoadingNoValidityTest_CXXFLAGS = ${GTEST_CXXFLAGS}
DBusDynamicLoadingNoValidityTest_LDADD = ${LDADD_FOR_GTEST_WITHOUT_LIBCOMMON_API_DBUS}
-
-DBusClientIdTest_SOURCES = src/test/DBusClientIdTest.cpp
+DBusClientIdTest_SOURCES = \
+ src/test/DBusClientIdTest.cpp
DBusClientIdTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
DBusClientIdTest_CXXFLAGS = ${GTEST_CXXFLAGS}
DBusClientIdTest_LDADD = ${LDADD_FOR_GTEST}
+
+DBusSelectiveBroadcastTest_SOURCES = \
+ ${TestInterfaceDBusSources} \
+ src/test/DBusSelectiveBroadcastTest.cpp
+DBusSelectiveBroadcastTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
+DBusSelectiveBroadcastTest_CXXFLAGS = ${GTEST_CXXFLAGS}
+DBusSelectiveBroadcastTest_LDADD = ${LDADD_FOR_GTEST}
+
endif
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "DBusClientId.h"
+#include "DBusMessage.h"
#include <typeinfo>
+namespace std {
+
+template<>
+struct hash<CommonAPI::DBus::DBusClientId> {
+public:
+ size_t operator()(CommonAPI::DBus::DBusClientId* dbusClientIdToHash) const {
+ return (hash<string>()(dbusClientIdToHash->dbusId_));
+ }
+};
+
+} /* namespace std */
+
namespace CommonAPI {
namespace DBus {
bool DBusClientId::operator==(CommonAPI::ClientId& clientIdToCompare) {
try {
DBusClientId clientIdToCompareDBus = DBusClientId(dynamic_cast<DBusClientId&>(clientIdToCompare));
- return (&clientIdToCompareDBus == this);
+ return (clientIdToCompareDBus == *this);
}
catch (const std::bad_cast& e) {
return false;
return (clientIdToCompare.dbusId_ == dbusId_);
}
+size_t DBusClientId::hashCode()
+{
+ return std::hash<DBusClientId>()(this);
+}
+
+DBusMessage DBusClientId::createMessage(const std::string objectPath, const std::string interfaceName, const std::string signalName) const
+{
+ DBusMessage returnMessage = DBusMessage::createSignal(objectPath, interfaceName, signalName);
+ returnMessage.setDestination(dbusId_.c_str());
+
+ return(returnMessage);
+}
+
} /* namespace DBus */
} /* namespace CommonAPI */
+
+
namespace CommonAPI {
namespace DBus {
+class DBusMessage;
+
/**
* \brief Implementation of CommonAPI::ClientId for DBus
*
* It internally uses a string to identify clients. This string is the unique sender id used by dbus.
*/
class DBusClientId: public CommonAPI::ClientId {
+ friend class std::hash<DBusClientId>;
+
public:
DBusClientId(std::string dbusId);
bool operator==(CommonAPI::ClientId& clientIdToCompare);
bool operator==(DBusClientId& clientIdToCompare);
+ size_t hashCode();
+
+ DBusMessage createMessage(const std::string objectPath, const std::string interfaceName, const std::string signalName) const;
protected:
std::string dbusId_;
};
#include "DBusConnection.h"
#include "DBusInputStream.h"
+#include "DBusProxy.h"
#include <algorithm>
#include <sstream>
return (dbus_connection_get_dispatch_status(libdbusConnection_) == DBUS_DISPATCH_DATA_REMAINS);
}
+DBusProxyConnection::DBusSignalHandlerToken DBusConnection::subscribeForSelectiveBroadcast(
+ bool& subscriptionAccepted,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusSignalHandler* dbusSignalHandler,
+ DBusProxy* callingProxy) {
+
+ const char* methodName = ("subscribeFor" + interfaceMemberName + "Selective").c_str();
+
+ subscriptionAccepted = false;
+ CommonAPI::CallStatus callStatus;
+ DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
+ CommonAPI::DBus::DBusSerializableArguments<bool>>::callMethodWithReply(
+ *callingProxy, methodName, "", callStatus, subscriptionAccepted);
+
+ DBusProxyConnection::DBusSignalHandlerToken subscriptionToken;
+
+ if (callStatus == CommonAPI::CallStatus::SUCCESS && subscriptionAccepted) {
+ subscriptionToken = addSignalMemberHandler(
+ objectPath,
+ interfaceName,
+ interfaceMemberName,
+ interfaceMemberSignature,
+ dbusSignalHandler,
+ true);
+
+ subscriptionAccepted = true;
+ }
+
+ return (subscriptionToken);
+}
+
+void DBusConnection::unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+ DBusProxyConnection::DBusSignalHandlerToken subscription,
+ DBusProxy* callingProxy) {
+ bool lastListenerOnConnectionRemoved = removeSignalMemberHandler(subscription);
+
+ if (lastListenerOnConnectionRemoved) {
+ // send unsubscribe message to stub
+ const char* methodName = ("unsubscribeFrom" + eventName + "Selective").c_str();
+ CommonAPI::CallStatus callStatus;
+ DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
+ CommonAPI::DBus::DBusSerializableArguments<>>::callMethodWithReply(
+ *callingProxy, methodName, "", callStatus);
+ }
+}
DBusProxyConnection::DBusSignalHandlerToken DBusConnection::addSignalMemberHandler(const std::string& objectPath,
const std::string& interfaceName,
const std::string& interfaceMemberName,
const std::string& interfaceMemberSignature,
- DBusSignalHandler* dbusSignalHandler) {
+ DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter) {
DBusSignalHandlerPath dbusSignalHandlerPath(
objectPath,
interfaceName,
interfaceMemberName,
interfaceMemberSignature);
- std::lock_guard<std::mutex> dbusSignalLock(signalGuard_);
- const bool isFirstSignalMemberHandler = dbusSignalHandlerTable_.find(dbusSignalHandlerPath) == dbusSignalHandlerTable_.end();
+ std::lock_guard < std::mutex > dbusSignalLock(signalGuard_);
+ const bool isFirstSignalMemberHandler = dbusSignalHandlerTable_.find(dbusSignalHandlerPath)
+ == dbusSignalHandlerTable_.end();
dbusSignalHandlerTable_.insert(DBusSignalHandlerTable::value_type(dbusSignalHandlerPath, dbusSignalHandler));
if (isFirstSignalMemberHandler) {
- addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
+ addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName, justAddFilter);
}
return dbusSignalHandlerPath;
}
-void DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) {
+bool DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) {
+ bool lastHandlerRemoved = false;
+
std::lock_guard<std::mutex> dbusSignalLock(signalGuard_);
auto equalRangeIteratorPair = dbusSignalHandlerTable_.equal_range(dbusSignalHandlerToken);
if (equalRangeIteratorPair.first != equalRangeIteratorPair.second) {
- // advance to the next element
- equalRangeIteratorPair.first++;
+ // advance to the next element
+ equalRangeIteratorPair.first++;
- // check if the first element was the only element
- const bool isLastSignalMemberHandler = equalRangeIteratorPair.first == equalRangeIteratorPair.second;
+ // check if the first element was the only element
+ const bool isLastSignalMemberHandler = equalRangeIteratorPair.first == equalRangeIteratorPair.second;
- if (isLastSignalMemberHandler) {
- const std::string& objectPath = std::get<0>(dbusSignalHandlerToken);
- const std::string& interfaceName = std::get<1>(dbusSignalHandlerToken);
- const std::string& interfaceMemberName = std::get<2>(dbusSignalHandlerToken);
+ if (isLastSignalMemberHandler) {
+ const std::string& objectPath = std::get<0>(dbusSignalHandlerToken);
+ const std::string& interfaceName = std::get<1>(dbusSignalHandlerToken);
+ const std::string& interfaceMemberName = std::get<2>(dbusSignalHandlerToken);
- removeLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
- }
+ removeLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
+ lastHandlerRemoved = true;
+ }
- dbusSignalHandlerTable_.erase(dbusSignalHandlerToken);
+ dbusSignalHandlerTable_.erase(equalRangeIteratorPair.first, equalRangeIteratorPair.first);
}
+
+ return lastHandlerRemoved;
}
void DBusConnection::registerObjectPath(const std::string& objectPath) {
void DBusConnection::addLibdbusSignalMatchRule(const std::string& objectPath,
const std::string& interfaceName,
- const std::string& interfaceMemberName) {
+ const std::string& interfaceMemberName,
+ const bool justAddFilter) {
DBusSignalMatchRuleTuple dbusSignalMatchRuleTuple(objectPath, interfaceName, interfaceMemberName);
auto matchRuleIterator = dbusSignalMatchRulesMap_.find(dbusSignalMatchRuleTuple);
const bool matchRuleFound = matchRuleIterator != dbusSignalMatchRulesMap_.end();
std::string matchRuleString = matchRuleStringStream.str();
auto success = dbusSignalMatchRulesMap_.insert(
DBusSignalMatchRulesMap::value_type(dbusSignalMatchRuleTuple,
- DBusSignalMatchRuleMapping(1, matchRuleString)));
+ DBusSignalMatchRuleMapping(1, matchRuleString)));
assert(success.second);
// if not connected the filter and the rules will be added as soon as the connection is established
// add the libdbus message signal filter
if (isFirstMatchRule) {
const dbus_bool_t libdbusSuccess = dbus_connection_add_filter(libdbusConnection_,
- &onLibdbusSignalFilterThunk,
- this,
- NULL);
+ &onLibdbusSignalFilterThunk,
+ this,
+ NULL);
assert(libdbusSuccess);
}
- // finally add the match rule
- DBusError dbusError;
- dbus_bus_add_match(libdbusConnection_, matchRuleString.c_str(), &dbusError.libdbusError_);
- assert(!dbusError);
+ if (!justAddFilter)
+ {
+ // finally add the match rule
+ DBusError dbusError;
+ dbus_bus_add_match(libdbusConnection_, matchRuleString.c_str(), &dbusError.libdbusError_);
+ assert(!dbusError);
+ }
resumeDispatching();
}
::DBusHandlerResult DBusConnection::onLibdbusSignalFilter(::DBusMessage* libdbusMessage) {
assert(libdbusMessage);
+
auto selfReference = this->shared_from_this();
// handle only signal messages
int timeoutMilliseconds = kDefaultSendTimeoutMs) const;
DBusSignalHandlerToken addSignalMemberHandler(const std::string& objectPath,
- const std::string& interfaceName,
- const std::string& interfaceMemberName,
- const std::string& interfaceMemberSignature,
- DBusSignalHandler* dbusSignalHandler);
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter = false);
+
+ DBusProxyConnection::DBusSignalHandlerToken subscribeForSelectiveBroadcast(bool& subscriptionAccepted,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusSignalHandler* dbusSignalHandler,
+ DBusProxy* callingProxy);
+
+ void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+ DBusProxyConnection::DBusSignalHandlerToken subscription,
+ DBusProxy* callingProxy);
void registerObjectPath(const std::string& objectPath);
void unregisterObjectPath(const std::string& objectPath);
- void removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken);
-
+ bool removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken);
bool readWriteDispatch(int timeoutMilliseconds = -1);
virtual const std::shared_ptr<DBusServiceRegistry> getDBusServiceRegistry();
bool isDispatchReady();
bool singleDispatch();
+ typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
+ typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
+ typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
private:
void dispatch();
void suspendDispatching() const;
void addLibdbusSignalMatchRule(const std::string& objectPath,
const std::string& interfaceName,
- const std::string& interfaceMemberName);
+ const std::string& interfaceMemberName,
+ const bool justAddFilter = false);
void removeLibdbusSignalMatchRule(const std::string& objectPath,
const std::string& interfaceName,
DBusConnectionStatusEvent dbusConnectionStatusEvent_;
- typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
- typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
- typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
+
DBusSignalMatchRulesMap dbusSignalMatchRulesMap_;
DBusSignalHandlerTable dbusSignalHandlerTable_;
template <typename _EventType, typename _DBusProxy = DBusProxyBase>
class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandler {
public:
- typedef typename _EventType::ArgumentsTuple ArgumentsTuple;
- typedef typename _EventType::CancellableListener CancellableListener;
+ typedef typename _EventType::ArgumentsTuple ArgumentsTuple;
+ typedef typename _EventType::CancellableListener CancellableListener;
- DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature):
- dbusProxy_(dbusProxy),
- eventName_(eventName),
- eventSignature_(eventSignature) {
+
+ DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature):
+ dbusProxy_(dbusProxy),
+ eventName_(eventName),
+ eventSignature_(eventSignature) {
interfaceName_ = dbusProxy.getInterfaceName().c_str();
objectPath_ = dbusProxy_.getDBusObjectPath().c_str();
assert(eventName_);
assert(eventSignature_);
assert(objectPath_);
assert(interfaceName_);
- }
+ }
- DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature, const char* objPath, const char* interfaceName) :
+ DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature, const char* objPath, const char* interfaceName) :
dbusProxy_(dbusProxy),
eventName_(eventName),
eventSignature_(eventSignature),
assert(interfaceName);
}
- virtual ~DBusEvent() {
- if (this->hasListeners())
- dbusProxy_.removeSignalMemberHandler(subscription_);
- }
-
- virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage& dbusMessage) {
- return unpackArgumentsAndHandleSignalDBusMessage(dbusMessage, ArgumentsTuple());
- }
+ virtual ~DBusEvent() {
+ if (this->hasListeners())
+ dbusProxy_.removeSignalMemberHandler(subscription_);
+ }
+ virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage& dbusMessage) {
+ return unpackArgumentsAndHandleSignalDBusMessage(dbusMessage, ArgumentsTuple());
+ }
protected:
- virtual void onFirstListenerAdded(const CancellableListener&) {
- subscription_ = dbusProxy_.addSignalMemberHandler(objectPath_, interfaceName_,
- eventName_, eventSignature_, this);
- }
+ virtual void onFirstListenerAdded(const CancellableListener&) {
+ subscription_ = dbusProxy_.addSignalMemberHandler(objectPath_, interfaceName_,
+ eventName_, eventSignature_, this);
+ }
- virtual void onLastListenerRemoved(const CancellableListener&) {
- dbusProxy_.removeSignalMemberHandler(subscription_);
- }
+ virtual void onLastListenerRemoved(const CancellableListener&) {
+ dbusProxy_.removeSignalMemberHandler(subscription_);
+ }
- template <typename ... _Arguments>
- inline SubscriptionStatus unpackArgumentsAndHandleSignalDBusMessage(const DBusMessage& dbusMessage, std::tuple<_Arguments...> argTuple) {
- return handleSignalDBusMessage(dbusMessage, std::move(argTuple), typename make_sequence<sizeof...(_Arguments)>::type());
- }
+ template <typename ... _Arguments>
+ inline SubscriptionStatus unpackArgumentsAndHandleSignalDBusMessage(const DBusMessage& dbusMessage, std::tuple<_Arguments...> argTuple) {
+ return handleSignalDBusMessage(dbusMessage, std::move(argTuple), typename make_sequence<sizeof...(_Arguments)>::type());
+ }
template<typename ... _Arguments, int ... _ArgIndices>
inline SubscriptionStatus handleSignalDBusMessage(const DBusMessage& dbusMessage,
return success ? this->notifyListeners(std::get<_ArgIndices>(argTuple)...) : SubscriptionStatus::RETAIN;
}
- _DBusProxy& dbusProxy_;
- const char* eventName_;
- const char* eventSignature_;
- const char* interfaceName_;
- const char* objectPath_;
- DBusProxyConnection::DBusSignalHandlerToken subscription_;
+ _DBusProxy& dbusProxy_;
+ const char* eventName_;
+ const char* eventSignature_;
+ const char* interfaceName_;
+ const char* objectPath_;
+ DBusProxyConnection::DBusSignalHandlerToken subscription_;
};
} // namespace DBus
namespace DBus {
DBusMessage::DBusMessage():
- libdbusMessage_(NULL) {
+ libdbusMessage_(NULL) {
}
DBusMessage::DBusMessage(::DBusMessage* libdbusMessage) {
- libdbusMessage_ = libdbusMessage != NULL ? dbus_message_ref(libdbusMessage) : NULL;
+ libdbusMessage_ = libdbusMessage != NULL ? dbus_message_ref(libdbusMessage) : NULL;
}
DBusMessage::DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount) {
- assert(libdbusMessage);
+ assert(libdbusMessage);
- libdbusMessage_ = increaseReferenceCount ? dbus_message_ref(libdbusMessage) : libdbusMessage;
+ libdbusMessage_ = increaseReferenceCount ? dbus_message_ref(libdbusMessage) : libdbusMessage;
}
DBusMessage::DBusMessage(const DBusMessage& src) {
- libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
+ libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
}
DBusMessage::DBusMessage(DBusMessage&& rsrc) {
- libdbusMessage_ = rsrc.libdbusMessage_;
- rsrc.libdbusMessage_ = NULL;
+ libdbusMessage_ = rsrc.libdbusMessage_;
+ rsrc.libdbusMessage_ = NULL;
}
DBusMessage::~DBusMessage() {
- if (libdbusMessage_)
- dbus_message_unref(libdbusMessage_);
+ if (libdbusMessage_)
+ dbus_message_unref(libdbusMessage_);
}
DBusMessage& DBusMessage::operator=(const DBusMessage& src) {
- if (this != &src) {
- if (libdbusMessage_)
- dbus_message_unref(libdbusMessage_);
+ if (this != &src) {
+ if (libdbusMessage_)
+ dbus_message_unref(libdbusMessage_);
- libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
- }
+ libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
+ }
- return *this;
+ return *this;
}
DBusMessage& DBusMessage::operator=(DBusMessage&& rsrc) {
- if (this != &rsrc) {
- if (libdbusMessage_)
- dbus_message_unref(libdbusMessage_);
+ if (this != &rsrc) {
+ if (libdbusMessage_)
+ dbus_message_unref(libdbusMessage_);
- libdbusMessage_ = rsrc.libdbusMessage_;
- rsrc.libdbusMessage_ = NULL;
- }
+ libdbusMessage_ = rsrc.libdbusMessage_;
+ rsrc.libdbusMessage_ = NULL;
+ }
- return *this;
+ return *this;
}
DBusMessage::operator bool() const {
- const bool isNotNullDBusMessage = (libdbusMessage_ != NULL);
- return isNotNullDBusMessage;
+ const bool isNotNullDBusMessage = (libdbusMessage_ != NULL);
+ return isNotNullDBusMessage;
}
DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const char* methodName, const char* signature) {
- return DBusMessage::createMethodCall("org.freedesktop.DBus",
- "/",
- "org.freedesktop.DBus",
- methodName,
- signature);
+ return DBusMessage::createMethodCall("org.freedesktop.DBus",
+ "/",
+ "org.freedesktop.DBus",
+ methodName,
+ signature);
}
DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const std::string& methodName,
- const std::string& signature) {
- assert(!methodName.empty());
+ const std::string& signature) {
+ assert(!methodName.empty());
- return createOrgFreedesktopOrgMethodCall(methodName.c_str(),
- signature.empty() ? NULL : signature.c_str());
+ return createOrgFreedesktopOrgMethodCall(methodName.c_str(),
+ signature.empty() ? NULL : signature.c_str());
}
DBusMessage DBusMessage::createMethodCall(const char* busName,
const char* interfaceName,
const char* methodName,
const char* signature) {
- assert(busName);
- assert(objectPath);
- assert(interfaceName);
- assert(methodName);
+ assert(busName);
+ assert(objectPath);
+ assert(interfaceName);
+ assert(methodName);
- ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(busName,
- objectPath,
- interfaceName,
- methodName);
- assert(libdbusMessageCall);
+ ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(busName,
+ objectPath,
+ interfaceName,
+ methodName);
+ assert(libdbusMessageCall);
- if (signature)
- dbus_message_set_signature(libdbusMessageCall, signature);
+ if (signature)
+ dbus_message_set_signature(libdbusMessageCall, signature);
- const bool increaseLibdbusMessageReferenceCount = false;
- return DBusMessage(libdbusMessageCall, increaseLibdbusMessageReferenceCount);
+ const bool increaseLibdbusMessageReferenceCount = false;
+ return DBusMessage(libdbusMessageCall, increaseLibdbusMessageReferenceCount);
}
DBusMessage DBusMessage::createMethodCall(const std::string& busName,
- const std::string& objectPath,
- const std::string& interfaceName,
- const std::string& methodName,
- const std::string& signature) {
- assert(!busName.empty());
- assert(!objectPath.empty());
- assert(!interfaceName.empty());
- assert(!methodName.empty());
-
- return createMethodCall(busName.c_str(),
- objectPath.c_str(),
- interfaceName.c_str(),
- methodName.c_str(),
- signature.empty() ? NULL : signature.c_str());
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& methodName,
+ const std::string& signature) {
+ assert(!busName.empty());
+ assert(!objectPath.empty());
+ assert(!interfaceName.empty());
+ assert(!methodName.empty());
+
+ return createMethodCall(busName.c_str(),
+ objectPath.c_str(),
+ interfaceName.c_str(),
+ methodName.c_str(),
+ signature.empty() ? NULL : signature.c_str());
}
DBusMessage DBusMessage::createMethodReturn(const char* signature) const {
- ::DBusMessage* libdbusMessageReturn = dbus_message_new_method_return(libdbusMessage_);
- assert(libdbusMessageReturn);
+ ::DBusMessage* libdbusMessageReturn = dbus_message_new_method_return(libdbusMessage_);
+ assert(libdbusMessageReturn);
- if (signature)
- dbus_message_set_signature(libdbusMessageReturn, signature);
+ if (signature)
+ dbus_message_set_signature(libdbusMessageReturn, signature);
- const bool increaseLibdbusMessageReferenceCount = false;
- return DBusMessage(libdbusMessageReturn, increaseLibdbusMessageReferenceCount);
+ const bool increaseLibdbusMessageReferenceCount = false;
+ return DBusMessage(libdbusMessageReturn, increaseLibdbusMessageReferenceCount);
}
DBusMessage DBusMessage::createMethodReturn(const std::string& signature) const {
- return createMethodReturn(signature.empty() ? NULL : signature.c_str());
+ return createMethodReturn(signature.empty() ? NULL : signature.c_str());
}
DBusMessage DBusMessage::createMethodError(const std::string& name, const std::string& reason) const {
const char* interfaceName,
const char* signalName,
const char* signature) {
- assert(objectPath);
- assert(interfaceName);
- assert(signalName);
+ assert(objectPath);
+ assert(interfaceName);
+ assert(signalName);
- ::DBusMessage* libdbusMessageSignal = dbus_message_new_signal(objectPath,
- interfaceName,
- signalName);
- assert(libdbusMessageSignal);
+ ::DBusMessage* libdbusMessageSignal = dbus_message_new_signal(objectPath,
+ interfaceName,
+ signalName);
+ assert(libdbusMessageSignal);
- if (signature)
- dbus_message_set_signature(libdbusMessageSignal, signature);
+ if (signature)
+ dbus_message_set_signature(libdbusMessageSignal, signature);
- const bool increaseLibdbusMessageReferenceCount = false;
- return DBusMessage(libdbusMessageSignal, increaseLibdbusMessageReferenceCount);
+ const bool increaseLibdbusMessageReferenceCount = false;
+ return DBusMessage(libdbusMessageSignal, increaseLibdbusMessageReferenceCount);
}
DBusMessage DBusMessage::createSignal(const std::string& objectPath,
- const std::string& interfaceName,
- const std::string& signalName,
- const std::string& signature) {
- assert(!objectPath.empty());
- assert(!interfaceName.empty());
- assert(!signalName.empty());
+ const std::string& interfaceName,
+ const std::string& signalName,
+ const std::string& signature) {
+ assert(!objectPath.empty());
+ assert(!interfaceName.empty());
+ assert(!signalName.empty());
- return createSignal(objectPath.c_str(),
- interfaceName.c_str(),
- signalName.c_str(),
- signature.empty() ? NULL : signature.c_str());
+ return createSignal(objectPath.c_str(),
+ interfaceName.c_str(),
+ signalName.c_str(),
+ signature.empty() ? NULL : signature.c_str());
}
const char* DBusMessage::getObjectPath() const {
- return dbus_message_get_path(libdbusMessage_);
+ return dbus_message_get_path(libdbusMessage_);
}
const char* DBusMessage::getSenderName() const {
- return dbus_message_get_sender(libdbusMessage_);
+ return dbus_message_get_sender(libdbusMessage_);
}
const char* DBusMessage::getInterfaceName() const {
- return dbus_message_get_interface(libdbusMessage_);
+ return dbus_message_get_interface(libdbusMessage_);
}
const char* DBusMessage::getMemberName() const {
- return dbus_message_get_member(libdbusMessage_);
+ return dbus_message_get_member(libdbusMessage_);
}
const char* DBusMessage::getSignatureString() const {
- return dbus_message_get_signature(libdbusMessage_);
+ return dbus_message_get_signature(libdbusMessage_);
}
const char* DBusMessage::getErrorName() const {
- assert(isErrorType());
+ assert(isErrorType());
+
+ return dbus_message_get_error_name(libdbusMessage_);
+}
- return dbus_message_get_error_name(libdbusMessage_);
+const char* DBusMessage::getDestination() const {
+ return dbus_message_get_destination(libdbusMessage_);
}
bool DBusMessage::hasObjectPath(const char* objectPath) const {
}
bool DBusMessage::hasSignature(const char* signature) const {
- const char* dbusMessageSignature = getSignatureString();
+ const char* dbusMessageSignature = getSignatureString();
- assert(signature);
- assert(dbusMessageSignature);
+ assert(signature);
+ assert(dbusMessageSignature);
- return !strcmp(dbusMessageSignature, signature);
+ return !strcmp(dbusMessageSignature, signature);
}
const DBusMessage::Type DBusMessage::getType() const {
- const int libdbusType = dbus_message_get_type(libdbusMessage_);
- return static_cast<Type>(libdbusType);
+ const int libdbusType = dbus_message_get_type(libdbusMessage_);
+ return static_cast<Type>(libdbusType);
}
char* DBusMessage::getBodyData() const {
- return dbus_message_get_body(libdbusMessage_);
+ return dbus_message_get_body(libdbusMessage_);
}
int DBusMessage::getBodyLength() const {
- return dbus_message_get_body_length(libdbusMessage_);
+ return dbus_message_get_body_length(libdbusMessage_);
}
int DBusMessage::getBodySize() const {
- return dbus_message_get_body_allocated(libdbusMessage_);
+ return dbus_message_get_body_allocated(libdbusMessage_);
}
bool DBusMessage::setBodyLength(const int bodyLength) {
- return dbus_message_set_body_length(libdbusMessage_, bodyLength);
+ return dbus_message_set_body_length(libdbusMessage_, bodyLength);
+}
+
+bool DBusMessage::setDestination(const char* destination)
+{
+ return dbus_message_set_destination(libdbusMessage_, destination);
}
} // namespace DBus
class DBusMessage {
public:
- DBusMessage();
- DBusMessage(::DBusMessage* libdbusMessage);
- DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount);
- DBusMessage(const DBusMessage& src);
- DBusMessage(DBusMessage&& src);
+ DBusMessage();
+ DBusMessage(::DBusMessage* libdbusMessage);
+ DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount);
+ DBusMessage(const DBusMessage& src);
+ DBusMessage(DBusMessage&& src);
- ~DBusMessage();
+ ~DBusMessage();
- DBusMessage& operator=(const DBusMessage& src);
- DBusMessage& operator=(DBusMessage&& rsrc);
- operator bool() const;
+ DBusMessage& operator=(const DBusMessage& src);
+ DBusMessage& operator=(DBusMessage&& rsrc);
+ operator bool() const;
- static DBusMessage createOrgFreedesktopOrgMethodCall(const char* methodName,
- const char* signature = NULL);
+ static DBusMessage createOrgFreedesktopOrgMethodCall(const char* methodName,
+ const char* signature = NULL);
- static DBusMessage createOrgFreedesktopOrgMethodCall(const std::string& methodName,
- const std::string& signature = "");
+ static DBusMessage createOrgFreedesktopOrgMethodCall(const std::string& methodName,
+ const std::string& signature = "");
- static DBusMessage createMethodCall(const char* busName,
+ static DBusMessage createMethodCall(const char* busName,
const char* objectPath,
const char* interfaceName,
const char* methodName,
const char* signature = NULL);
- static DBusMessage createMethodCall(const std::string& busName,
- const std::string& objectPath,
- const std::string& interfaceName,
- const std::string& methodName,
- const std::string& signature = "");
+ static DBusMessage createMethodCall(const std::string& busName,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& methodName,
+ const std::string& signature = "");
- DBusMessage createMethodReturn(const char* signature = NULL) const;
+ DBusMessage createMethodReturn(const char* signature = NULL) const;
- DBusMessage createMethodReturn(const std::string& signature) const;
+ DBusMessage createMethodReturn(const std::string& signature) const;
DBusMessage createMethodError(const std::string& name, const std::string& reason = "") const;
- static DBusMessage createSignal(const char* objectPath,
- const char* interfaceName,
- const char* signalName,
- const char* signature = NULL);
+ static DBusMessage createSignal(const char* objectPath,
+ const char* interfaceName,
+ const char* signalName,
+ const char* signature = NULL);
- static DBusMessage createSignal(const std::string& objectPath,
- const std::string& interfaceName,
- const std::string& signalName,
- const std::string& signature = "");
+ static DBusMessage createSignal(const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& signalName,
+ const std::string& signature = "");
- const char* getSenderName() const;
- const char* getObjectPath() const;
- const char* getInterfaceName() const;
- const char* getMemberName() const;
- const char* getSignatureString() const;
- const char* getErrorName() const;
+ const char* getSenderName() const;
+ const char* getObjectPath() const;
+ const char* getInterfaceName() const;
+ const char* getMemberName() const;
+ const char* getSignatureString() const;
+ const char* getErrorName() const;
+ const char* getDestination() const;
- inline bool hasObjectPath(const std::string& objectPath) const;
+ inline bool hasObjectPath(const std::string& objectPath) const;
- bool hasObjectPath(const char* objectPath) const;
+ bool hasObjectPath(const char* objectPath) const;
bool hasInterfaceName(const char* interfaceName) const;
- bool hasMemberName(const char* memberName) const;
- bool hasSignature(const char* signature) const;
-
- enum class Type: int {
- Invalid = DBUS_MESSAGE_TYPE_INVALID,
- MethodCall = DBUS_MESSAGE_TYPE_METHOD_CALL,
- MethodReturn = DBUS_MESSAGE_TYPE_METHOD_RETURN,
- Error = DBUS_MESSAGE_TYPE_ERROR,
- Signal = DBUS_MESSAGE_TYPE_SIGNAL
- };
- const Type getType() const;
- inline bool isInvalidType() const;
- inline bool isMethodCallType() const;
- inline bool isMethodReturnType() const;
- inline bool isErrorType() const;
- inline bool isSignalType() const;
-
- char* getBodyData() const;
- int getBodyLength() const;
- int getBodySize() const;
-
- bool setBodyLength(const int bodyLength);
+ bool hasMemberName(const char* memberName) const;
+ bool hasSignature(const char* signature) const;
+
+ enum class Type: int {
+ Invalid = DBUS_MESSAGE_TYPE_INVALID,
+ MethodCall = DBUS_MESSAGE_TYPE_METHOD_CALL,
+ MethodReturn = DBUS_MESSAGE_TYPE_METHOD_RETURN,
+ Error = DBUS_MESSAGE_TYPE_ERROR,
+ Signal = DBUS_MESSAGE_TYPE_SIGNAL
+ };
+ const Type getType() const;
+ inline bool isInvalidType() const;
+ inline bool isMethodCallType() const;
+ inline bool isMethodReturnType() const;
+ inline bool isErrorType() const;
+ inline bool isSignalType() const;
+
+ char* getBodyData() const;
+ int getBodyLength() const;
+ int getBodySize() const;
+
+ bool setBodyLength(const int bodyLength);
+ bool setDestination(const char* destination);
private:
- ::DBusMessage* libdbusMessage_;
+ ::DBusMessage* libdbusMessage_;
- friend class DBusConnection;
+ friend class DBusConnection;
};
bool DBusMessage::hasObjectPath(const std::string& objectPath) const {
}
bool DBusMessage::isInvalidType() const {
- return (getType() == Type::Invalid);
+ return (getType() == Type::Invalid);
}
bool DBusMessage::isMethodCallType() const {
- return (getType() == Type::MethodCall);
+ return (getType() == Type::MethodCall);
}
bool DBusMessage::isMethodReturnType() const {
- return (getType() == Type::MethodReturn);
+ return (getType() == Type::MethodReturn);
}
bool DBusMessage::isErrorType() const {
- return (getType() == Type::Error);
+ return (getType() == Type::Error);
}
bool DBusMessage::isSignalType() const {
- return (getType() == Type::Signal);
+ return (getType() == Type::Signal);
}
} // namespace DBus
return commonApiDomain_ + ":" + commonApiServiceId_ + ":" + commonApiParticipantId_;
}
+DBusProxyConnection::DBusSignalHandlerToken DBusProxy::subscribeForSelectiveBroadcastOnConnection(
+ bool& subscriptionAccepted,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+
+ return getDBusConnection()->subscribeForSelectiveBroadcast(
+ subscriptionAccepted,
+ objectPath,
+ interfaceName,
+ interfaceMemberName,
+ interfaceMemberSignature,
+ dbusSignalHandler,
+ this);
+}
+
+void DBusProxy::unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+ DBusProxyConnection::DBusSignalHandlerToken subscription) {
+ getDBusConnection()->unsubsribeFromSelectiveBroadcast(eventName, subscription, this);
+}
+
} // namespace DBus
} // namespace CommonAPI
virtual const std::string& getDBusBusName() const;
virtual const std::string& getDBusObjectPath() const;
virtual const std::string& getInterfaceName() const;
-
+ DBusProxyConnection::DBusSignalHandlerToken subscribeForSelectiveBroadcastOnConnection(
+ bool& subscriptionAccepted,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
+ void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+ DBusProxyConnection::DBusSignalHandlerToken subscription);
private:
DBusProxy(const DBusProxy&) = delete;
const char* methodSignature = NULL) const;
inline DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
- const std::string& signalName,
- const std::string& signalSignature,
- DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
+ const std::string& signalName,
+ const std::string& signalSignature,
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter = false);
inline DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
const std::string& objectPath,
const std::string& interfaceName,
const std::string& signalName,
const std::string& signalSignature,
- DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
-
- inline void removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken);
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter = false);
+ inline bool removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken);
protected:
const std::string commonApiDomain_;
DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
const std::string& signalName,
const std::string& signalSignature,
- DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter) {
return addSignalMemberHandler(
getDBusObjectPath(),
getInterfaceName(),
signalName,
signalSignature,
- dbusSignalHandler);
+ dbusSignalHandler,
+ justAddFilter);
}
DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
const std::string& interfaceName,
const std::string& signalName,
const std::string& signalSignature,
- DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+ DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter) {
return dbusConnection_->addSignalMemberHandler(
objectPath,
interfaceName,
signalName,
signalSignature,
- dbusSignalHandler);
+ dbusSignalHandler,
+ justAddFilter);
}
-void DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken) {
+bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken) {
return dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerToken);
}
+
} // namespace DBus
} // namespace CommonAPI
class DBusDaemonProxy;
class DBusServiceRegistry;
class DBusObjectManager;
+class DBusProxy;
class DBusProxyConnection {
const std::string& interfaceName,
const std::string& interfaceMemberName,
const std::string& interfaceMemberSignature,
- DBusSignalHandler* dbusSignalHandler) = 0;
-
- virtual void removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) = 0;
+ DBusSignalHandler* dbusSignalHandler,
+ const bool justAddFilter = false) = 0;
+
+ virtual DBusSignalHandlerToken subscribeForSelectiveBroadcast(bool& subscriptionAccepted,
+ const std::string& objectPath,
+ const std::string& interfaceName,
+ const std::string& interfaceMemberName,
+ const std::string& interfaceMemberSignature,
+ DBusSignalHandler* dbusSignalHandler,
+ DBusProxy* callingProxy) = 0;
+
+ virtual void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+ DBusProxyConnection::DBusSignalHandlerToken subscription,
+ DBusProxy* callingProxy) = 0;
+ virtual bool removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) = 0;
virtual const std::shared_ptr<DBusServiceRegistry> getDBusServiceRegistry() = 0;
virtual const std::shared_ptr<DBusObjectManager> getDBusObjectManager() = 0;
--- /dev/null
+/* Copyright (C) 2013 BMW Group
+ * Author: Manfred Bathelt (manfred.bathelt@bmw.de)
+ * Author: Juergen Gehring (juergen.gehring@bmw.de)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#error "Only <CommonAPI/CommonAPI.h> can be included directly, this file may disappear or change contents."
+#endif
+
+#ifndef COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
+#define COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
+
+#include "DBusEvent.h"
+
+namespace CommonAPI {
+namespace DBus {
+
+template<typename _EventType, typename _DBusProxy = DBusProxyBase>
+class DBusSelectiveEvent: public DBusEvent<_EventType, _DBusProxy> {
+public:
+ typedef typename DBusEvent<_EventType, _DBusProxy>::CancellableListener CancellableListener;
+ typedef DBusEvent<_EventType, _DBusProxy> DBusEventBase;
+
+ DBusSelectiveEvent(DBusProxy& associatedDbusProxy,
+ const char* eventName,
+ const char* eventSignature) :
+ DBusEventBase(associatedDbusProxy, eventName, eventSignature),
+ associatedDbusProxy_(associatedDbusProxy) {
+ }
+
+ DBusSelectiveEvent(DBusProxy& associatedDbusProxy, const char* eventName,
+ const char* eventSignature,
+ const char* objPath,
+ const char* interfaceName) :
+
+ DBusEvent<_EventType, _DBusProxy>(
+ associatedDbusProxy,
+ eventName,
+ eventSignature,
+ objPath,
+ interfaceName),
+ associatedDbusProxy_(associatedDbusProxy) {
+ }
+
+ virtual ~DBusSelectiveEvent() { }
+
+ typename _EventType::Subscription subscribe(typename _EventType::Listener listener, bool& success) {
+
+ DBusEventBase::listenerListMutex_.lock();
+ const bool firstListenerAdded = DBusEventBase::listenersList_.empty();
+
+ typename _EventType::CancellableListenerWrapper wrappedListener(std::move(listener));
+ DBusEventBase::listenersList_.emplace_front(std::move(wrappedListener));
+ typename _EventType::Subscription listenerSubscription = DBusEventBase::listenersList_.begin();
+
+ success = true;
+ DBusProxyConnection::DBusSignalHandlerToken dbusSignalHandlerToken;
+
+ if (firstListenerAdded) {
+ dbusSignalHandlerToken = associatedDbusProxy_.subscribeForSelectiveBroadcastOnConnection(
+ success,
+ DBusEventBase::objectPath_,
+ DBusEventBase::interfaceName_,
+ DBusEventBase::eventName_,
+ DBusEventBase::eventSignature_,
+ this
+ );
+ }
+
+ if (success) {
+ // actually add subscription
+ DBusEventBase::subscription_ = dbusSignalHandlerToken;
+ this->onListenerAdded(*listenerSubscription);
+ }
+ else {
+ DBusEventBase::listenersList_.erase(listenerSubscription);
+ listenerSubscription = DBusEventBase::listenersList_.end();
+ }
+ DBusEventBase::listenerListMutex_.unlock();
+
+ return listenerSubscription;
+ }
+
+protected:
+ virtual void onLastListenerRemoved(const CancellableListener&) {
+ associatedDbusProxy_.unsubsribeFromSelectiveBroadcast(DBusEventBase::eventName_, DBusEventBase::subscription_);
+ }
+
+private:
+ DBusProxy& associatedDbusProxy_;
+};
+
+} // namespace DBus
+} // namespace CommonAPI
+
+#endif // COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
virtual const char* getMethodsDBusIntrospectionXmlData() const = 0;
virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage) = 0;
-
- private:
+private:
const std::string commonApiDomain_;
const std::string commonApiServiceId_;
const std::string commonApiParticipantId_;
virtual ~DBusStubAdapterHelper() {
DBusStubAdapter::deinit();
- stub_.reset();
+ stub_.reset();
}
virtual void init() {
virtual void deinit() {
DBusStubAdapter::deinit();
- stub_.reset();
+ stub_.reset();
}
inline std::shared_ptr<StubAdapterType> getStubAdapter() {
class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
public:
typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
- typedef void (_StubClass::*_StubFunctor)(CommonAPI::ClientId&, _InArgs...);
+ typedef void (_StubClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs...);
DBusMethodStubDispatcher(_StubFunctor stubFunctor):
stubFunctor_(stubFunctor) {
private:
template <int... _InArgIndices, int... _OutArgIndices>
inline bool handleDBusMessage(const DBusMessage& dbusMessage,
- const std::shared_ptr<_StubClass>& stub,
+ const std::shared_ptr<_StubClass>& stub,
DBusStubAdapterHelperType& dbusStubAdapterHelper,
index_sequence<_InArgIndices...>) const {
std::tuple<_InArgs...> argTuple;
return false;
}
- const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
(stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))...);
public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
public:
typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
- typedef void (_StubClass::*_StubFunctor)(const CommonAPI::ClientId&, _InArgs..., _OutArgs&...);
+ typedef void (_StubClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs..., _OutArgs&...);
DBusMethodWithReplyStubDispatcher(_StubFunctor stubFunctor, const char* dbusReplySignature):
stubFunctor_(stubFunctor),
private:
template <int... _InArgIndices, int... _OutArgIndices>
inline bool handleDBusMessage(const DBusMessage& dbusMessage,
- const std::shared_ptr<_StubClass>& stub,
+ const std::shared_ptr<_StubClass>& stub,
DBusStubAdapterHelperType& dbusStubAdapterHelper,
index_sequence<_InArgIndices...>,
index_sequence<_OutArgIndices...>) const {
return false;
}
- const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
(stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))..., std::get<_OutArgIndices>(argTuple)...);
const char* dbusReplySignature_;
};
+template< class, class, class, class >
+class DBusMethodWithReplyAdapterDispatcher;
+
+template <
+ typename _StubClass,
+ typename _StubAdapterClass,
+ template <class...> class _In, class... _InArgs,
+ template <class...> class _Out, class... _OutArgs>
+class DBusMethodWithReplyAdapterDispatcher<_StubClass, _StubAdapterClass, _In<_InArgs...>, _Out<_OutArgs...> >:
+ public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
+ public:
+ typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
+ typedef void (_StubAdapterClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs..., _OutArgs&...);
+
+ DBusMethodWithReplyAdapterDispatcher(_StubFunctor stubFunctor, const char* dbusReplySignature):
+ stubFunctor_(stubFunctor),
+ dbusReplySignature_(dbusReplySignature) {
+ }
+
+ bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
+ return handleDBusMessage(
+ dbusMessage,
+ stub,
+ dbusStubAdapterHelper,
+ typename make_sequence_range<sizeof...(_InArgs), 0>::type(),
+ typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type());
+ }
+
+ private:
+ template <int... _InArgIndices, int... _OutArgIndices>
+ inline bool handleDBusMessage(const DBusMessage& dbusMessage,
+ const std::shared_ptr<_StubClass>& stub,
+ DBusStubAdapterHelperType& dbusStubAdapterHelper,
+ index_sequence<_InArgIndices...>,
+ index_sequence<_OutArgIndices...>) const {
+ std::tuple<_InArgs..., _OutArgs...> argTuple;
+
+ if (sizeof...(_InArgs) > 0) {
+ DBusInputStream dbusInputStream(dbusMessage);
+ const bool success = DBusSerializableArguments<_InArgs...>::deserialize(dbusInputStream, std::get<_InArgIndices>(argTuple)...);
+ if (!success)
+ return false;
+ }
+
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
+
+ (dbusStubAdapterHelper.getStubAdapter().get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))..., std::get<_OutArgIndices>(argTuple)...);
+ DBusMessage dbusMessageReply = dbusMessage.createMethodReturn(dbusReplySignature_);
+
+ if (sizeof...(_OutArgs) > 0) {
+ DBusOutputStream dbusOutputStream(dbusMessageReply);
+ const bool success = DBusSerializableArguments<_OutArgs...>::serialize(dbusOutputStream, std::get<_OutArgIndices>(argTuple)...);
+ if (!success)
+ return false;
+
+ dbusOutputStream.flush();
+ }
+
+ return dbusStubAdapterHelper.getDBusConnection()->sendDBusMessage(dbusMessageReply);
+ }
+
+ _StubFunctor stubFunctor_;
+ const char* dbusReplySignature_;
+};
+
template <typename _StubClass, typename _AttributeType>
class DBusGetAttributeStubDispatcher: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
public:
typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
- typedef const _AttributeType& (_StubClass::*GetStubFunctor)(const CommonAPI::ClientId&);
+ typedef const _AttributeType& (_StubClass::*GetStubFunctor)(std::shared_ptr<CommonAPI::ClientId>);
DBusGetAttributeStubDispatcher(GetStubFunctor getStubFunctor, const char* dbusSignature):
getStubFunctor_(getStubFunctor),
DBusMessage dbusMessageReply = dbusMessage.createMethodReturn(dbusSignature_);
DBusOutputStream dbusOutputStream(dbusMessageReply);
- const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
dbusOutputStream << (stub.get()->*getStubFunctor_)(clientId);
dbusOutputStream.flush();
typedef typename DBusStubAdapterHelperType::RemoteEventHandlerType RemoteEventHandlerType;
typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::GetStubFunctor GetStubFunctor;
- typedef bool (RemoteEventHandlerType::*OnRemoteSetFunctor)(const CommonAPI::ClientId&, _AttributeType);
+ typedef bool (RemoteEventHandlerType::*OnRemoteSetFunctor)(std::shared_ptr<CommonAPI::ClientId>, _AttributeType);
typedef void (RemoteEventHandlerType::*OnRemoteChangedFunctor)();
DBusSetAttributeStubDispatcher(GetStubFunctor getStubFunctor,
protected:
inline bool setAttributeValue(const DBusMessage& dbusMessage,
- const std::shared_ptr<_StubClass>& stub,
- DBusStubAdapterHelperType& dbusStubAdapterHelper,
- bool& attributeValueChanged) {
+ const std::shared_ptr<_StubClass>& stub,
+ DBusStubAdapterHelperType& dbusStubAdapterHelper,
+ bool& attributeValueChanged) {
DBusInputStream dbusInputStream(dbusMessage);
_AttributeType attributeValue;
dbusInputStream >> attributeValue;
if (dbusInputStream.hasError())
return false;
- const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
attributeValueChanged = (dbusStubAdapterHelper.getRemoteEventHandler()->*onRemoteSetFunctor_)(clientId, std::move(attributeValue));
(dbusStubAdapterHelper.getRemoteEventHandler()->*onRemoteChangedFunctor_)();
}
- inline const _AttributeType& getAttributeValue(const CommonAPI::ClientId& clientId, const std::shared_ptr<_StubClass>& stub) {
+ inline const _AttributeType& getAttributeValue(std::shared_ptr<CommonAPI::ClientId> clientId, const std::shared_ptr<_StubClass>& stub) {
return (stub.get()->*(this->getStubFunctor_))(clientId);
}
return false;
if (attributeValueChanged) {
- const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+ std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
fireAttributeValueChanged(clientId, dbusStubAdapterHelper, stub);
this->notifyOnRemoteChanged(dbusStubAdapterHelper);
}
}
private:
- inline void fireAttributeValueChanged(const CommonAPI::ClientId& clientId, DBusStubAdapterHelperType& dbusStubAdapterHelper, const std::shared_ptr<_StubClass> stub) {
+ inline void fireAttributeValueChanged(std::shared_ptr<CommonAPI::ClientId> clientId, DBusStubAdapterHelperType& dbusStubAdapterHelper, const std::shared_ptr<_StubClass> stub) {
(dbusStubAdapterHelper.getStubAdapter().get()->*fireChangedFunctor_)(this->getAttributeValue(clientId, stub));
}
return false; // doesn't matter, as we are just comparing this class with DBusClientId;
}
+ std::size_t hashCode() {
+ return 0;
+ }
+
};
TEST_F(DBusClientIdTest, TestClientIdImplementation) {
--- /dev/null
+/* Copyright (C) 2013 BMW Group
+ * Author: Manfred Bathelt (manfred.bathelt@bmw.de)
+ * Author: Juergen Gehring (juergen.gehring@bmw.de)
+ * 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 <gtest/gtest.h>
+
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+#include <functional>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <utility>
+#include <tuple>
+#include <type_traits>
+
+#include <CommonAPI/CommonAPI.h>
+
+#define COMMONAPI_INTERNAL_COMPILATION
+
+#include <CommonAPI/DBus/DBusConnection.h>
+#include <CommonAPI/DBus/DBusProxy.h>
+#include <CommonAPI/DBus/DBusRuntime.h>
+
+#include "commonapi/tests/PredefinedTypeCollection.h"
+#include "commonapi/tests/DerivedTypeCollection.h"
+#include "commonapi/tests/TestInterfaceProxy.h"
+#include "commonapi/tests/TestInterfaceStubDefault.h"
+#include "commonapi/tests/TestInterfaceDBusStubAdapter.h"
+
+#include "commonapi/tests/TestInterfaceDBusProxy.h"
+
+class SelectiveBroadcastSender: public commonapi::tests::TestInterfaceStubDefault {
+public:
+
+ SelectiveBroadcastSender():
+ acceptSubs(true),
+ sentBroadcasts(0) {
+
+ }
+
+ void startSending() {
+ sentBroadcasts = 0;
+ selectiveBroadcastSender = std::thread(&SelectiveBroadcastSender::send, this);
+ selectiveBroadcastSender.detach();
+ }
+
+ void send() {
+ sentBroadcasts++;
+ fireTestSelectiveBroadcastSelective();
+ }
+
+ void onTestSelectiveBroadcastSelectiveSubscriptionChanged(
+ const std::shared_ptr<CommonAPI::ClientId> clientId,
+ const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
+
+ if(event == CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED)
+ lastSubscribedClient = clientId;
+ }
+
+ bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(
+ const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ return acceptSubs;
+ }
+
+ void sendToLastSubscribedClient()
+ {
+ sentBroadcasts++;
+ CommonAPI::ClientIdList receivers = { lastSubscribedClient };
+
+ fireTestSelectiveBroadcastSelective(&receivers);
+ }
+
+
+ int getNumberOfSubscribedClients() {
+ return getSubscribersForTestSelectiveBroadcastSelective()->size();
+
+ }
+
+ bool acceptSubs;
+
+private:
+ std::thread selectiveBroadcastSender;
+ int sentBroadcasts;
+
+ std::shared_ptr<CommonAPI::ClientId> lastSubscribedClient;
+};
+
+
+
+class DBusSelectiveBroadcastTest: public ::testing::Test {
+protected:
+ virtual void SetUp() {
+ runtime_ = CommonAPI::Runtime::load();
+ ASSERT_TRUE((bool)runtime_);
+ CommonAPI::DBus::DBusRuntime* dbusRuntime = dynamic_cast<CommonAPI::DBus::DBusRuntime*>(&(*runtime_));
+ ASSERT_TRUE(dbusRuntime != NULL);
+
+ proxyFactory_ = runtime_->createFactory();
+ ASSERT_TRUE((bool)proxyFactory_);
+
+ proxyFactory2_ = runtime_->createFactory();
+ ASSERT_TRUE((bool)proxyFactory2_);
+
+ stubFactory_ = runtime_->createFactory();
+ ASSERT_TRUE((bool)stubFactory_);
+
+ servicePublisher_ = runtime_->getServicePublisher();
+ ASSERT_TRUE((bool)servicePublisher_);
+
+ selectiveBroadcastArrivedAtProxyFromSameFactory1 = 0;
+ selectiveBroadcastArrivedAtProxyFromSameFactory2 = 0;
+ selectiveBroadcastArrivedAtProxyFromOtherFactory = 0;
+ }
+
+ virtual void TearDown() {
+ }
+
+
+
+
+ std::shared_ptr<CommonAPI::Runtime> runtime_;
+ std::shared_ptr<CommonAPI::Factory> proxyFactory_;
+ std::shared_ptr<CommonAPI::Factory> proxyFactory2_;
+ std::shared_ptr<CommonAPI::Factory> stubFactory_;
+ std::shared_ptr<CommonAPI::ServicePublisher> servicePublisher_;
+
+ static const std::string serviceAddress_;
+ static const std::string serviceAddress2_;
+ static const std::string serviceAddress3_;
+ static const std::string serviceAddress4_;
+ static const std::string nonstandardAddress_;
+
+ int selectiveBroadcastArrivedAtProxyFromSameFactory1;
+ int selectiveBroadcastArrivedAtProxyFromSameFactory2;
+ int selectiveBroadcastArrivedAtProxyFromOtherFactory;
+public:
+ CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromSameFactory1() {
+ selectiveBroadcastArrivedAtProxyFromSameFactory1++;
+ return CommonAPI::SubscriptionStatus::RETAIN;
+ }
+
+ CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromSameFactory2() {
+ selectiveBroadcastArrivedAtProxyFromSameFactory2++;
+ return CommonAPI::SubscriptionStatus::RETAIN;
+ }
+
+ CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromOtherFactory() {
+ selectiveBroadcastArrivedAtProxyFromOtherFactory++;
+ return CommonAPI::SubscriptionStatus::RETAIN;
+ }
+};
+
+const std::string DBusSelectiveBroadcastTest::serviceAddress_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService";
+const std::string DBusSelectiveBroadcastTest::serviceAddress2_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService2";
+const std::string DBusSelectiveBroadcastTest::serviceAddress3_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService3";
+const std::string DBusSelectiveBroadcastTest::serviceAddress4_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService4";
+const std::string DBusSelectiveBroadcastTest::nonstandardAddress_ = "local:non.standard.ServiceName:non.standard.participand.ID";
+
+
+TEST_F(DBusSelectiveBroadcastTest, ProxysCanSubscribe)
+{
+ auto proxyFromSameFactory1 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+ ASSERT_TRUE((bool)proxyFromSameFactory1);
+ auto proxyFromSameFactory2 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+ ASSERT_TRUE((bool)proxyFromSameFactory2);
+ auto proxyFromOtherFactory = proxyFactory2_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+ ASSERT_TRUE((bool)proxyFromOtherFactory);
+
+ auto stub = std::make_shared<SelectiveBroadcastSender>();
+
+
+ bool serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+ for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
+ serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+ usleep(10000);
+ }
+ ASSERT_TRUE(serviceRegistered);
+
+ for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+ usleep(10000);
+ }
+ ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+
+ auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this));
+
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+
+ stub->send();
+
+ usleep(20000);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 0);
+
+
+ auto subscriptionResult2 = proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory2, this));
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1); // should still be one because these were created by the same factory thus using the same connection
+
+ stub->send();
+ usleep(20000);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 2);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+
+ auto subscriptionResult3 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+
+ proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult2);
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+
+ stub->send();
+ usleep(20000);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 1);
+
+ // now only the last subscribed client (which is the one from the other factory) should receive the signal
+ stub->sendToLastSubscribedClient();
+ usleep(20000);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 2);
+
+ proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult1);
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+
+ servicePublisher_->unregisterService(serviceAddress4_);
+}
+
+TEST_F(DBusSelectiveBroadcastTest, ProxysCanBeRejected) {
+ auto proxyFromSameFactory1 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+ ASSERT_TRUE((bool)proxyFromSameFactory1);
+ auto proxyFromOtherFactory = proxyFactory2_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+ ASSERT_TRUE((bool)proxyFromOtherFactory);
+
+
+ auto stub = std::make_shared<SelectiveBroadcastSender>();
+
+ bool serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+ for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
+ serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+ usleep(10000);
+ }
+ ASSERT_TRUE(serviceRegistered);
+
+ for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+ usleep(10000);
+ }
+ ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+
+ bool subbed = false;
+
+ auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+ std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this),
+ subbed);
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+ ASSERT_TRUE(subbed);
+
+ stub->acceptSubs = false;
+
+ auto subscriptionResult2 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+ std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this),
+ subbed);
+ ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+ ASSERT_FALSE(subbed);
+
+ stub->send();
+
+ usleep(20000);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
+ ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 0);
+}
+
+int main(int argc, char** argv) {
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
} // namespace commonapi
namespace CommonAPI {
-
- template<>
- struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnum> {
- inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
- typeStream.writeInt32EnumType();
- }
- };
-
- template<>
- struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
- static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
- inputStream.beginReadInt32EnumVector();
- }
- };
-
- template <>
- struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
- static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
- outputStream.beginWriteInt32EnumVector(vectorValue.size());
- }
- };
- template<>
- struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
- inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
- typeStream.writeInt32EnumType();
- }
- };
-
- template<>
- struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
- static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
- inputStream.beginReadInt32EnumVector();
- }
- };
-
- template <>
- struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
- static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
- outputStream.beginWriteInt32EnumVector(vectorValue.size());
- }
- };
- template<>
- struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
- inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
- typeStream.writeInt32EnumType();
- }
- };
-
- template<>
- struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
- static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
- inputStream.beginReadInt32EnumVector();
- }
- };
-
- template <>
- struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
- static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
- outputStream.beginWriteInt32EnumVector(vectorValue.size());
- }
- };
- template<>
- struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
- inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
- typeStream.writeInt32EnumType();
- }
- };
-
- template<>
- struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
- static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
- inputStream.beginReadInt32EnumVector();
- }
- };
-
- template <>
- struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
- static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
- outputStream.beginWriteInt32EnumVector(vectorValue.size());
- }
- };
-
+
+ template<>
+ struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnum> {
+ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+ typeStream.writeInt32EnumType();
+ }
+ };
+
+ template<>
+ struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
+ static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
+ inputStream.beginReadInt32EnumVector();
+ }
+ };
+
+ template <>
+ struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
+ static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
+ outputStream.beginWriteInt32EnumVector(vectorValue.size());
+ }
+ };
+ template<>
+ struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+ typeStream.writeInt32EnumType();
+ }
+ };
+
+ template<>
+ struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+ static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
+ inputStream.beginReadInt32EnumVector();
+ }
+ };
+
+ template <>
+ struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+ static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
+ outputStream.beginWriteInt32EnumVector(vectorValue.size());
+ }
+ };
+ template<>
+ struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+ typeStream.writeInt32EnumType();
+ }
+ };
+
+ template<>
+ struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+ static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
+ inputStream.beginReadInt32EnumVector();
+ }
+ };
+
+ template <>
+ struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+ static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
+ outputStream.beginWriteInt32EnumVector(vectorValue.size());
+ }
+ };
+ template<>
+ struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+ typeStream.writeInt32EnumType();
+ }
+ };
+
+ template<>
+ struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+ static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
+ inputStream.beginReadInt32EnumVector();
+ }
+ };
+
+ template <>
+ struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+ static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
+ outputStream.beginWriteInt32EnumVector(vectorValue.size());
+ }
+ };
+
}
} // namespace commonapi
namespace CommonAPI {
-
-
+
+
}
, testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute"),
testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute"),
testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute")
-, testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us")
+, testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us"),
+ testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", ""),
+ testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us")
{
}
TestInterfaceDBusProxy::TestPredefinedTypeBroadcastEvent& TestInterfaceDBusProxy::getTestPredefinedTypeBroadcastEvent() {
return testPredefinedTypeBroadcast_;
}
+TestInterfaceDBusProxy::TestSelectiveBroadcastSelectiveEvent& TestInterfaceDBusProxy::getTestSelectiveBroadcastSelectiveEvent() {
+ return testSelectiveBroadcastSelective_;
+}
+TestInterfaceDBusProxy::TestBroadcastWithOutArgsSelectiveEvent& TestInterfaceDBusProxy::getTestBroadcastWithOutArgsSelectiveEvent() {
+ return testBroadcastWithOutArgsSelective_;
+}
void TestInterfaceDBusProxy::testEmptyMethod(CommonAPI::CallStatus& callStatus) {
CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
std::move(callback));
}
+
void TestInterfaceDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
ownVersionMajor = 1;
ownVersionMinor = 0;
#include <CommonAPI/DBus/DBusProxy.h>
#include <CommonAPI/DBus/DBusAttribute.h>
#include <CommonAPI/DBus/DBusEvent.h>
+#include <CommonAPI/types.h>
+#include <CommonAPI/DBus/DBusSelectiveEvent.h>
#undef COMMONAPI_INTERNAL_COMPILATION
virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute();
virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent();
-
+ virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent();
+ virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent();
virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus);
virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback);
-
virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus);
virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback);
-
virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue);
virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback);
-
virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus);
virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback);
-
virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback);
-
+
virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
private:
CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute>> testDerivedArrayAttribute_;
CommonAPI::DBus::DBusEvent<TestPredefinedTypeBroadcastEvent> testPredefinedTypeBroadcast_;
+ CommonAPI::DBus::DBusSelectiveEvent<TestSelectiveBroadcastSelectiveEvent> testSelectiveBroadcastSelective_;
+ CommonAPI::DBus::DBusSelectiveEvent<TestBroadcastWithOutArgsSelectiveEvent> testBroadcastWithOutArgsSelective_;
};
} // namespace tests
const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() const {
static const char* introspectionData =
"<method name=\"getTestPredefinedTypeAttributeAttribute\">\n"
-
"<arg name=\"value\" type=\"u\" direction=\"out\" />"
+ "<arg name=\"value\" type=\"u\" direction=\"out\" />"
"</method>\n"
"<method name=\"setTestPredefinedTypeAttributeAttribute\">\n"
"<arg name=\"requestedValue\" type=\"u\" direction=\"in\" />\n"
"<arg name=\"changedValue\" type=\"u\" />\n"
"</signal>\n"
"<method name=\"getTestDerivedStructAttributeAttribute\">\n"
-
"<arg name=\"value\" type=\"(sqi)\" direction=\"out\" />"
+ "<arg name=\"value\" type=\"(sqi)\" direction=\"out\" />"
"</method>\n"
"<method name=\"setTestDerivedStructAttributeAttribute\">\n"
"<arg name=\"requestedValue\" type=\"(sqi)\" direction=\"in\" />\n"
"<arg name=\"changedValue\" type=\"(sqi)\" />\n"
"</signal>\n"
"<method name=\"getTestDerivedArrayAttributeAttribute\">\n"
-
"<arg name=\"value\" type=\"at\" direction=\"out\" />"
+ "<arg name=\"value\" type=\"at\" direction=\"out\" />"
"</method>\n"
"<method name=\"setTestDerivedArrayAttributeAttribute\">\n"
"<arg name=\"requestedValue\" type=\"at\" direction=\"in\" />\n"
"<arg name=\"uint32Value\" type=\"u\" />\n"
"<arg name=\"stringValue\" type=\"s\" />\n"
"</signal>\n"
+ "<signal name=\"TestSelectiveBroadcast\">\n"
+ "</signal>\n"
+ "<signal name=\"TestBroadcastWithOutArgs\">\n"
+ "<arg name=\"uint32Value\" type=\"u\" />\n"
+ "<arg name=\"stringValue\" type=\"s\" />\n"
+ "</signal>\n"
"<method name=\"testEmptyMethod\">\n"
"</method>\n"
"<method name=\"testVoidPredefinedTypeMethod\">\n"
> testDerivedTypeMethodStubDispatcher(&TestInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}");
void TestInterfaceDBusStubAdapter::fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value) {
- CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
::sendSignal(
*this,
"onTestPredefinedTypeAttributeAttributeChanged",
);
}
void TestInterfaceDBusStubAdapter::fireTestDerivedStructAttributeAttributeChanged(const DerivedTypeCollection::TestStructExtended& value) {
- CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestStructExtended>>
+ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestStructExtended>>
::sendSignal(
*this,
"onTestDerivedStructAttributeAttributeChanged",
);
}
void TestInterfaceDBusStubAdapter::fireTestDerivedArrayAttributeAttributeChanged(const DerivedTypeCollection::TestArrayUInt64& value) {
- CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestArrayUInt64>>
+ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestArrayUInt64>>
::sendSignal(
*this,
"onTestDerivedArrayAttributeAttributeChanged",
uint32Value, stringValue
);
}
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+ TestInterfaceStub,
+ TestInterfaceStubAdapter,
+ std::tuple<>,
+ std::tuple<bool>
+ > subscribeTestSelectiveBroadcastSelectiveStubDispatcher(&TestInterfaceStubAdapter::subscribeForTestSelectiveBroadcastSelective, "b");
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+ TestInterfaceStub,
+ TestInterfaceStubAdapter,
+ std::tuple<>,
+ std::tuple<>
+ > unsubscribeTestSelectiveBroadcastSelectiveStubDispatcher(&TestInterfaceStubAdapter::unsubscribeFromTestSelectiveBroadcastSelective, "");
+
+
+void TestInterfaceDBusStubAdapter::fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ std::shared_ptr<CommonAPI::DBus::DBusClientId> dbusClientId = std::dynamic_pointer_cast<CommonAPI::DBus::DBusClientId, CommonAPI::ClientId>(clientId);
+
+ if(dbusClientId != NULL)
+ {
+ CommonAPI::DBus::DBusMessage dbusMethodCall = dbusClientId->createMessage(getObjectPath(), getInterfaceName(), "TestSelectiveBroadcast");
+ getDBusConnection()->sendDBusMessage(dbusMethodCall);
+ }
+}
+
+void TestInterfaceDBusStubAdapter::sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers) {
+ const CommonAPI::ClientIdList* actualReceiverList;
+ actualReceiverList = receivers;
+
+ if(receivers == NULL)
+ actualReceiverList = &subscribersForTestSelectiveBroadcastSelective_;
+
+ for (auto clientIdIterator = actualReceiverList->cbegin();
+ clientIdIterator != actualReceiverList->cend();
+ clientIdIterator++) {
+ if(receivers == NULL || subscribersForTestSelectiveBroadcastSelective_.find(*clientIdIterator) != subscribersForTestSelectiveBroadcastSelective_.end()) {
+ fireTestSelectiveBroadcastSelective(*clientIdIterator);
+ }
+ }
+}
+
+void TestInterfaceDBusStubAdapter::subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
+ bool ok = stub_->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
+ if (ok) {
+ subscribersForTestSelectiveBroadcastSelective_.insert(clientId);
+ stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+ success = true;
+ } else {
+ success = false;
+ }
+}
+
+
+void TestInterfaceDBusStubAdapter::unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ subscribersForTestSelectiveBroadcastSelective_.erase(clientId);
+ stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+}
+
+CommonAPI::ClientIdList* const TestInterfaceDBusStubAdapter::getSubscribersForTestSelectiveBroadcastSelective() {
+ return &subscribersForTestSelectiveBroadcastSelective_;
+}
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+ TestInterfaceStub,
+ TestInterfaceStubAdapter,
+ std::tuple<>,
+ std::tuple<bool>
+ > subscribeTestBroadcastWithOutArgsSelectiveStubDispatcher(&TestInterfaceStubAdapter::subscribeForTestBroadcastWithOutArgsSelective, "b");
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+ TestInterfaceStub,
+ TestInterfaceStubAdapter,
+ std::tuple<>,
+ std::tuple<>
+ > unsubscribeTestBroadcastWithOutArgsSelectiveStubDispatcher(&TestInterfaceStubAdapter::unsubscribeFromTestBroadcastWithOutArgsSelective, "");
+
+
+void TestInterfaceDBusStubAdapter::fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue) {
+ std::shared_ptr<CommonAPI::DBus::DBusClientId> dbusClientId = std::dynamic_pointer_cast<CommonAPI::DBus::DBusClientId, CommonAPI::ClientId>(clientId);
+
+ if(dbusClientId != NULL)
+ {
+ CommonAPI::DBus::DBusMessage dbusMethodCall = dbusClientId->createMessage(getObjectPath(), getInterfaceName(), "TestBroadcastWithOutArgs");
+ getDBusConnection()->sendDBusMessage(dbusMethodCall);
+ }
+}
+
+void TestInterfaceDBusStubAdapter::sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers) {
+ const CommonAPI::ClientIdList* actualReceiverList;
+ actualReceiverList = receivers;
+
+ if(receivers == NULL)
+ actualReceiverList = &subscribersForTestBroadcastWithOutArgsSelective_;
+
+ for (auto clientIdIterator = actualReceiverList->cbegin();
+ clientIdIterator != actualReceiverList->cend();
+ clientIdIterator++) {
+ if(receivers == NULL || subscribersForTestBroadcastWithOutArgsSelective_.find(*clientIdIterator) != subscribersForTestBroadcastWithOutArgsSelective_.end()) {
+ fireTestBroadcastWithOutArgsSelective(*clientIdIterator, uint32Value, stringValue);
+ }
+ }
+}
+
+void TestInterfaceDBusStubAdapter::subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
+ bool ok = stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
+ if (ok) {
+ subscribersForTestBroadcastWithOutArgsSelective_.insert(clientId);
+ stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+ success = true;
+ } else {
+ success = false;
+ }
+}
+
+
+void TestInterfaceDBusStubAdapter::unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ subscribersForTestBroadcastWithOutArgsSelective_.erase(clientId);
+ stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+}
+
+CommonAPI::ClientIdList* const TestInterfaceDBusStubAdapter::getSubscribersForTestBroadcastWithOutArgsSelective() {
+ return &subscribersForTestBroadcastWithOutArgsSelective_;
+}
+
const TestInterfaceDBusStubAdapter::StubDispatcherTable& TestInterfaceDBusStubAdapter::getStubDispatcherTable() {
static const TestInterfaceDBusStubAdapter::StubDispatcherTable stubDispatcherTable = {
{ { "testPredefinedTypeMethod", "us" }, &commonapi::tests::testPredefinedTypeMethodStubDispatcher },
{ { "testVoidDerivedTypeMethod", "ia{ua(sq)}" }, &commonapi::tests::testVoidDerivedTypeMethodStubDispatcher },
{ { "testDerivedTypeMethod", "ia{ua(sq)}" }, &commonapi::tests::testDerivedTypeMethodStubDispatcher }
+ ,
+ { { "subscribeForTestSelectiveBroadcastSelective", "" }, &commonapi::tests::subscribeTestSelectiveBroadcastSelectiveStubDispatcher },
+ { { "unsubscribeFromTestSelectiveBroadcastSelective", "" }, &commonapi::tests::unsubscribeTestSelectiveBroadcastSelectiveStubDispatcher },
+ { { "subscribeForTestBroadcastWithOutArgsSelective", "" }, &commonapi::tests::subscribeTestBroadcastWithOutArgsSelectiveStubDispatcher },
+ { { "unsubscribeFromTestBroadcastWithOutArgsSelective", "" }, &commonapi::tests::unsubscribeTestBroadcastWithOutArgsSelectiveStubDispatcher }
};
return stubDispatcherTable;
}
const std::string& dbusObjectPath,
const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
const std::shared_ptr<CommonAPI::StubBase>& stub);
-
+
void fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value);
void fireTestDerivedStructAttributeAttributeChanged(const DerivedTypeCollection::TestStructExtended& value);
void fireTestDerivedArrayAttributeAttributeChanged(const DerivedTypeCollection::TestArrayUInt64& value);
void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue);
+ void fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+ void sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL);
+ void subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success);
+ void unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+ CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective();
+ void fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue);
+ void sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL);
+ void subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success);
+ void unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+ CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective();
const StubDispatcherTable& getStubDispatcherTable();
virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() {
return delegate_->getTestPredefinedTypeAttributeAttribute();
}
-
/// Returns the wrapper class that provides access to the attribute TestDerivedStructAttribute.
virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() {
return delegate_->getTestDerivedStructAttributeAttribute();
}
-
/// Returns the wrapper class that provides access to the attribute TestDerivedArrayAttribute.
virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() {
return delegate_->getTestDerivedArrayAttributeAttribute();
}
-
- /// Returns the wrapper class that provides access to the broadcast TestPredefinedTypeBroadcast.
+ // Returns the wrapper class that provides access to the broadcast TestPredefinedTypeBroadcast.
virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() {
return delegate_->getTestPredefinedTypeBroadcastEvent();
}
-
-
+ // Returns the wrapper class that provides access to the broadcast TestSelectiveBroadcast.
+ virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent() {
+ return delegate_->getTestSelectiveBroadcastSelectiveEvent();
+ }
+ // Returns the wrapper class that provides access to the broadcast TestBroadcastWithOutArgs.
+ virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent() {
+ return delegate_->getTestBroadcastWithOutArgsSelectiveEvent();
+ }
/**
* Calls testEmptyMethod with synchronous semantics.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback);
-
/**
* Calls testVoidPredefinedTypeMethod with synchronous semantics.
*
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback);
-
/**
* Calls testPredefinedTypeMethod with synchronous semantics.
*
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback);
-
/**
* Calls testVoidDerivedTypeMethod with synchronous semantics.
*
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback);
-
/**
* Calls testDerivedTypeMethod with synchronous semantics.
*
std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) {
return delegate_->testEmptyMethodAsync(callback);
}
-
template <typename ... _AttributeExtensions>
void TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) {
delegate_->testVoidPredefinedTypeMethod(uint32Value, stringValue, callStatus);
std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) {
return delegate_->testVoidPredefinedTypeMethodAsync(uint32Value, stringValue, callback);
}
-
template <typename ... _AttributeExtensions>
void TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) {
delegate_->testPredefinedTypeMethod(uint32InValue, stringInValue, callStatus, uint32OutValue, stringOutValue);
std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) {
return delegate_->testPredefinedTypeMethodAsync(uint32InValue, stringInValue, callback);
}
-
template <typename ... _AttributeExtensions>
void TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) {
delegate_->testVoidDerivedTypeMethod(testEnumExtended2Value, testMapValue, callStatus);
std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) {
return delegate_->testVoidDerivedTypeMethodAsync(testEnumExtended2Value, testMapValue, callback);
}
-
template <typename ... _AttributeExtensions>
void TestInterfaceProxy<_AttributeExtensions...>::testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
delegate_->testDerivedTypeMethod(testEnumExtended2InValue, testMapInValue, callStatus, testEnumExtended2OutValue, testMapOutValue);
return delegate_->testDerivedTypeMethodAsync(testEnumExtended2InValue, testMapInValue, callback);
}
-
template <typename ... _AttributeExtensions>
std::string TestInterfaceProxy<_AttributeExtensions...>::getAddress() const {
return delegate_->getAddress();
- /*
- * This file was generated by the CommonAPI Generators.
- *
- * 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_TESTS_Test_Interface_PROXY_BASE_H_
- #define COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
-
- #include "TestInterface.h"
-
-
- #include <commonapi/tests/DerivedTypeCollection.h>
-
- #if !defined (COMMONAPI_INTERNAL_COMPILATION)
- #define COMMONAPI_INTERNAL_COMPILATION
- #endif
-
- #include <CommonAPI/InputStream.h>
- #include <CommonAPI/OutputStream.h>
- #include <cstdint>
- #include <unordered_map>
- #include <vector>
+/*
+* This file was generated by the CommonAPI Generators.
+*
+* 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_TESTS_Test_Interface_PROXY_BASE_H_
+#define COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
- #include <CommonAPI/Attribute.h>
- #include <CommonAPI/Event.h>
- #include <CommonAPI/Proxy.h>
- #include <functional>
- #include <future>
-
- #undef COMMONAPI_INTERNAL_COMPILATION
+#include "TestInterface.h"
- namespace commonapi {
- namespace tests {
- class TestInterfaceProxyBase: virtual public CommonAPI::Proxy {
- public:
- typedef CommonAPI::ObservableAttribute<uint32_t> TestPredefinedTypeAttributeAttribute;
- typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestStructExtended> TestDerivedStructAttributeAttribute;
- typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestArrayUInt64> TestDerivedArrayAttributeAttribute;
- typedef CommonAPI::Event<uint32_t, std::string> TestPredefinedTypeBroadcastEvent;
- typedef std::function<void(const CommonAPI::CallStatus&)> TestEmptyMethodAsyncCallback;
- typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidPredefinedTypeMethodAsyncCallback;
- typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&, const std::string&)> TestPredefinedTypeMethodAsyncCallback;
- typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidDerivedTypeMethodAsyncCallback;
- typedef std::function<void(const CommonAPI::CallStatus&, const DerivedTypeCollection::TestEnumExtended2&, const DerivedTypeCollection::TestMap&)> TestDerivedTypeMethodAsyncCallback;
+#include <commonapi/tests/DerivedTypeCollection.h>
- virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() = 0;
- virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() = 0;
- virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() = 0;
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
- virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() = 0;
+#include <CommonAPI/InputStream.h>
+#include <CommonAPI/OutputStream.h>
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+#include <CommonAPI/Attribute.h>
+#include <CommonAPI/Event.h>
+#include <CommonAPI/SelectiveEvent.h>
+#include <CommonAPI/Proxy.h>
+#include <functional>
+#include <future>
- virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus) = 0;
- virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) = 0;
+#undef COMMONAPI_INTERNAL_COMPILATION
- virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) = 0;
- virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) = 0;
+namespace commonapi {
+namespace tests {
- virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
- virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) = 0;
+class TestInterfaceProxyBase: virtual public CommonAPI::Proxy {
+ public:
+ typedef CommonAPI::ObservableAttribute<uint32_t> TestPredefinedTypeAttributeAttribute;
+ typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestStructExtended> TestDerivedStructAttributeAttribute;
+ typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestArrayUInt64> TestDerivedArrayAttributeAttribute;
+ typedef CommonAPI::Event<uint32_t, std::string> TestPredefinedTypeBroadcastEvent;
+ typedef CommonAPI::SelectiveEvent<> TestSelectiveBroadcastSelectiveEvent;
+ typedef CommonAPI::SelectiveEvent<uint32_t, std::string> TestBroadcastWithOutArgsSelectiveEvent;
- virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) = 0;
- virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) = 0;
+ typedef std::function<void(const CommonAPI::CallStatus&)> TestEmptyMethodAsyncCallback;
+ typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidPredefinedTypeMethodAsyncCallback;
+ typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&, const std::string&)> TestPredefinedTypeMethodAsyncCallback;
+ typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidDerivedTypeMethodAsyncCallback;
+ typedef std::function<void(const CommonAPI::CallStatus&, const DerivedTypeCollection::TestEnumExtended2&, const DerivedTypeCollection::TestMap&)> TestDerivedTypeMethodAsyncCallback;
- virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
- virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback) = 0;
- };
+ virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() = 0;
+ virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() = 0;
+ virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() = 0;
- } // namespace tests
- } // namespace commonapi
+ virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() = 0;
+ virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent() = 0;
+ virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent() = 0;
- #endif // COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
+ virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus) = 0;
+ virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) = 0;
+ virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) = 0;
+ virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) = 0;
+ virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
+ virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) = 0;
+ virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) = 0;
+ virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) = 0;
+ virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
+ virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback) = 0;
+};
+
+} // namespace tests
+} // namespace commonapi
+
+#endif // COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
#include <CommonAPI/OutputStream.h>
#include <cstdint>
#include <unordered_map>
+#include <unordered_set>
#include <vector>
#include <CommonAPI/Stub.h>
-#include <CommonAPI/types.h>
#undef COMMONAPI_INTERNAL_COMPILATION
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0;
+ /**
+ * Sends a selective broadcast event for TestSelectiveBroadcast. Should not be called directly.
+ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
+ */
+ virtual void fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ virtual void sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL) = 0;
+ virtual void subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) = 0;
+ virtual void unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective() = 0;
+ /**
+ * Sends a selective broadcast event for TestBroadcastWithOutArgs. Should not be called directly.
+ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
+ */
+ virtual void fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue) = 0;
+ virtual void sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL) = 0;
+ virtual void subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) = 0;
+ virtual void unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective() = 0;
+protected:
+ /**
+ * Defines properties for storing the ClientIds of clients / proxies that have
+ * subscribed to the selective broadcasts
+ */
+ CommonAPI::ClientIdList subscribersForTestSelectiveBroadcastSelective_;
+ CommonAPI::ClientIdList subscribersForTestBroadcastWithOutArgsSelective_;
};
public:
virtual ~TestInterfaceStubRemoteEvent() { }
- /// Verification callback for remote set requests on the attribute TestPredefinedTypeAttribute.
- virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t TestPredefinedTypeAttribute) = 0;
- /// Action callback for remote set requests on the attribute TestPredefinedTypeAttribute.
- virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged() = 0;
+ /// Verification callback for remote set requests on the attribute TestPredefinedTypeAttribute
+ virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t TestPredefinedTypeAttribute) = 0;
+ /// Action callback for remote set requests on the attribute TestPredefinedTypeAttribute
+ virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged() = 0;
- /// Verification callback for remote set requests on the attribute TestDerivedStructAttribute.
- virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended TestDerivedStructAttribute) = 0;
- /// Action callback for remote set requests on the attribute TestDerivedStructAttribute.
- virtual void onRemoteTestDerivedStructAttributeAttributeChanged() = 0;
+ /// Verification callback for remote set requests on the attribute TestDerivedStructAttribute
+ virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended TestDerivedStructAttribute) = 0;
+ /// Action callback for remote set requests on the attribute TestDerivedStructAttribute
+ virtual void onRemoteTestDerivedStructAttributeAttributeChanged() = 0;
- /// Verification callback for remote set requests on the attribute TestDerivedArrayAttribute.
- virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 TestDerivedArrayAttribute) = 0;
- /// Action callback for remote set requests on the attribute TestDerivedArrayAttribute.
- virtual void onRemoteTestDerivedArrayAttributeAttributeChanged() = 0;
+ /// Verification callback for remote set requests on the attribute TestDerivedArrayAttribute
+ virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 TestDerivedArrayAttribute) = 0;
+ /// Action callback for remote set requests on the attribute TestDerivedArrayAttribute
+ virtual void onRemoteTestDerivedArrayAttributeAttributeChanged() = 0;
};
public:
virtual ~TestInterfaceStub() { }
- /// Provides getter access to the attribute TestPredefinedTypeAttribute.
- virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
- /// Provides getter access to the attribute TestDerivedStructAttribute.
- virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
- /// Provides getter access to the attribute TestDerivedArrayAttribute.
- virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
+ /// Provides getter access to the attribute TestPredefinedTypeAttribute
+ virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ /// Provides getter access to the attribute TestDerivedStructAttribute
+ virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ /// Provides getter access to the attribute TestDerivedArrayAttribute
+ virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
/// This is the method that will be called on remote calls on the method testEmptyMethod.
- virtual void testEmptyMethod(const CommonAPI::ClientId& clientId) = 0;
+ virtual void testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
/// This is the method that will be called on remote calls on the method testVoidPredefinedTypeMethod.
- virtual void testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue) = 0;
+ virtual void testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue) = 0;
/// This is the method that will be called on remote calls on the method testPredefinedTypeMethod.
- virtual void testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
+ virtual void testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
/// This is the method that will be called on remote calls on the method testVoidDerivedTypeMethod.
- virtual void testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) = 0;
+ virtual void testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) = 0;
/// This is the method that will be called on remote calls on the method testDerivedTypeMethod.
- virtual void testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
-
+ virtual void testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
/// Sends a broadcast event for TestPredefinedTypeBroadcast.
virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0;
+ /**
+ * Sends a selective broadcast event for TestSelectiveBroadcast to the given ClientIds.
+ * The ClientIds must all be out of the set of subscribed clients.
+ * If no ClientIds are given, the selective broadcast is sent to all subscribed clients.
+ */
+ virtual void fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL) = 0;
+ /// retreives the list of all subscribed clients for TestSelectiveBroadcast
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective() = 0;
+ /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+ virtual void onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) = 0;
+ /// Hook method for reacting accepting or denying new subscriptions
+ virtual bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+ /**
+ * Sends a selective broadcast event for TestBroadcastWithOutArgs to the given ClientIds.
+ * The ClientIds must all be out of the set of subscribed clients.
+ * If no ClientIds are given, the selective broadcast is sent to all subscribed clients.
+ */
+ virtual void fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL) = 0;
+ /// retreives the list of all subscribed clients for TestBroadcastWithOutArgs
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective() = 0;
+ /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+ virtual void onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) = 0;
+ /// Hook method for reacting accepting or denying new subscriptions
+ virtual bool onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
};
} // namespace tests
return testPredefinedTypeAttributeAttributeValue_;
}
-const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
return getTestPredefinedTypeAttributeAttribute();
}
stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
}
-void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value) {
+void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value) {
setTestPredefinedTypeAttributeAttribute(value);
}
return defaultStub_->trySetTestPredefinedTypeAttributeAttribute(std::move(value));
}
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value) {
return onRemoteSetTestPredefinedTypeAttributeAttribute(value);
}
return testDerivedStructAttributeAttributeValue_;
}
-const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
return getTestDerivedStructAttributeAttribute();
}
stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
}
-void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value) {
+void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value) {
setTestDerivedStructAttributeAttribute(value);
}
return defaultStub_->trySetTestDerivedStructAttributeAttribute(std::move(value));
}
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value) {
return onRemoteSetTestDerivedStructAttributeAttribute(value);
}
return testDerivedArrayAttributeAttributeValue_;
}
-const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
return getTestDerivedArrayAttributeAttribute();
}
stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
}
-void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value) {
+void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value) {
setTestDerivedArrayAttributeAttribute(value);
}
return defaultStub_->trySetTestDerivedArrayAttributeAttribute(std::move(value));
}
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value) {
return onRemoteSetTestDerivedArrayAttributeAttribute(value);
}
}
-void TestInterfaceStubDefault::testEmptyMethod() {
+void TestInterfaceStubDefault::testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId) {
// No operation in default
}
-
-void TestInterfaceStubDefault::testEmptyMethod(const CommonAPI::ClientId& clientId) {
- // Call compatibility interface
- testEmptyMethod();
+void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue) {
+ // No operation in default
}
-void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue) {
+void TestInterfaceStubDefault::testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
// No operation in default
}
-
-void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue) {
- // Call compatibility interface
- testVoidPredefinedTypeMethod(uint32Value, stringValue);
+void TestInterfaceStubDefault::testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
+ // No operation in default
}
-void TestInterfaceStubDefault::testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
+void TestInterfaceStubDefault::testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
// No operation in default
}
-void TestInterfaceStubDefault::testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
- // Call compatibility interface
- testPredefinedTypeMethod(uint32InValue, stringInValue, uint32OutValue, stringOutValue);
+void TestInterfaceStubDefault::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) {
+ stubAdapter_->fireTestPredefinedTypeBroadcastEvent(uint32Value, stringValue);
}
-
-void TestInterfaceStubDefault::testVoidDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
+void TestInterfaceStubDefault::fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers) {
+ stubAdapter_->sendTestSelectiveBroadcastSelective(receivers);
+}
+void TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
// No operation in default
}
-
-
-void TestInterfaceStubDefault::testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
- // Call compatibility interface
- testVoidDerivedTypeMethod(testEnumExtended2Value, testMapValue);
+bool TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ // Accept in default
+ return true;
+}
+CommonAPI::ClientIdList* const TestInterfaceStubDefault::getSubscribersForTestSelectiveBroadcastSelective() {
+ return(stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective());
}
-void TestInterfaceStubDefault::testDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
+void TestInterfaceStubDefault::fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers) {
+ stubAdapter_->sendTestBroadcastWithOutArgsSelective(uint32Value, stringValue, receivers);
+}
+void TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
// No operation in default
}
-
-
-void TestInterfaceStubDefault::testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
- // Call compatibility interface
- testDerivedTypeMethod(testEnumExtended2InValue, testMapInValue, testEnumExtended2OutValue, testMapOutValue);
+bool TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+ // Accept in default
+ return true;
}
-
-
-void TestInterfaceStubDefault::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) {
- stubAdapter_->fireTestPredefinedTypeBroadcastEvent(uint32Value, stringValue);
+CommonAPI::ClientIdList* const TestInterfaceStubDefault::getSubscribersForTestBroadcastWithOutArgsSelective() {
+ return(stubAdapter_->getSubscribersForTestBroadcastWithOutArgsSelective());
}
+
TestInterfaceStubDefault::RemoteEventHandler::RemoteEventHandler(TestInterfaceStubDefault* defaultStub):
defaultStub_(defaultStub) {
}
* TestInterfaceStub. Method callbacks have an empty implementation,
* remote set calls on attributes will always change the value of the attribute
* to the one received.
- *
+ *
* Override this stub if you only want to provide a subset of the functionality
* that would be defined for this service, and/or if you do not need any non-default
* behaviour.
TestInterfaceStubRemoteEvent* initStubAdapter(const std::shared_ptr<TestInterfaceStubAdapter>& stubAdapter);
virtual const uint32_t& getTestPredefinedTypeAttributeAttribute();
- virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId);
+ virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
virtual void setTestPredefinedTypeAttributeAttribute(uint32_t value);
- virtual void setTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value);
+ virtual void setTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value);
virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute();
- virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId);
+ virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
virtual void setTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
- virtual void setTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value);
+ virtual void setTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value);
virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute();
- virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId);
+ virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
virtual void setTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
- virtual void setTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value);
+ virtual void setTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value);
- virtual void testEmptyMethod();
- virtual void testEmptyMethod(const CommonAPI::ClientId& clientId);
+ virtual void testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId);
- virtual void testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue);
- virtual void testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue);
+ virtual void testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue);
- virtual void testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
- virtual void testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
+ virtual void testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
- virtual void testVoidDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
- virtual void testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
+ virtual void testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
+
+ virtual void testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
- virtual void testDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
- virtual void testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
-
virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue);
+ virtual void fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL);
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective();
+ /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+ virtual void onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event);
+ /// Hook method for reacting accepting or denying new subscriptions
+ virtual bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId);
+ virtual void fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL);
+ virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective();
+ /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+ virtual void onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event);
+ /// Hook method for reacting accepting or denying new subscriptions
+ virtual bool onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId);
protected:
virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged();
virtual bool trySetTestPredefinedTypeAttributeAttribute(uint32_t value);
virtual bool validateTestPredefinedTypeAttributeAttributeRequestedValue(const uint32_t& value);
-
virtual void onRemoteTestDerivedStructAttributeAttributeChanged();
virtual bool trySetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
virtual bool validateTestDerivedStructAttributeAttributeRequestedValue(const DerivedTypeCollection::TestStructExtended& value);
-
virtual void onRemoteTestDerivedArrayAttributeAttributeChanged();
virtual bool trySetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
virtual bool validateTestDerivedArrayAttributeAttributeRequestedValue(const DerivedTypeCollection::TestArrayUInt64& value);
-
-
+ std::shared_ptr<TestInterfaceStubAdapter> stubAdapter_;
private:
class RemoteEventHandler: public TestInterfaceStubRemoteEvent {
public:
RemoteEventHandler(TestInterfaceStubDefault* defaultStub);
virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(uint32_t value);
- virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value);
+ virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value);
virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged();
virtual bool onRemoteSetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
- virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value);
+ virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value);
virtual void onRemoteTestDerivedStructAttributeAttributeChanged();
virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
- virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value);
+ virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value);
virtual void onRemoteTestDerivedArrayAttributeAttributeChanged();
};
RemoteEventHandler remoteEventHandler_;
- std::shared_ptr<TestInterfaceStubAdapter> stubAdapter_;
uint32_t testPredefinedTypeAttributeAttributeValue_;
DerivedTypeCollection::TestStructExtended testDerivedStructAttributeAttributeValue_;
String stringValue
}
}
+
+ broadcast TestSelectiveBroadcast selective {
+ }
+
+ broadcast TestBroadcastWithOutArgs selective {
+ out {
+ UInt32 uint32Value
+ String stringValue
+ }
+ }
}
projects / profile / ivi / common-api-dbus-runtime.git / commitdiff