X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=caafb65ba9aa41dbb16453c0257ae888d0147db3;hp=f0711f16dfda7585be4192bc4651c8d35839e335;hb=db00831bca59a012242d1ad5fac52a20c6cd2956;hpb=e8a39b4c3c92e193ab861a3fea84a261bb6fbd24

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index f0711f16..caafb65b 100644
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -18,6 +18,9 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
+#include <algorithm>
+#include <utility>
+
 #include <QCoreApplication>
 #include <QHostAddress>
 #include <QMetaMethod>
@@ -25,174 +28,57 @@
 #include <QThread>
 
 #ifdef HAVE_SSL
-    #include <QSslSocket>
+#    include <QSslSocket>
 #endif
 
-#include "signalproxy.h"
-
 #include "peer.h"
 #include "protocol.h"
+#include "signalproxy.h"
 #include "syncableobject.h"
-#include "util.h"
 #include "types.h"
+#include "util.h"
 
 using namespace Protocol;
 
 class RemovePeerEvent : public QEvent
 {
 public:
-    RemovePeerEvent(Peer *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeerEvent)), peer(peer) {}
-    Peer *peer;
+    RemovePeerEvent(Peer* peer)
+        : QEvent(QEvent::Type(SignalProxy::RemovePeerEvent))
+        , peer(peer)
+    {}
+    Peer* peer;
 };
 
-
-// ==================================================
-//  SignalRelay
-// ==================================================
-class SignalProxy::SignalRelay : public QObject
-{
-/* Q_OBJECT is not necessary or even allowed, because we implement
-   qt_metacall ourselves (and don't use any other features of the meta
-   object system)
-*/
-public:
-    SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {}
-    inline SignalProxy *proxy() const { return _proxy; }
-
-    int qt_metacall(QMetaObject::Call _c, int _id, void **_a) override;
-
-    void attachSignal(QObject *sender, int signalId, const QByteArray &funcName);
-    void detachSignal(QObject *sender, int signalId = -1);
-
-private:
-    struct Signal {
-        QObject *sender;
-        int signalId;
-        QByteArray signature;
-        Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {}
-        Signal() : sender(nullptr), signalId(-1) {}
-    };
-
-    SignalProxy *_proxy;
-    QHash<int, Signal> _slots;
-};
-
-
-void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const QByteArray &funcName)
-{
-    // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
-    // all connected methodIds are offset by the standard methodCount of QObject
-    int slotId;
-    for (int i = 0;; i++) {
-        if (!_slots.contains(i)) {
-            slotId = i;
-            break;
-        }
-    }
-
-    QByteArray fn;
-    if (!funcName.isEmpty()) {
-        fn = QMetaObject::normalizedSignature(funcName);
-    }
-    else {
-        fn = SIGNAL(fakeMethodSignature());
-        fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).methodSignature());
-    }
-
-    _slots[slotId] = Signal(sender, signalId, fn);
-
-    QMetaObject::connect(sender, signalId, this, QObject::staticMetaObject.methodCount() + slotId);
-}
-
-
-void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId)
-{
-    QHash<int, Signal>::iterator slotIter = _slots.begin();
-    while (slotIter != _slots.end()) {
-        if (slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) {
-            slotIter = _slots.erase(slotIter);
-            if (signalId != -1)
-                break;
-        }
-        else {
-            ++slotIter;
-        }
-    }
-}
-
-
-int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_slots.contains(_id)) {
-            QObject *caller = sender();
-
-            SignalProxy::ExtendedMetaObject *eMeta = proxy()->extendedMetaObject(caller->metaObject());
-            Q_ASSERT(eMeta);
-
-            const Signal &signal = _slots[_id];
-
-            QVariantList params;
-
-            const QList<int> &argTypes = eMeta->argTypes(signal.signalId);
-            for (int i = 0; i < argTypes.size(); i++) {
-                if (argTypes[i] == 0) {
-                    qWarning() << "SignalRelay::qt_metacall(): received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(caller->metaObject()->className()).arg(caller->metaObject()->method(signal.signalId).methodSignature().constData());
-                    qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
-                    return _id;
-                }
-                params << QVariant(argTypes[i], _a[i+1]);
-            }
-
-            if (proxy()->_restrictMessageTarget) {
-                for (auto peer : proxy()->_restrictedTargets) {
-                    if (peer != nullptr)
-                        proxy()->dispatch(peer, RpcCall(signal.signature, params));
-                }
-            } else
-                proxy()->dispatch(RpcCall(signal.signature, params));
-        }
-        _id -= _slots.count();
-    }
-    return _id;
-}
-
-
 // ==================================================
 //  SignalProxy
 // ==================================================
 
 namespace {
-thread_local SignalProxy *_current{nullptr};
+thread_local SignalProxy* _current{nullptr};
 }
 
