X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=caafb65ba9aa41dbb16453c0257ae888d0147db3;hp=98364082fb8e3fd55731660f6cf5d460891d51a6;hb=db00831bca59a012242d1ad5fac52a20c6cd2956;hpb=5b686746c880e5cda6d5de3e08180ea4332ff222 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 98364082..caafb65b 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2012 by the Quassel Project * + * Copyright (C) 2005-2018 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -18,278 +18,92 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ -#include "signalproxy.h" +#include +#include -#include -#include -#include +#include #include -#include -#include -#include -#include -#include #include #include -#include +#include + #ifdef HAVE_SSL -#include +# include #endif -#include -#include -#include -#include +#include "peer.h" +#include "protocol.h" +#include "signalproxy.h" #include "syncableobject.h" +#include "types.h" #include "util.h" -// ================================================== -// PeerSignalEvent -// ================================================== -class PeerSignalEvent : public QEvent -{ -public: - PeerSignalEvent(SignalProxy *sender, SignalProxy::RequestType requestType, const QVariantList ¶ms) : QEvent(QEvent::Type(SignalProxy::PeerSignal)), sender(sender), requestType(requestType), params(params) {} - SignalProxy *sender; - SignalProxy::RequestType requestType; - QVariantList params; -}; - +using namespace Protocol; class RemovePeerEvent : public QEvent { public: - RemovePeerEvent(QObject *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeer)), peer(peer) {} - QObject *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); - - 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(0), signalId(-1) {} - }; - - SignalProxy *_proxy; - QHash _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).signature()); - } - - _slots[slotId] = Signal(sender, signalId, fn); - - QMetaObject::connect(sender, signalId, this, QObject::staticMetaObject.methodCount() + slotId); -} - - -void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId) -{ - QHash::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; - params << signal.signature; - - const QList &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(_id).signature()); - qWarning() << " - make sure all your data types are known by the Qt MetaSystem"; - return _id; - } - params << QVariant(argTypes[i], _a[i+1]); - } - - proxy()->dispatchSignal(SignalProxy::RpcCall, params); - } - _id -= _slots.count(); - } - return _id; -} - - -// ================================================== -// Peers +// SignalProxy // ================================================== -void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) -{ - QVariantList packedFunc; - packedFunc << (qint16)requestType - << params; - dispatchPackedFunc(QVariant(packedFunc)); -} - - -bool SignalProxy::IODevicePeer::isSecure() const -{ -#ifdef HAVE_SSL - QSslSocket *sslSocket = qobject_cast(_device); - if (sslSocket) - return sslSocket->isEncrypted() || sslSocket->localAddress() == QHostAddress::LocalHost || sslSocket->localAddress() == QHostAddress::LocalHostIPv6; -#endif - - QAbstractSocket *socket = qobject_cast(_device); - if (socket) - return socket->localAddress() == QHostAddress::LocalHost || socket->localAddress() == QHostAddress::LocalHostIPv6; - return false; +namespace { +thread_local SignalProxy* _current{nullptr}; } - -QString SignalProxy::IODevicePeer::address() const -{ - QAbstractSocket *socket = qobject_cast(_device); - if (socket) - return socket->peerAddress().toString(); - else - return QString(); -} - - -void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) -{ - Qt::ConnectionType type = QThread::currentThread() == receiver->thread() - ? Qt::DirectConnection - : Qt::QueuedConnection; - - if (type == Qt::DirectConnection) { - receiver->receivePeerSignal(sender, requestType, params); - } - else { - QCoreApplication::postEvent(receiver, new PeerSignalEvent(sender, requestType, params)); - } -} - - -// ================================================== -// SignalProxy -// ================================================== -SignalProxy::SignalProxy(QObject *parent) +SignalProxy::SignalProxy(QObject* parent) : QObject(parent) { setProxyMode(Client); init(); } - -SignalProxy::SignalProxy(ProxyMode mode, QObject *parent) - : QObject(parent) -{ - setProxyMode(mode); - init(); -} - - -SignalProxy::SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent) +SignalProxy::SignalProxy(ProxyMode mode, QObject* parent) : QObject(parent) { setProxyMode(mode); - addPeer(device); init(); } - SignalProxy::~SignalProxy() { QHash::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); } - classIter++; + ++classIter; } _syncSlave.clear(); 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() +{ + return _current; +} void SignalProxy::setProxyMode(ProxyMode mode) { - PeerHash::iterator peer = _peers.begin(); - while (peer != _peers.end()) { - if ((*peer)->type() != AbstractPeer::IODevicePeer) { - IODevicePeer *ioPeer = static_cast(*peer); - if (ioPeer->isOpen()) { - qWarning() << "SignalProxy: Cannot change proxy mode while connected"; - return; - } - } - if ((*peer)->type() != AbstractPeer::SignalProxyPeer) { - qWarning() << "SignalProxy: Cannot change proxy mode while connected to another internal SignalProxy"; - return; - } - peer++; + if (!_peerMap.empty()) { + qWarning() << Q_FUNC_INFO << "Cannot change proxy mode while connected"; + return; } _proxyMode = mode; @@ -299,216 +113,170 @@ void SignalProxy::setProxyMode(ProxyMode mode) initClient(); } - void SignalProxy::init() { _heartBeatInterval = 0; _maxHeartBeatCount = 0; - _signalRelay = new SignalRelay(this); - connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat())); setHeartBeatInterval(30); setMaxHeartBeatCount(2); - _heartBeatTimer.start(); _secure = false; + _current = this; updateSecureState(); } - -void SignalProxy::initServer() -{ -} - +void SignalProxy::initServer() {} void SignalProxy::initClient() { - attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString))); -} - - -bool SignalProxy::addPeer(QIODevice *iodev) -{ - if (!iodev) - return false; - - if (_peers.contains(iodev)) - return true; - - if (proxyMode() == Client && !_peers.isEmpty()) { - qWarning("SignalProxy: only one peer allowed in client mode!"); - return false; - } - - if (!iodev->isOpen()) { - qWarning("SignalProxy::addPeer(QIODevice *iodev): iodev needs to be open!"); - return false; - } - - connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender())); - connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable())); - -#ifdef HAVE_SSL - QSslSocket *sslSocket = qobject_cast(iodev); - if (sslSocket) { - connect(iodev, SIGNAL(encrypted()), this, SLOT(updateSecureState())); - } -#endif - - if (!iodev->parent()) - iodev->setParent(this); - - _peers[iodev] = new IODevicePeer(iodev, iodev->property("UseCompression").toBool()); - - if (_peers.count() == 1) - emit connected(); - - updateSecureState(); - return true; + attachSlot("__objectRenamed__", this, &SignalProxy::objectRenamed); } - void SignalProxy::setHeartBeatInterval(int secs) { - if (secs != _heartBeatInterval) { + if (_heartBeatInterval != secs) { _heartBeatInterval = secs; - _heartBeatTimer.setInterval(secs * 1000); + emit heartBeatIntervalChanged(secs); } } - void SignalProxy::setMaxHeartBeatCount(int max) { - _maxHeartBeatCount = max; + if (_maxHeartBeatCount != max) { + _maxHeartBeatCount = max; + emit maxHeartBeatCountChanged(max); + } } - -bool SignalProxy::addPeer(SignalProxy *proxy) +bool SignalProxy::addPeer(Peer* peer) { - if (!proxy) + if (!peer) return false; - if (proxyMode() == proxy->proxyMode()) { - qWarning() << "SignalProxy::addPeer(): adding a SignalProxy as peer requires one proxy to be server and one client!"; + if (_peerMap.values().contains(peer)) + return true; + + if (!peer->isOpen()) { + qWarning("SignalProxy: peer needs to be open!"); return false; } - if (_peers.contains(proxy)) { - return true; + if (proxyMode() == Client) { + if (!_peerMap.isEmpty()) { + qWarning("SignalProxy: only one peer allowed in client mode!"); + return false; + } + connect(peer, &Peer::lagUpdated, this, &SignalProxy::lagUpdated); } - if (proxyMode() == Client && !_peers.isEmpty()) { - qWarning("SignalProxy: only one peer allowed in client mode!"); - return false; + connect(peer, &Peer::disconnected, this, &SignalProxy::removePeerBySender); + connect(peer, &Peer::secureStateChanged, this, &SignalProxy::updateSecureState); + + if (!peer->parent()) + peer->setParent(this); + + if (peer->id() < 0) { + peer->setId(nextPeerId()); + peer->setConnectedSince(QDateTime::currentDateTimeUtc()); } - _peers[proxy] = new SignalProxyPeer(this, proxy); - proxy->addPeer(this); + _peerMap[peer->id()] = peer; + + peer->setSignalProxy(this); - if (_peers.count() == 1) + if (peerCount() == 1) emit connected(); updateSecureState(); return true; } - void SignalProxy::removeAllPeers() { - Q_ASSERT(proxyMode() == Server || _peers.count() <= 1); + Q_ASSERT(proxyMode() == Server || peerCount() <= 1); // wee need to copy that list since we modify it in the loop - QList peers = _peers.keys(); - foreach(QObject *peer, peers) { + QList peers = _peerMap.values(); + for (auto peer : peers) { removePeer(peer); } } - -void SignalProxy::removePeer(QObject *dev) +void SignalProxy::removePeer(Peer* peer) { - if (_peers.isEmpty()) { - qWarning() << "SignalProxy::removePeer(): No peers in use!"; + if (!peer) { + qWarning() << Q_FUNC_INFO << "Trying to remove a null peer!"; return; } - Q_ASSERT(dev); - if (!_peers.contains(dev)) { - qWarning() << "SignalProxy: unknown Peer" << dev; + if (_peerMap.isEmpty()) { + qWarning() << "SignalProxy::removePeer(): No peers in use!"; return; } - AbstractPeer *peer = _peers[dev]; - _peers.remove(dev); - - disconnect(dev, 0, this, 0); - if (peer->type() == AbstractPeer::IODevicePeer) - emit peerRemoved(static_cast(dev)); - - if (peer->type() == AbstractPeer::SignalProxyPeer) { - SignalProxy *proxy = static_cast(dev); - if (proxy->_peers.contains(this)) - proxy->removePeer(this); + if (!_peerMap.values().contains(peer)) { + qWarning() << "SignalProxy: unknown Peer" << peer; + return; } - if (dev->parent() == this) - dev->deleteLater(); + disconnect(peer, nullptr, this, nullptr); + peer->setSignalProxy(nullptr); + + _peerMap.remove(peer->id()); + emit peerRemoved(peer); - delete peer; + if (peer->parent() == this) + peer->deleteLater(); updateSecureState(); - if (_peers.isEmpty()) + if (_peerMap.isEmpty()) emit disconnected(); } - void SignalProxy::removePeerBySender() { - removePeer(sender()); + removePeer(qobject_cast(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); - QVariantList params; - params << "__objectRenamed__" << className << newname << oldname; - dispatchSignal(RpcCall, params); + 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(obj)) + if (const auto* syncObject = qobject_cast(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]; else - return 0; + 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); @@ -516,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 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); @@ -578,34 +326,7 @@ void SignalProxy::synchronize(SyncableObject *obj) obj->synchronize(this); } - -void SignalProxy::detachObject(QObject *obj) -{ - 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* @@ -615,145 +336,76 @@ void SignalProxy::stopSynchronize(SyncableObject *obj) classIter->remove(obj->objectName()); break; } - classIter++; + ++classIter; } obj->stopSynchronize(this); } - -void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) +void SignalProxy::dispatchSignal(QByteArray sigName, QVariantList params) { - QVariant packedFunc(QVariantList() << (qint16)requestType << params); - PeerHash::iterator peer = _peers.begin(); - while (peer != _peers.end()) { - switch ((*peer)->type()) { - case AbstractPeer::IODevicePeer: - { - IODevicePeer *ioPeer = static_cast(*peer); - if (ioPeer->isOpen()) - ioPeer->dispatchPackedFunc(packedFunc); - else - QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key())); + RpcCall rpcCall{std::move(sigName), std::move(params)}; + if (_restrictMessageTarget) { + for (auto&& peer : _restrictedTargets) { + dispatch(peer, rpcCall); } - break; - case AbstractPeer::SignalProxyPeer: - (*peer)->dispatchSignal(requestType, params); - break; - default: - Q_ASSERT(false); // there shouldn't be any peers with wrong / unknown type - } - peer++; + } + else { + dispatch(rpcCall); } } - -void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packedFunc) +template +void SignalProxy::dispatch(const T& protoMessage) { - QVariantList params(packedFunc.toList()); - - if (params.isEmpty()) { - qWarning() << "SignalProxy::receivePeerSignal(): received incompatible Data:" << packedFunc; - return; + for (auto&& peer : _peerMap.values()) { + dispatch(peer, protoMessage); } - - RequestType requestType = (RequestType)params.takeFirst().value(); - receivePeerSignal(sender, requestType, params); } - -void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList ¶ms) +template +void SignalProxy::dispatch(Peer* peer, const T& protoMessage) { - switch (requestType) { - // list all RequestTypes that shouldnot trigger a heartbeat counter reset here - case HeartBeatReply: - break; - default: - if (sender->type() == AbstractPeer::IODevicePeer) { - IODevicePeer *ioPeer = static_cast(sender); - ioPeer->sentHeartBeats = 0; - } - } - - // qDebug() << "SignalProxy::receivePeerSignal)" << requestType << params; - switch (requestType) { - case RpcCall: - if (params.empty()) - qWarning() << "SignalProxy::receivePeerSignal(): received empty RPC-Call"; - else - handleSignal(params); - //handleSignal(params.takeFirst().toByteArray(), params); - break; - - case Sync: - handleSync(sender, params); - break; - - case InitRequest: - handleInitRequest(sender, params); - break; - - case InitData: - handleInitData(sender, params); - break; + _targetPeer = peer; - case HeartBeat: - receiveHeartBeat(sender, params); - break; - - case HeartBeatReply: - receiveHeartBeatReply(sender, params); - break; + if (peer && peer->isOpen()) + peer->dispatch(protoMessage); + else + QCoreApplication::postEvent(this, new ::RemovePeerEvent(peer)); - default: - qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << requestType << params; - } + _targetPeer = nullptr; } - -void SignalProxy::receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList ¶ms) +void SignalProxy::handle(Peer* peer, const SyncMessage& syncMessage) { - if (!_peers.contains(sender)) { - // we output only the pointer value. otherwise Qt would try to pretty print. As the object might already been destroyed, this is not a good idea. - qWarning() << "SignalProxy::receivePeerSignal(): received Signal from unknown Proxy" << reinterpret_cast(sender); + 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) + << syncMessage.params; return; } - receivePeerSignal(_peers[sender], requestType, params); -} - -void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) -{ - if (params.count() < 3) { - qWarning() << "received invalid Sync call" << params; + 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) + << syncMessage.params; return; } - QByteArray className = params.takeFirst().toByteArray(); - QString objectName = params.takeFirst().toString(); - QByteArray slot = params.takeFirst().toByteArray(); - - if (!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) { - qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName) - << params; - return; - } - - SyncableObject *receiver = _syncSlave[className][objectName]; - ExtendedMetaObject *eMeta = extendedMetaObject(receiver); - if (!eMeta->slotMap().contains(slot)) { - qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName) - << params; - return; - } - - int slotId = eMeta->slotMap()[slot]; + int slotId = eMeta->slotMap()[syncMessage.slotName]; if (proxyMode() != eMeta->receiverMode(slotId)) { qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed. Wrong ProxyMode!", eMeta->methodName(slotId).constData()); return; } - QVariant returnValue((QVariant::Type)eMeta->returnType(slotId)); - if (!invokeSlot(receiver, slotId, params, returnValue)) { + // We can no longer construct a QVariant from QMetaType::Void + QVariant returnValue; + int returnType = eMeta->returnType(slotId); + if (returnType != QMetaType::Void) + returnValue = QVariant(static_cast(returnType)); + + if (!invokeSlot(receiver, slotId, syncMessage.params, returnValue, peer)) { qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData()); return; } @@ -761,127 +413,97 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) if (returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) { int receiverId = eMeta->receiveMap()[slotId]; QVariantList returnParams; - returnParams << className - << objectName - << eMeta->methodName(receiverId); - //QByteArray(receiver->metaObject()->method(receiverId).signature()); if (eMeta->argTypes(receiverId).count() > 1) - returnParams << params; + returnParams << syncMessage.params; returnParams << returnValue; - sender->dispatchSignal(Sync, returnParams); + _targetPeer = peer; + peer->dispatch(SyncMessage(syncMessage.className, syncMessage.objectName, eMeta->methodName(receiverId), returnParams)); + _targetPeer = nullptr; } // send emit update signal invokeSlot(receiver, eMeta->updatedRemotelyId()); } - -void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList ¶ms) +void SignalProxy::handle(Peer* peer, const RpcCall& rpcCall) { - if (params.count() != 2) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:" - << params; - return; - } + Q_UNUSED(peer) - QByteArray className(params[0].toByteArray()); - QString objectName(params[1].toString()); + 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; + } + }); +} - if (!_syncSlave.contains(className)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" - << className; +void SignalProxy::handle(Peer* peer, const InitRequest& initRequest) +{ + if (!_syncSlave.contains(initRequest.className)) { + qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" << initRequest.className; return; } - if (!_syncSlave[className].contains(objectName)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" - << className << objectName; + if (!_syncSlave[initRequest.className].contains(initRequest.objectName)) { + qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" << initRequest.className + << initRequest.objectName; return; } - SyncableObject *obj = _syncSlave[className][objectName]; - - QVariantList params_; - params_ << className - << objectName - << initData(obj); - - sender->dispatchSignal(InitData, params_); + SyncableObject* obj = _syncSlave[initRequest.className][initRequest.objectName]; + _targetPeer = peer; + peer->dispatch(InitData(initRequest.className, initRequest.objectName, initData(obj))); + _targetPeer = nullptr; } - -void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList ¶ms) +void SignalProxy::handle(Peer* peer, const InitData& initData) { - Q_UNUSED(sender) - if (params.count() != 3) { - qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:" - << params; - return; - } + Q_UNUSED(peer) - QByteArray className(params[0].toByteArray()); - QString objectName(params[1].toString()); - QVariantMap propertyMap(params[2].toMap()); - - if (!_syncSlave.contains(className)) { - qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" - << className; + if (!_syncSlave.contains(initData.className)) { + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" << initData.className; return; } - if (!_syncSlave[className].contains(objectName)) { - qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" - << className << objectName; + if (!_syncSlave[initData.className].contains(initData.objectName)) { + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" << initData.className << initData.objectName; return; } - SyncableObject *obj = _syncSlave[className][objectName]; - setInitData(obj, propertyMap); + SyncableObject* obj = _syncSlave[initData.className][initData.objectName]; + setInitData(obj, initData.initData); } - -//void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList ¶ms) { -void SignalProxy::handleSignal(const QVariantList &data) +bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, QVariant& returnValue, Peer* peer) { - QVariantList params = data; - QByteArray funcName = params.takeFirst().toByteArray(); - - QObject *receiver; - int methodId; - SlotHash::const_iterator slot = _attachedSlots.constFind(funcName); - while (slot != _attachedSlots.constEnd() && slot.key() == funcName) { - receiver = (*slot).first; - methodId = (*slot).second; - if (!invokeSlot(receiver, methodId, params)) { - 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 ¶ms, QVariant &returnValue) -{ - ExtendedMetaObject *eMeta = extendedMetaObject(receiver); + ExtendedMetaObject* eMeta = extendedMetaObject(receiver); const QList 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[] = { 0, // return type... - 0, 0, 0, 0, 0, // and 10 args - that's the max size qt can handle with signals and slots - 0, 0, 0, 0, 0 }; + 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).signature()); + 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; } @@ -889,18 +511,20 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId); return false; } - _a[i+1] = const_cast(params[i].constData()); + + _a[i + 1] = const_cast(params[i].constData()); } if (returnValue.type() != QVariant::Invalid) - _a[0] = const_cast(returnValue.constData()); + _a[0] = const_cast(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) { - return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0; + _sourcePeer = peer; + auto result = receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0; + _sourcePeer = nullptr; + return result; } else { qWarning() << "Queued Connections are not implemented yet"; @@ -909,140 +533,26 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList } } - -bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms) +bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, Peer* peer) { QVariant ret; - return invokeSlot(receiver, methodId, params, ret); -} - - -void SignalProxy::dataAvailable() -{ - // yet again. it's a private slot. no need for checks. - QIODevice *ioDev = qobject_cast(sender()); - Q_ASSERT(_peers.contains(ioDev) && _peers[ioDev]->type() == AbstractPeer::IODevicePeer); - IODevicePeer *peer = static_cast(_peers[ioDev]); - QVariant var; - while (peer->readData(var)) - receivePackedFunc(peer, var); -} - - -void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool compressed) -{ - QAbstractSocket *sock = qobject_cast(dev); - if (!dev->isOpen() || (sock && sock->state() != QAbstractSocket::ConnectedState)) { - qWarning("SignalProxy: Can't call write on a closed device"); - return; - } - - QByteArray block; - QDataStream out(&block, QIODevice::WriteOnly); - out.setVersion(QDataStream::Qt_4_2); - out << (quint32)0; - - if (compressed) { - QByteArray rawItem; - QDataStream itemStream(&rawItem, QIODevice::WriteOnly); - - itemStream.setVersion(QDataStream::Qt_4_2); - itemStream << item; - - rawItem = qCompress(rawItem); - - out << rawItem; - } - else { - out << item; - } - - out.device()->seek(0); - out << (quint32)(block.size() - sizeof(quint32)); - - dev->write(block); -} - - -bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) -{ - if (!dev) - return false; - - QDataStream in(dev); - in.setVersion(QDataStream::Qt_4_2); - - if (blockSize == 0) { - if (dev->bytesAvailable() < (int)sizeof(quint32)) return false; - in >> blockSize; - } - - if (blockSize > 1 << 22) { - disconnectDevice(dev, tr("Peer tried to send package larger than max package size!")); - return false; - } - - if (blockSize == 0) { - disconnectDevice(dev, tr("Peer tried to send 0 byte package!")); - return false; - } - - if (dev->bytesAvailable() < blockSize) - return false; - - blockSize = 0; - - if (compressed) { - QByteArray rawItem; - in >> rawItem; - - int nbytes = rawItem.size(); - if (nbytes <= 4) { - const char *data = rawItem.constData(); - if (nbytes < 4 || (data[0] != 0 || data[1] != 0 || data[2] != 0 || data[3] != 0)) { - disconnectDevice(dev, tr("Peer sent corrupted compressed data!")); - return false; - } - } - - rawItem = qUncompress(rawItem); - - QDataStream itemStream(&rawItem, QIODevice::ReadOnly); - itemStream.setVersion(QDataStream::Qt_4_2); - itemStream >> item; - } - else { - in >> item; - } - - if (!item.isValid()) { - disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!")); - return false; - } - - return true; + return invokeSlot(receiver, methodId, params, ret, peer); } - -void SignalProxy::requestInit(SyncableObject *obj) +void SignalProxy::requestInit(SyncableObject* obj) { if (proxyMode() == Server || obj->isInitialized()) return; - QVariantList params; - params << obj->syncMetaObject()->className() - << obj->objectName(); - dispatchSignal(InitRequest, params); + 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; @@ -1052,133 +562,64 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId()); } - -void SignalProxy::sendHeartBeat() -{ - QVariantList heartBeatParams; - heartBeatParams << QTime::currentTime(); - QList toClose; - - PeerHash::iterator peer = _peers.begin(); - while (peer != _peers.end()) { - if ((*peer)->type() == AbstractPeer::IODevicePeer) { - IODevicePeer *ioPeer = static_cast(*peer); - ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams); - if (ioPeer->sentHeartBeats > 0) { - updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval()); - } - if (maxHeartBeatCount() >= 0 && ioPeer->sentHeartBeats >= maxHeartBeatCount()) - toClose.append(ioPeer); - else - ioPeer->sentHeartBeats++; - } - ++peer; - } - - foreach(IODevicePeer *ioPeer, toClose) { - qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address() - << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats *_heartBeatTimer.interval() / 1000 << "seconds)"; - ioPeer->close(); - } -} - - -void SignalProxy::receiveHeartBeat(AbstractPeer *peer, const QVariantList ¶ms) +void SignalProxy::customEvent(QEvent* event) { - peer->dispatchSignal(SignalProxy::HeartBeatReply, params); -} - - -void SignalProxy::receiveHeartBeatReply(AbstractPeer *peer, const QVariantList ¶ms) -{ - if (peer->type() != AbstractPeer::IODevicePeer) { - qWarning() << "SignalProxy::receiveHeartBeatReply: received heart beat from a non IODevicePeer!"; - return; - } - - IODevicePeer *ioPeer = static_cast(peer); - ioPeer->sentHeartBeats = 0; - - if (params.isEmpty()) { - qWarning() << "SignalProxy: received heart beat reply with less params then sent from:" << ioPeer->address(); - return; - } - - QTime sendTime = params[0].value(); - updateLag(ioPeer, sendTime.msecsTo(QTime::currentTime()) / 2); -} - - -void SignalProxy::customEvent(QEvent *event) -{ - switch (+event->type()) { - case PeerSignal: - { - PeerSignalEvent *e = static_cast(event); - receivePeerSignal(e->sender, e->requestType, e->params); - } + switch ((int)event->type()) { + case RemovePeerEvent: { + auto* e = static_cast<::RemovePeerEvent*>(event); + removePeer(e->peer); event->accept(); break; - case RemovePeer: - { - RemovePeerEvent *e = static_cast(event); - removePeer(e->peer); } - event->accept(); + default: + qWarning() << Q_FUNC_INFO << "Received unknown custom event:" << event->type(); return; } } - -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; - params << eMeta->metaObject()->className() - << obj->objectName() - << QByteArray(funcname); - const QList &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname))); + const QList& 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*)); } - dispatchSignal(Sync, params); + if (_restrictMessageTarget) { + for (auto peer : _restrictedTargets) { + if (peer != nullptr) + dispatch(peer, SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params)); + } + } + 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(dev); + auto* sock = qobject_cast(dev); if (sock) qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString()); dev->close(); } - -void SignalProxy::updateLag(IODevicePeer *peer, int lag) -{ - peer->lag = lag; - if (proxyMode() == Client) { - emit lagUpdated(lag); - } -} - - void SignalProxy::dumpProxyStats() { QString mode; @@ -1188,44 +629,112 @@ 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 = !_peers.isEmpty(); - PeerHash::const_iterator peerIter; - for (peerIter = _peers.constBegin(); peerIter != _peers.constEnd(); peerIter++) { - _secure &= (*peerIter)->isSecure(); + _secure = !_peerMap.isEmpty(); + for (auto peer : _peerMap.values()) { + _secure &= peer->isSecure(); } if (wasSecure != _secure) emit secureStateChanged(_secure); } +QVariantList SignalProxy::peerData() +{ + QVariantList result; + for (auto&& peer : _peerMap.values()) { + QVariantMap data; + data["id"] = peer->id(); + data["clientVersion"] = peer->clientVersion(); + // We explicitly rename this, as, due to the Debian reproducability changes, buildDate isn’t actually the build + // date anymore, but on newer clients the date of the last git commit + data["clientVersionDate"] = peer->buildDate(); + data["remoteAddress"] = peer->address(); + data["connectedSince"] = peer->connectedSince(); + data["secure"] = peer->isSecure(); + data["features"] = static_cast(peer->features().toLegacyFeatures()); + data["featureList"] = peer->features().toStringList(); + result << data; + } + return result; +} -// ================================================== -// ExtendedMetaObject -// ================================================== -SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) - : _meta(meta), - _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()")) +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. + return _peerMap.value(peerId); +} + +void SignalProxy::restrictTargetPeers(QSet peers, std::function closure) +{ + auto previousRestrictMessageTarget = _restrictMessageTarget; + auto previousRestrictedTargets = _restrictedTargets; + _restrictMessageTarget = true; + _restrictedTargets = peers; + + closure(); + + _restrictMessageTarget = previousRestrictMessageTarget; + _restrictedTargets = previousRestrictedTargets; +} + +Peer* SignalProxy::sourcePeer() +{ + return _sourcePeer; +} + +void SignalProxy::setSourcePeer(Peer* sourcePeer) +{ + _sourcePeer = sourcePeer; +} + +Peer* SignalProxy::targetPeer() +{ + return _targetPeer; +} + +void SignalProxy::setTargetPeer(Peer* targetPeer) +{ + _targetPeer = targetPeer; +} + +// ---- 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) continue; - if (QByteArray(_meta->method(i).signature()).contains('*')) + if (_meta->method(i).methodSignature().contains('*')) continue; // skip methods with ptr params QByteArray method = methodName(_meta->method(i)); @@ -1236,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 ¤t = _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 commonParams = current.parameterTypes().mid(0, minCount); @@ -1248,13 +757,14 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo int minCount = current.parameterTypes().count(); QList 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).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature(); + qWarning() << " - " << _meta->method(i).methodSignature() << "conflicts with" + << _meta->method(_methodIds[method]).methodSignature(); } continue; } @@ -1262,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)); @@ -1271,8 +780,7 @@ const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMe return _methods[methodId]; } - -const QHash &SignalProxy::ExtendedMetaObject::receiveMap() +const QHash& SignalProxy::ExtendedMetaObject::receiveMap() { if (_receiveMap.isEmpty()) { QHash receiveMap; @@ -1294,7 +802,7 @@ const QHash &SignalProxy::ExtendedMetaObject::receiveMap() if (QMetaType::Void == (QMetaType::Type)returnType(i)) continue; - signature = QByteArray(requestSlot.signature()); + signature = requestSlot.methodSignature(); if (!signature.startsWith("request")) continue; @@ -1325,17 +833,15 @@ const QHash &SignalProxy::ExtendedMetaObject::receiveMap() return _receiveMap; } - -QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method) +QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod& method) { - QByteArray sig(method.signature()); + 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.signature()).section("(", 0, 0); + QString methodname = QString(method.methodSignature()).section("(", 0, 0); // determine where we have to chop: int upperCharPos; @@ -1359,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 paramTypes = method.parameterTypes(); @@ -1373,10 +878,8 @@ SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaM _argTypes = argTypes; // determine minArgCount - QString signature(method.signature()); + 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; }