-SignalProxy::SignalProxy(QObject *parent)
+SignalProxy::SignalProxy(QObject* parent)
     : QObject(parent)
 {
     setProxyMode(Client);
     init();
 }
 
-
-SignalProxy::SignalProxy(ProxyMode mode, QObject *parent)
+SignalProxy::SignalProxy(ProxyMode mode, QObject* parent)
     : QObject(parent)
 {
     setProxyMode(mode);
     init();
 }
 
-
 SignalProxy::~SignalProxy()
 {
     QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
     while (classIter != _syncSlave.end()) {
         ObjectId::iterator objIter = classIter->begin();
         while (objIter != classIter->end()) {
-            SyncableObject *obj = objIter.value();
+            SyncableObject* obj = objIter.value();
             objIter = classIter->erase(objIter);
             obj->stopSynchronize(this);
         }
@@ -202,16 +88,17 @@ SignalProxy::~SignalProxy()
 
     removeAllPeers();
 
+    // Ensure that we don't try to clean up while destroying ourselves
+    disconnect(this, &QObject::destroyed, this, &SignalProxy::detachSlotObjects);
+
     _current = nullptr;
 }
 
-
-SignalProxy *SignalProxy::current()
+SignalProxy* SignalProxy::current()
 {
     return _current;
 }
 
-
 void SignalProxy::setProxyMode(ProxyMode mode)
 {
     if (!_peerMap.empty()) {
@@ -230,7 +117,6 @@ void SignalProxy::init()
 {
     _heartBeatInterval = 0;
     _maxHeartBeatCount = 0;
-    _signalRelay = new SignalRelay(this);
     setHeartBeatInterval(30);
     setMaxHeartBeatCount(2);
     _secure = false;
@@ -238,18 +124,13 @@ void SignalProxy::init()
     updateSecureState();
 }
 
-
-void SignalProxy::initServer()
-{
-}
-
+void SignalProxy::initServer() {}
 
 void SignalProxy::initClient()
 {
-    attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray,QString,QString)));
+    attachSlot("__objectRenamed__", this, &SignalProxy::objectRenamed);
 }
 
-
 void SignalProxy::setHeartBeatInterval(int secs)
 {
     if (_heartBeatInterval != secs) {
@@ -258,7 +139,6 @@ void SignalProxy::setHeartBeatInterval(int secs)
     }
 }
 
-
 void SignalProxy::setMaxHeartBeatCount(int max)
 {
     if (_maxHeartBeatCount != max) {
@@ -267,8 +147,7 @@ void SignalProxy::setMaxHeartBeatCount(int max)
     }
 }
 
-
-bool SignalProxy::addPeer(Peer *peer)
+bool SignalProxy::addPeer(Peer* peer)
 {
     if (!peer)
         return false;
@@ -286,11 +165,11 @@ bool SignalProxy::addPeer(Peer *peer)
             qWarning("SignalProxy: only one peer allowed in client mode!");
             return false;
         }
-        connect(peer, SIGNAL(lagUpdated(int)), SIGNAL(lagUpdated(int)));
+        connect(peer, &Peer::lagUpdated, this, &SignalProxy::lagUpdated);
     }
 
-    connect(peer, SIGNAL(disconnected()), SLOT(removePeerBySender()));
-    connect(peer, SIGNAL(secureStateChanged(bool)), SLOT(updateSecureState()));
+    connect(peer, &Peer::disconnected, this, &SignalProxy::removePeerBySender);
+    connect(peer, &Peer::secureStateChanged, this, &SignalProxy::updateSecureState);
 
     if (!peer->parent())
         peer->setParent(this);
@@ -311,19 +190,17 @@ bool SignalProxy::addPeer(Peer *peer)
     return true;
 }
 
-
 void SignalProxy::removeAllPeers()
 {
     Q_ASSERT(proxyMode() == Server || peerCount() <= 1);
     // wee need to copy that list since we modify it in the loop
-    QList<Peer *> peers = _peerMap.values();
+    QList<Peer*> peers = _peerMap.values();
     for (auto peer : peers) {
         removePeer(peer);
     }
 }
 
-
-void SignalProxy::removePeer(Peer *peer)
+void SignalProxy::removePeer(Peer* peer)
 {
     if (!peer) {
         qWarning() << Q_FUNC_INFO << "Trying to remove a null peer!";
@@ -355,45 +232,43 @@ void SignalProxy::removePeer(Peer *peer)
         emit disconnected();
 }
 
-
 void SignalProxy::removePeerBySender()
 {
-    removePeer(qobject_cast<Peer *>(sender()));
+    removePeer(qobject_cast<Peer*>(sender()));
 }
 
-
-void SignalProxy::renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname)
+void SignalProxy::renameObject(const SyncableObject* obj, const QString& newname, const QString& oldname)
 {
     if (proxyMode() == Client)
         return;
 
-    const QMetaObject *meta = obj->syncMetaObject();
+    const QMetaObject* meta = obj->syncMetaObject();
     const QByteArray className(meta->className());
     objectRenamed(className, newname, oldname);
 
     dispatch(RpcCall("__objectRenamed__", QVariantList() << className << newname << oldname));
 }
 
-
-void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname)
+void SignalProxy::objectRenamed(const QByteArray& classname, const QString& newname, const QString& oldname)
 {
-    if (_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) {
-        SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
-        requestInit(obj);
+    if (newname != oldname) {
+        if (_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname)) {
+            SyncableObject* obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
+            obj->setObjectName(newname);
+            requestInit(obj);
+        }
     }
 }
 
-
-const QMetaObject *SignalProxy::metaObject(const QObject *obj)
+const QMetaObject* SignalProxy::metaObject(const QObject* obj)
 {
-    if (const SyncableObject *syncObject = qobject_cast<const SyncableObject *>(obj))
+    if (const auto* syncObject = qobject_cast<const SyncableObject*>(obj))
         return syncObject->syncMetaObject();
     else
         return obj->metaObject();
 }
 
-
-SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObject *meta) const
+SignalProxy::ExtendedMetaObject* SignalProxy::extendedMetaObject(const QMetaObject* meta) const
 {
     if (_extendedMetaObjects.contains(meta))
         return _extendedMetaObjects[meta];
@@ -401,8 +276,7 @@ SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObje
         return nullptr;
 }
 
-
-SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts)
+SignalProxy::ExtendedMetaObject* SignalProxy::createExtendedMetaObject(const QMetaObject* meta, bool checkConflicts)
 {
     if (!_extendedMetaObjects.contains(meta)) {
         _extendedMetaObjects[meta] = new ExtendedMetaObject(meta, checkConflicts);
@@ -410,47 +284,27 @@ SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMe
     return _extendedMetaObjects[meta];
 }
 
-
-bool SignalProxy::attachSignal(QObject *sender, const char *signal, const QByteArray &sigName)
+void SignalProxy::attachSlotObject(const QByteArray& signalName, std::unique_ptr<SlotObjectBase> slotObject)
 {
-    const QMetaObject *meta = sender->metaObject();
-    QByteArray sig(meta->normalizedSignature(signal).mid(1));
-    int methodId = meta->indexOfMethod(sig.constData());
-    if (methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
-        qWarning() << "SignalProxy::attachSignal(): No such signal" << signal;
-        return false;
-    }
+    // Remove all attached slots related to the context upon its destruction
+    connect(slotObject->context(), &QObject::destroyed, this, &SignalProxy::detachSlotObjects, Qt::UniqueConnection);
 
-    createExtendedMetaObject(meta);
-    _signalRelay->attachSignal(sender, methodId, sigName);
-
-    disconnect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
-    connect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
-    return true;
+    _attachedSlots.emplace(QMetaObject::normalizedSignature(signalName.constData()), std::move(slotObject));
 }
 
-
-bool SignalProxy::attachSlot(const QByteArray &sigName, QObject *recv, const char *slot)
+void SignalProxy::detachSlotObjects(const QObject *context)
 {
-    const QMetaObject *meta = recv->metaObject();
-    int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
-    if (methodId == -1 || meta->method(methodId).methodType() == QMetaMethod::Method) {
-        qWarning() << "SignalProxy::attachSlot(): No such slot" << slot;
-        return false;
+    for (auto&& it = _attachedSlots.begin(); it != _attachedSlots.end(); ) {
+        if (it->second->context() == context) {
+            it = _attachedSlots.erase(it);
+        }
+        else {
+            ++it;
+        }
     }
-
-    createExtendedMetaObject(meta);
-
-    QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
-    _attachedSlots.insert(funcName, qMakePair(recv, methodId));
-
-    disconnect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
-    connect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
-    return true;
 }
 
-
-void SignalProxy::synchronize(SyncableObject *obj)
+void SignalProxy::synchronize(SyncableObject* obj)
 {
     createExtendedMetaObject(obj, true);
 
@@ -472,37 +326,7 @@ void SignalProxy::synchronize(SyncableObject *obj)
     obj->synchronize(this);
 }
 
-
-void SignalProxy::detachObject(QObject *obj)
-{
-    // Don't try to connect SignalProxy from itself on shutdown
-    if (obj != this) {
-        detachSignals(obj);
-        detachSlots(obj);
-    }
-}
-
-
-void SignalProxy::detachSignals(QObject *sender)
-{
-    _signalRelay->detachSignal(sender);
-}
-
-
-void SignalProxy::detachSlots(QObject *receiver)
-{
-    SlotHash::iterator slotIter = _attachedSlots.begin();
-    while (slotIter != _attachedSlots.end()) {
-        if (slotIter.value().first == receiver) {
-            slotIter = _attachedSlots.erase(slotIter);
-        }
-        else
-            ++slotIter;
-    }
-}
-
-
-void SignalProxy::stopSynchronize(SyncableObject *obj)
+void SignalProxy::stopSynchronize(SyncableObject* obj)
 {
     // we can't use a className here, since it might be effed up, if we receive the call as a result of a decon
     // gladly the objectName() is still valid. So we have only to iterate over the classes not each instance! *sigh*
@@ -517,18 +341,29 @@ void SignalProxy::stopSynchronize(SyncableObject *obj)
     obj->stopSynchronize(this);
 }
 
+void SignalProxy::dispatchSignal(QByteArray sigName, QVariantList params)
+{
+    RpcCall rpcCall{std::move(sigName), std::move(params)};
+    if (_restrictMessageTarget) {
+        for (auto&& peer : _restrictedTargets) {
+            dispatch(peer, rpcCall);
+        }
+    }
+    else {
+        dispatch(rpcCall);
+    }
+}
 
 template<class T>
-void SignalProxy::dispatch(const T &protoMessage)
+void SignalProxy::dispatch(const T& protoMessage)
 {
     for (auto&& peer : _peerMap.values()) {
         dispatch(peer, protoMessage);
     }
 }
 
-
 template<class T>
-void SignalProxy::dispatch(Peer *peer, const T &protoMessage)
+void SignalProxy::dispatch(Peer* peer, const T& protoMessage)
 {
     _targetPeer = peer;
 
@@ -540,19 +375,20 @@ void SignalProxy::dispatch(Peer *peer, const T &protoMessage)
     _targetPeer = nullptr;
 }
 
-
-void SignalProxy::handle(Peer *peer, const SyncMessage &syncMessage)
+void SignalProxy::handle(Peer* peer, const SyncMessage& syncMessage)
 {
     if (!_syncSlave.contains(syncMessage.className) || !_syncSlave[syncMessage.className].contains(syncMessage.objectName)) {
-        qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
+        qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:")
+                          .arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
                    << syncMessage.params;
         return;
     }
 
-    SyncableObject *receiver = _syncSlave[syncMessage.className][syncMessage.objectName];
-    ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
+    SyncableObject* receiver = _syncSlave[syncMessage.className][syncMessage.objectName];
+    ExtendedMetaObject* eMeta = extendedMetaObject(receiver);
     if (!eMeta->slotMap().contains(syncMessage.slotName)) {
-        qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
+        qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:")
+                          .arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
                    << syncMessage.params;
         return;
     }
@@ -589,87 +425,85 @@ void SignalProxy::handle(Peer *peer, const SyncMessage &syncMessage)
     invokeSlot(receiver, eMeta->updatedRemotelyId());
 }
 
+void SignalProxy::handle(Peer* peer, const RpcCall& rpcCall)
+{
+    Q_UNUSED(peer)
+
+    auto range = _attachedSlots.equal_range(rpcCall.signalName);
+    std::for_each(range.first, range.second, [&rpcCall](const auto& p) {
+        if (!p.second->invoke(rpcCall.params)) {
+            qWarning() << "Could not invoke slot for remote signal" << rpcCall.signalName;
+        }
+    });
+}
 
-void SignalProxy::handle(Peer *peer, const InitRequest &initRequest)
+void SignalProxy::handle(Peer* peer, const InitRequest& initRequest)
 {
-   if (!_syncSlave.contains(initRequest.className)) {
-        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
-                   << initRequest.className;
+    if (!_syncSlave.contains(initRequest.className)) {
+        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" << initRequest.className;
         return;
     }
 
     if (!_syncSlave[initRequest.className].contains(initRequest.objectName)) {
-        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
-                   << initRequest.className << initRequest.objectName;
+        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" << initRequest.className
+                   << initRequest.objectName;
         return;
     }
 
-    SyncableObject *obj = _syncSlave[initRequest.className][initRequest.objectName];
+    SyncableObject* obj = _syncSlave[initRequest.className][initRequest.objectName];
     _targetPeer = peer;
     peer->dispatch(InitData(initRequest.className, initRequest.objectName, initData(obj)));
     _targetPeer = nullptr;
 }
 
-
-void SignalProxy::handle(Peer *peer, const InitData &initData)
+void SignalProxy::handle(Peer* peer, const InitData& initData)
 {
     Q_UNUSED(peer)
 
     if (!_syncSlave.contains(initData.className)) {
-        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
-                   << initData.className;
+        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" << initData.className;
         return;
     }
 
     if (!_syncSlave[initData.className].contains(initData.objectName)) {
-        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
-                   << initData.className << initData.objectName;
+        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" << initData.className << initData.objectName;
         return;
     }
 
-    SyncableObject *obj = _syncSlave[initData.className][initData.objectName];
+    SyncableObject* obj = _syncSlave[initData.className][initData.objectName];
     setInitData(obj, initData.initData);
 }
 
-
-void SignalProxy::handle(Peer *peer, const RpcCall &rpcCall)
+bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, QVariant& returnValue, Peer* peer)
 {
-    QObject *receiver;
-    int methodId;
-    SlotHash::const_iterator slot = _attachedSlots.constFind(rpcCall.slotName);
-    while (slot != _attachedSlots.constEnd() && slot.key() == rpcCall.slotName) {
-        receiver = (*slot).first;
-        methodId = (*slot).second;
-        if (!invokeSlot(receiver, methodId, rpcCall.params, peer)) {
-            ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
-            qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData());
-        }
-        ++slot;
-    }
-}
-
-
-bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue, Peer *peer)
-{
-    ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
+    ExtendedMetaObject* eMeta = extendedMetaObject(receiver);
     const QList<int> args = eMeta->argTypes(methodId);
-    const int numArgs = params.count() < args.count()
-                        ? params.count()
-                        : args.count();
+    const int numArgs = params.count() < args.count() ? params.count() : args.count();
 
     if (eMeta->minArgCount(methodId) > params.count()) {
         qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId);
         return false;
     }
 
-    void *_a[] = { nullptr,           // return type...
-                   nullptr, nullptr, nullptr, nullptr, nullptr, // and 10 args - that's the max size qt can handle with signals and slots
-                   nullptr, nullptr, nullptr, nullptr, nullptr };
+    void* _a[] = {nullptr,  // return type...
+                  nullptr,
+                  nullptr,
+                  nullptr,
+                  nullptr,
+                  nullptr,  // and 10 args - that's the max size qt can handle with signals and slots
+                  nullptr,
+                  nullptr,
+                  nullptr,
+                  nullptr,
+                  nullptr};
 
     // check for argument compatibility and build params array
     for (int i = 0; i < numArgs; i++) {
         if (!params[i].isValid()) {
-            qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method" << QString("%1::%2()").arg(receiver->metaObject()->className()).arg(receiver->metaObject()->method(methodId).methodSignature().constData());
+            qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method"
+                       << QString("%1::%2()")
+                              .arg(receiver->metaObject()->className())
+                              .arg(receiver->metaObject()->method(methodId).methodSignature().constData());
             qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
             return false;
         }
@@ -678,37 +512,34 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
             return false;
         }
 
-        _a[i+1] = const_cast<void *>(params[i].constData());
+        _a[i + 1] = const_cast<void*>(params[i].constData());
     }
 
     if (returnValue.type() != QVariant::Invalid)
-        _a[0] = const_cast<void *>(returnValue.constData());
+        _a[0] = const_cast<void*>(returnValue.constData());
 
-    Qt::ConnectionType type = QThread::currentThread() == receiver->thread()
-                              ? Qt::DirectConnection
-                              : Qt::QueuedConnection;
+    Qt::ConnectionType type = QThread::currentThread() == receiver->thread() ? Qt::DirectConnection : Qt::QueuedConnection;
 
     if (type == Qt::DirectConnection) {
         _sourcePeer = peer;
         auto result = receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
         _sourcePeer = nullptr;
         return result;
-    } else {
+    }
+    else {
         qWarning() << "Queued Connections are not implemented yet";
         // note to self: qmetaobject.cpp:990 ff
         return false;
     }
 }
 
-
-bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, Peer *peer)
+bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, Peer* peer)
 {
     QVariant ret;
     return invokeSlot(receiver, methodId, params, ret, peer);
 }
 
-
-void SignalProxy::requestInit(SyncableObject *obj)
+void SignalProxy::requestInit(SyncableObject* obj)
 {
     if (proxyMode() == Server || obj->isInitialized())
         return;
@@ -716,14 +547,12 @@ void SignalProxy::requestInit(SyncableObject *obj)
     dispatch(InitRequest(obj->syncMetaObject()->className(), obj->objectName()));
 }
 
-
-QVariantMap SignalProxy::initData(SyncableObject *obj) const
+QVariantMap SignalProxy::initData(SyncableObject* obj) const
 {
     return obj->toVariantMap();
 }
 
-
-void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties)
+void SignalProxy::setInitData(SyncableObject* obj, const QVariantMap& properties)
 {
     if (obj->isInitialized())
         return;
@@ -733,12 +562,11 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties
     invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId());
 }
 
-
-void SignalProxy::customEvent(QEvent *event)
+void SignalProxy::customEvent(QEvent* event)
 {
     switch ((int)event->type()) {
     case RemovePeerEvent: {
-        ::RemovePeerEvent *e = static_cast< ::RemovePeerEvent *>(event);
+        auto* e = static_cast<::RemovePeerEvent*>(event);
         removePeer(e->peer);
         event->accept();
         break;
@@ -750,26 +578,26 @@ void SignalProxy::customEvent(QEvent *event)
     }
 }
 
-
-void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode modeType, const char *funcname, va_list ap)
+void SignalProxy::sync_call__(const SyncableObject* obj, SignalProxy::ProxyMode modeType, const char* funcname, va_list ap)
 {
     // qDebug() << obj << modeType << "(" << _proxyMode << ")" << funcname;
     if (modeType != _proxyMode)
         return;
 
-    ExtendedMetaObject *eMeta = extendedMetaObject(obj);
+    ExtendedMetaObject* eMeta = extendedMetaObject(obj);
 
     QVariantList params;
 
-    const QList<int> &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname)));
+    const QList<int>& argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname)));
 
     for (int i = 0; i < argTypes.size(); i++) {
         if (argTypes[i] == 0) {
-            qWarning() << Q_FUNC_INFO << "received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(eMeta->metaObject()->className()).arg(funcname);
+            qWarning() << Q_FUNC_INFO << "received invalid data for argument number" << i << "of signal"
+                       << QString("%1::%2").arg(eMeta->metaObject()->className()).arg(funcname);
             qWarning() << "        - make sure all your data types are known by the Qt MetaSystem";
             return;
         }
-        params << QVariant(argTypes[i], va_arg(ap, void *));
+        params << QVariant(argTypes[i], va_arg(ap, void*));
     }
 
     if (_restrictMessageTarget) {
@@ -777,22 +605,21 @@ void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode
             if (peer != nullptr)
                 dispatch(peer, SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
         }
-    } else
+    }
+    else
         dispatch(SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
 }
 
-
-void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason)
+void SignalProxy::disconnectDevice(QIODevice* dev, const QString& reason)
 {
     if (!reason.isEmpty())
         qWarning() << qPrintable(reason);
-    QAbstractSocket *sock  = qobject_cast<QAbstractSocket *>(dev);
+    auto* sock = qobject_cast<QAbstractSocket*>(dev);
     if (sock)
         qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString());
     dev->close();
 }
 
-
 void SignalProxy::dumpProxyStats()
 {
     QString mode;
@@ -802,23 +629,22 @@ void SignalProxy::dumpProxyStats()
         mode = "Client";
 
     int slaveCount = 0;
-    foreach(ObjectId oid, _syncSlave.values())
-    slaveCount += oid.count();
+    foreach (ObjectId oid, _syncSlave.values())
+        slaveCount += oid.count();
 
     qDebug() << this;
     qDebug() << "              Proxy Mode:" << mode;
-    qDebug() << "          attached Slots:" << _attachedSlots.count();
+    qDebug() << "          attached Slots:" << _attachedSlots.size();
     qDebug() << " number of synced Slaves:" << slaveCount;
     qDebug() << "number of Classes cached:" << _extendedMetaObjects.count();
 }
 
-
 void SignalProxy::updateSecureState()
 {
     bool wasSecure = _secure;
 
     _secure = !_peerMap.isEmpty();
-    for (auto peer :  _peerMap.values()) {
+    for (auto peer : _peerMap.values()) {
         _secure &= peer->isSecure();
     }
 
@@ -826,9 +652,10 @@ void SignalProxy::updateSecureState()
         emit secureStateChanged(_secure);
 }
 
-QVariantList SignalProxy::peerData() {
+QVariantList SignalProxy::peerData()
+{
     QVariantList result;
-    for (auto &&peer : _peerMap.values()) {
+    for (auto&& peer : _peerMap.values()) {
         QVariantMap data;
         data["id"] = peer->id();
         data["clientVersion"] = peer->clientVersion();
@@ -845,7 +672,8 @@ QVariantList SignalProxy::peerData() {
     return result;
 }
 
-Peer *SignalProxy::peerById(int peerId) {
+Peer* SignalProxy::peerById(int peerId)
+{
     // We use ::value() here instead of the [] operator because the latter has the side-effect
     // of automatically inserting a null value with the passed key into the map.  See
     // https://doc.qt.io/qt-5/qhash.html#operator-5b-5d and https://doc.qt.io/qt-5/qhash.html#value.
@@ -865,28 +693,42 @@ void SignalProxy::restrictTargetPeers(QSet<Peer*> peers, std::function<void()> c
     _restrictedTargets = previousRestrictedTargets;
 }
 
-Peer *SignalProxy::sourcePeer() {
+Peer* SignalProxy::sourcePeer()
+{
     return _sourcePeer;
 }
 
-void SignalProxy::setSourcePeer(Peer *sourcePeer) {
+void SignalProxy::setSourcePeer(Peer* sourcePeer)
+{
     _sourcePeer = sourcePeer;
 }
 
-Peer *SignalProxy::targetPeer() {
+Peer* SignalProxy::targetPeer()
+{
     return _targetPeer;
 }
 
-void SignalProxy::setTargetPeer(Peer *targetPeer) {
+void SignalProxy::setTargetPeer(Peer* targetPeer)
+{
     _targetPeer = targetPeer;
 }
 
-// ==================================================
-//  ExtendedMetaObject
-// ==================================================
-SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts)
-    : _meta(meta),
-    _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
+// ---- SlotObjectBase ---------------------------------------------------------------------------------------------------------------------
+
+SignalProxy::SlotObjectBase::SlotObjectBase(const QObject* context)
+    : _context{context}
+{}
+
+const QObject* SignalProxy::SlotObjectBase::context() const
+{
+    return _context;
+}
+
+//  ---- ExtendedMetaObject ----------------------------------------------------------------------------------------------------------------
+
+SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject* meta, bool checkConflicts)
+    : _meta(meta)
+    , _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
 {
     for (int i = 0; i < _meta->methodCount(); i++) {
         if (_meta->method(i).methodType() != QMetaMethod::Slot)
@@ -903,8 +745,8 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo
             /* funny... moc creates for methods containing default parameters multiple metaMethod with separate methodIds.
                we don't care... we just need the full fledged version
              */
-            const QMetaMethod &current = _meta->method(_methodIds[method]);
-            const QMetaMethod &candidate = _meta->method(i);
+            const QMetaMethod& current = _meta->method(_methodIds[method]);
+            const QMetaMethod& candidate = _meta->method(i);
             if (current.parameterTypes().count() > candidate.parameterTypes().count()) {
                 int minCount = candidate.parameterTypes().count();
                 QList<QByteArray> commonParams = current.parameterTypes().mid(0, minCount);
@@ -915,13 +757,14 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo
                 int minCount = current.parameterTypes().count();
                 QList<QByteArray> commonParams = candidate.parameterTypes().mid(0, minCount);
                 if (commonParams == current.parameterTypes()) {
-                    _methodIds[method] = i; // use the new one
+                    _methodIds[method] = i;  // use the new one
                     continue;
                 }
             }
             if (checkConflicts) {
                 qWarning() << "class" << meta->className() << "contains overloaded methods which is currently not supported!";
-                qWarning() << " - " << _meta->method(i).methodSignature() << "conflicts with" << _meta->method(_methodIds[method]).methodSignature();
+                qWarning() << " - " << _meta->method(i).methodSignature() << "conflicts with"
+                           << _meta->method(_methodIds[method]).methodSignature();
             }
             continue;
         }
@@ -929,8 +772,7 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo
     }
 }
 
-
-const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId)
+const SignalProxy::ExtendedMetaObject::MethodDescriptor& SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId)
 {
     if (!_methods.contains(methodId)) {
         _methods[methodId] = MethodDescriptor(_meta->method(methodId));
@@ -938,8 +780,7 @@ const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMe
     return _methods[methodId];
 }
 
-
-const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
+const QHash<int, int>& SignalProxy::ExtendedMetaObject::receiveMap()
 {
     if (_receiveMap.isEmpty()) {
         QHash<int, int> receiveMap;
@@ -992,15 +833,13 @@ const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
     return _receiveMap;
 }
 
-
-QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method)
+QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod& method)
 {
     QByteArray sig(method.methodSignature());
     return sig.left(sig.indexOf("("));
 }
 
-
-QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method)
+QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod& method)
 {
     QString methodname = QString(method.methodSignature()).section("(", 0, 0);
 
@@ -1026,10 +865,9 @@ QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &metho
     return methodname;
 }
 
-
-SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaMethod &method)
-    : _methodName(SignalProxy::ExtendedMetaObject::methodName(method)),
-    _returnType(QMetaType::type(method.typeName()))
+SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaMethod& method)
+    : _methodName(SignalProxy::ExtendedMetaObject::methodName(method))
+    , _returnType(QMetaType::type(method.typeName()))
 {
     // determine argTypes
     QList<QByteArray> paramTypes = method.parameterTypes();
@@ -1043,7 +881,5 @@ SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaM
     QString signature(method.methodSignature());
     _minArgCount = method.parameterTypes().count() - signature.count("=");
 
-    _receiverMode = (_methodName.startsWith("request"))
-                    ? SignalProxy::Server
-                    : SignalProxy::Client;
+    _receiverMode = (_methodName.startsWith("request")) ? SignalProxy::Server : SignalProxy::Client;
 }