X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=ac39e3640b6a22117bb24e1bd24585536a232e48;hp=14aea7ace9632cb13b6ffb6ba0414c05e125b4e5;hb=dfcf836c5f1f57cadcdbea5c5a7a7034d21ce332;hpb=cebcb6c30e4f866aa1b3d4e07e1a93dd7f178cea diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 14aea7ac..ac39e364 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel Project * + * Copyright (C) 2005-09 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -61,42 +61,17 @@ public: }; // ================================================== -// Relays +// SignalRelay // ================================================== -class SignalProxy::Relay : public QObject { +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: - Relay(SignalProxy *parent) : QObject(parent), _proxy(parent) {} - + SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {} inline SignalProxy *proxy() const { return _proxy; } -private: - SignalProxy *_proxy; -}; - -class SignalProxy::SyncRelay : public SignalProxy::Relay { -public: - SyncRelay(SignalProxy::ExtendedMetaObject *eMeta, SignalProxy *parent); - - int qt_metacall(QMetaObject::Call _c, int _id, void **_a); - - void synchronize(SyncableObject *object); - - int signalCount() const { return _signalCount; } - -private: - ExtendedMetaObject *_eMeta; - QSet _signalIds; - int _signalCount; -}; - -class SignalProxy::SignalRelay : public SignalProxy::Relay { -public: - SignalRelay(SignalProxy *parent) : Relay(parent) {} - int qt_metacall(QMetaObject::Call _c, int _id, void **_a); void attachSignal(QObject *sender, int signalId, const QByteArray &funcName); @@ -111,75 +86,10 @@ private: Signal() : sender(0), signalId(-1) {} }; + SignalProxy *_proxy; QHash _slots; }; -SignalProxy::SyncRelay::SyncRelay(SignalProxy::ExtendedMetaObject *eMeta, SignalProxy *parent) - : Relay(parent), - _eMeta(eMeta) -{ - QByteArray signature; - for(int i = 0; i < eMeta->metaObject()->methodCount(); i++ ) { - signature = eMeta->metaObject()->method(i).signature(); - if(!eMeta->syncMap().contains(signature)) - continue; - - if((proxy()->proxyMode() == SignalProxy::Server && !signature.contains("Requested")) || - (proxy()->proxyMode() == SignalProxy::Client && signature.contains("Requested"))) { - _signalIds << i; - } - } - _signalCount = _signalIds.count(); -} - -void SignalProxy::SyncRelay::synchronize(SyncableObject *object) { - if(object->syncMetaObject() != _eMeta->metaObject()) { - qWarning() << Q_FUNC_INFO << "can't use SyncRelay of class" << _eMeta->metaObject()->className() - << "for SyncableObject" << object << "with syncMetaObject of class" << object->syncMetaObject()->className(); - return; - } - - QSet::const_iterator sigIter = _signalIds.constBegin(); - while(sigIter != _signalIds.constEnd()) { - QMetaObject::connect(object, *sigIter, this, QObject::staticMetaObject.methodCount() + *sigIter); - sigIter++; - } -} - -int SignalProxy::SyncRelay::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(!_signalIds.contains(_id)) { - qWarning() << Q_FUNC_INFO << "_id" << _id << "is not a valid SyncMethod!"; - return _id; - } - - QVariantList params; - - params << _eMeta->metaObject()->className() - << sender()->objectName() - << _eMeta->metaObject()->method(_id).signature(); - - const QList &argTypes = _eMeta->argTypes(_id); - 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(_eMeta->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::Sync, params); - } - _id -= _signalCount; - return _id; -} - - 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 @@ -195,8 +105,8 @@ void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const if(!funcName.isEmpty()) { fn = QMetaObject::normalizedSignature(funcName); } else { - fn = SIGNAL(); - fn += sender->metaObject()->method(signalId).signature(); + fn = SIGNAL(fakeMethodSignature()); + fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature()); } _slots[slotId] = Signal(sender, signalId, fn); @@ -210,7 +120,7 @@ void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId) { if(slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) { slotIter = _slots.erase(slotIter); if(signalId != -1) - break; + break; } else { slotIter++; } @@ -236,12 +146,12 @@ int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void ** 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]); + 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); @@ -257,7 +167,7 @@ int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void ** void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { QVariantList packedFunc; packedFunc << (qint16)requestType - << params; + << params; dispatchPackedFunc(QVariant(packedFunc)); } @@ -299,7 +209,9 @@ void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType // SignalProxy // ================================================== SignalProxy::SignalProxy(QObject* parent) - : QObject(parent) + : QObject(parent), + _heartBeatInterval(30), + _maxHeartBeatCount(2) { setProxyMode(Client); init(); @@ -321,6 +233,18 @@ SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent) } SignalProxy::~SignalProxy() { + QHash::iterator classIter = _syncSlave.begin(); + while(classIter != _syncSlave.end()) { + ObjectId::iterator objIter = classIter->begin(); + while(objIter != classIter->end()) { + SyncableObject *obj = objIter.value(); + objIter = classIter->erase(objIter); + obj->stopSynchronize(this); + } + classIter++; + } + _syncSlave.clear(); + removeAllPeers(); } @@ -330,8 +254,8 @@ void SignalProxy::setProxyMode(ProxyMode mode) { if((*peer)->type() != AbstractPeer::IODevicePeer) { IODevicePeer *ioPeer = static_cast(*peer); if(ioPeer->isOpen()) { - qWarning() << "SignalProxy: Cannot change proxy mode while connected"; - return; + qWarning() << "SignalProxy: Cannot change proxy mode while connected"; + return; } } if((*peer)->type() != AbstractPeer::SignalProxyPeer) { @@ -351,7 +275,9 @@ void SignalProxy::setProxyMode(ProxyMode mode) { void SignalProxy::init() { _signalRelay = new SignalRelay(this); connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat())); - _heartBeatTimer.start(30 * 1000); + setHeartBeatInterval(30); + setMaxHeartBeatCount(2); + _heartBeatTimer.start(); _secure = false; updateSecureState(); } @@ -402,6 +328,17 @@ bool SignalProxy::addPeer(QIODevice* iodev) { return true; } +void SignalProxy::setHeartBeatInterval(int secs) { + if(secs != _heartBeatInterval) { + _heartBeatInterval = secs; + _heartBeatTimer.setInterval(secs * 1000); + } +} + +void SignalProxy::setMaxHeartBeatCount(int max) { + _maxHeartBeatCount = max; +} + bool SignalProxy::addPeer(SignalProxy* proxy) { if(!proxy) return false; @@ -479,15 +416,14 @@ void SignalProxy::removePeerBySender() { removePeer(sender()); } -void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) { - SyncableObject *syncObject = qobject_cast(sender()); - const QMetaObject *meta = syncObject->syncMetaObject(); - const QByteArray className(meta->className()); - objectRenamed(className, newname, oldname); - +void SignalProxy::renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname) { if(proxyMode() == Client) return; + const QMetaObject *meta = obj->syncMetaObject(); + const QByteArray className(meta->className()); + objectRenamed(className, newname, oldname); + QVariantList params; params << "__objectRenamed__" << className << newname << oldname; dispatchSignal(RpcCall, params); @@ -514,9 +450,9 @@ SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObje return 0; } -SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta) { +SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) { if(!_extendedMetaObjects.contains(meta)) { - _extendedMetaObjects[meta] = new ExtendedMetaObject(meta); + _extendedMetaObjects[meta] = new ExtendedMetaObject(meta, checkConflicts); } return _extendedMetaObjects[meta]; } @@ -557,24 +493,13 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha } void SignalProxy::synchronize(SyncableObject *obj) { - ExtendedMetaObject *eMeta = createExtendedMetaObject(obj); - - SyncRelay *relay; - if(!_syncRelays.contains(obj->syncMetaObject())) { - _syncRelays[obj->syncMetaObject()] = new SyncRelay(eMeta, this); - } - relay = _syncRelays[obj->syncMetaObject()]; - - relay->synchronize(obj); + createExtendedMetaObject(obj, true); // attaching as slave to receive sync Calls QByteArray className(obj->syncMetaObject()->className()); _syncSlave[className][obj->objectName()] = obj; - disconnect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); - connect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); if(proxyMode() == Server) { - connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString))); obj->setInitialized(); emit objectInitialized(obj); } else { @@ -583,10 +508,11 @@ void SignalProxy::synchronize(SyncableObject *obj) { else requestInit(obj); } + + obj->synchronize(this); } void SignalProxy::detachObject(QObject *obj) { - stopSync(obj); detachSignals(obj); detachSlots(obj); } @@ -605,12 +531,7 @@ void SignalProxy::detachSlots(QObject* receiver) { } } -void SignalProxy::stopSync(QObject *obj) { - SyncableObject *syncableObject = qobject_cast(obj); - if(syncableObject && _syncRelays.contains(syncableObject->syncMetaObject())) { - QObject::disconnect(syncableObject, 0, _syncRelays[syncableObject->syncMetaObject()], 0); - } - +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* QHash::iterator classIter = _syncSlave.begin(); @@ -621,6 +542,7 @@ void SignalProxy::stopSync(QObject *obj) { } classIter++; } + obj->stopSynchronize(this); } void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { @@ -630,11 +552,11 @@ void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantL 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())); + IODevicePeer *ioPeer = static_cast(*peer); + if(ioPeer->isOpen()) + ioPeer->dispatchPackedFunc(packedFunc); + else + QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key())); } break; case AbstractPeer::SignalProxyPeer: @@ -660,6 +582,18 @@ void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packed } void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList ¶ms) { + 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()) @@ -711,23 +645,27 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { QByteArray className = params.takeFirst().toByteArray(); QString objectName = params.takeFirst().toString(); - QByteArray signal = params.takeFirst().toByteArray(); + 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(signal)).arg(objectName) - << params; + 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->syncMap().contains(signal)) { - qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) - << params; + 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->syncMap()[signal]; + int slotId = eMeta->slotMap()[slot]; + 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)) { @@ -735,12 +673,14 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { return; } + if(returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) { int receiverId = eMeta->receiveMap()[slotId]; QVariantList returnParams; returnParams << className - << objectName - << QByteArray(receiver->metaObject()->method(receiverId).signature()); + << objectName + << eMeta->methodName(receiverId); + //QByteArray(receiver->metaObject()->method(receiverId).signature()); if(eMeta->argTypes(receiverId).count() > 1) returnParams << params; returnParams << returnValue; @@ -754,7 +694,7 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList ¶ms) { if(params.count() != 2) { qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:" - << params; + << params; return; } @@ -763,13 +703,13 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa if(!_syncSlave.contains(className)) { qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" - << className; + << className; return; } if(!_syncSlave[className].contains(objectName)) { qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" - << className << objectName; + << className << objectName; return; } @@ -777,8 +717,8 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa QVariantList params_; params_ << className - << objectName - << initData(obj); + << objectName + << initData(obj); sender->dispatchSignal(InitData, params_); } @@ -787,7 +727,7 @@ void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList ¶m Q_UNUSED(sender) if(params.count() != 3) { qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:" - << params; + << params; return; } @@ -797,13 +737,13 @@ void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList ¶m if(!_syncSlave.contains(className)) { qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" - << className; + << className; return; } if(!_syncSlave[className].contains(objectName)) { qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" - << className << objectName; + << className << objectName; return; } @@ -843,8 +783,8 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList } 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}; + 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}; // check for argument compatibility and build params array for(int i = 0; i < numArgs; i++) { @@ -925,6 +865,9 @@ void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool c } bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) { + if(!dev) + return false; + QDataStream in(dev); in.setVersion(QDataStream::Qt_4_2); @@ -934,12 +877,12 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian } if(blockSize > 1 << 22) { - disconnectDevice(dev, tr("Client tried to send package larger than max package size!")); + disconnectDevice(dev, tr("Peer tried to send package larger than max package size!")); return false; } if(blockSize == 0) { - disconnectDevice(dev, tr("Client tried to send 0 byte package!")); + disconnectDevice(dev, tr("Peer tried to send 0 byte package!")); return false; } @@ -956,8 +899,8 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian 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("Client sent corrupted compressed data!")); - return false; + disconnectDevice(dev, tr("Peer sent corrupted compressed data!")); + return false; } } @@ -971,7 +914,7 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian } if(!item.isValid()) { - disconnectDevice(dev, tr("Client sent corrupt data: unable to load QVariant!")); + disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!")); return false; } @@ -984,7 +927,7 @@ void SignalProxy::requestInit(SyncableObject *obj) { QVariantList params; params << obj->syncMetaObject()->className() - << obj->objectName(); + << obj->objectName(); dispatchSignal(InitRequest, params); } @@ -1004,23 +947,28 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties 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(ioPeer->sentHeartBeats > 1) { - qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address() - << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)"; - ioPeer->close(); - } else { - ioPeer->sentHeartBeats++; + updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval()); } + if(maxHeartBeatCount() >= 0 && ioPeer->sentHeartBeats >= maxHeartBeatCount()) + toClose.append(ioPeer); + else + ioPeer->sentHeartBeats++; } - peer++; + ++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(); } } @@ -1066,6 +1014,34 @@ void SignalProxy::customEvent(QEvent *event) { } } +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); + + QVariantList params; + params << eMeta->metaObject()->className() + << obj->objectName() + << 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() << " - make sure all your data types are known by the Qt MetaSystem"; + return; + } + params << QVariant(argTypes[i], va_arg(ap, void *)); + } + + dispatchSignal(Sync, params); +} + + + void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) { if(!reason.isEmpty()) qWarning() << qPrintable(reason); @@ -1089,36 +1065,17 @@ void SignalProxy::dumpProxyStats() { else mode = "Client"; - int sigCount = 0; - foreach(SyncRelay *relay, _syncRelays.values()) - sigCount += relay->signalCount(); - int slaveCount = 0; foreach(ObjectId oid, _syncSlave.values()) slaveCount += oid.count(); qDebug() << this; qDebug() << " Proxy Mode:" << mode; - // qDebug() << "attached sending Objects:" << _relayHash.count(); - qDebug() << " number of Signals:" << sigCount; qDebug() << " attached Slots:" << _attachedSlots.count(); qDebug() << " number of synced Slaves:" << slaveCount; qDebug() << "number of Classes cached:" << _extendedMetaObjects.count(); } -void SignalProxy::dumpSyncMap(SyncableObject *object) { - const QMetaObject *meta = object->metaObject(); - ExtendedMetaObject *eMeta = extendedMetaObject(object); - qDebug() << "SignalProxy: SyncMap for Class" << meta->className(); - - QHash syncMap_ = eMeta->syncMap(); - QHash::const_iterator iter = syncMap_.constBegin(); - while(iter != syncMap_.constEnd()) { - qDebug() << qPrintable(QString("%1 --> %2 %3").arg(QString(iter.key()), 40).arg(iter.value()).arg(QString(meta->method(iter.value()).signature()))); - iter++; - } -} - void SignalProxy::updateSecureState() { bool wasSecure = _secure; @@ -1136,94 +1093,55 @@ void SignalProxy::updateSecureState() { // ================================================== // ExtendedMetaObject // ================================================== -SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta) +SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) : _meta(meta), - _updatedRemotelyId(-1) + _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()")) { -} - -const QList &SignalProxy::ExtendedMetaObject::argTypes(int methodId) { - if(!_argTypes.contains(methodId)) { - QList paramTypes = _meta->method(methodId).parameterTypes(); - QList argTypes; - for(int i = 0; i < paramTypes.count(); i++) { - argTypes.append(QMetaType::type(paramTypes[i])); - } - _argTypes[methodId] = argTypes; - } - return _argTypes[methodId]; -} - -const int &SignalProxy::ExtendedMetaObject::returnType(int methodId) { - if(!_returnType.contains(methodId)) { - _returnType[methodId] = QMetaType::type(_meta->method(methodId).typeName()); - } - return _returnType[methodId]; -} - -const int &SignalProxy::ExtendedMetaObject::minArgCount(int methodId) { - if(!_minArgCount.contains(methodId)) { - QString signature(_meta->method(methodId).signature()); - _minArgCount[methodId] = _meta->method(methodId).parameterTypes().count() - signature.count("="); - } - return _minArgCount[methodId]; -} - -const QByteArray &SignalProxy::ExtendedMetaObject::methodName(int methodId) { - if(!_methodNames.contains(methodId)) { - _methodNames[methodId] = methodName(_meta->method(methodId)); - } - return _methodNames[methodId]; -} - -const QHash &SignalProxy::ExtendedMetaObject::syncMap() { - if(_syncMap.isEmpty()) { - QHash syncMap; - - QList slotIndexes; - for(int i = 0; i < _meta->methodCount(); i++) { - if(_meta->method(i).methodType() == QMetaMethod::Slot) - slotIndexes << i; - } + for(int i = 0; i < _meta->methodCount(); i++) { + if(_meta->method(i).methodType() != QMetaMethod::Slot) + continue; - // we're faking sync pairs for sync replies - // --> we deliver to every slot starting with "receive" - QByteArray slotSignature; - QList::iterator slotIter = slotIndexes.begin(); - while(slotIter != slotIndexes.end()) { - slotSignature = QByteArray(_meta->method(*slotIter).signature()); - if(slotSignature.startsWith("receive")) { - syncMap[slotSignature] = *slotIter; - slotIter = slotIndexes.erase(slotIter); + if(QByteArray(_meta->method(i).signature()).contains('*')) + continue; // skip methods with ptr params + + QByteArray method = methodName(_meta->method(i)); + if(method.startsWith("init")) + continue; // skip initializers + + if(_methodIds.contains(method)) { + /* 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); + if(current.parameterTypes().count() > candidate.parameterTypes().count()) { + int minCount = candidate.parameterTypes().count(); + QList commonParams = current.parameterTypes().mid(0, minCount); + if(commonParams == candidate.parameterTypes()) + continue; // we already got the full featured version } else { - slotIter++; - } - } - - // find the proper sig -> slot matches - QMetaMethod signal, slot; - int matchIdx; - for(int signalIdx = 0; signalIdx < _meta->methodCount(); signalIdx++) { - signal = _meta->method(signalIdx); - if(signal.methodType() != QMetaMethod::Signal) - continue; - - matchIdx = -1; - foreach(int slotIdx, slotIndexes) { - slot = _meta->method(slotIdx); - if(methodsMatch(signal, slot)) { - matchIdx = slotIdx; - break; - } + int minCount = current.parameterTypes().count(); + QList commonParams = candidate.parameterTypes().mid(0, minCount); + if(commonParams == current.parameterTypes()) { + _methodIds[method] = i; // use the new one + continue; + } } - if(matchIdx != -1) { - slotIndexes.removeAll(matchIdx); - syncMap[QByteArray(signal.signature())] = matchIdx; + 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(); } + continue; } - _syncMap = syncMap; + _methodIds[method] = i; + } +} + +const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId) { + if(!_methods.contains(methodId)) { + _methods[methodId] = MethodDescriptor(_meta->method(methodId)); } - return _syncMap; + return _methods[methodId]; } const QHash &SignalProxy::ExtendedMetaObject::receiveMap() { @@ -1241,19 +1159,19 @@ const QHash &SignalProxy::ExtendedMetaObject::receiveMap() { for(int i = 0; i < methodCount; i++) { requestSlot = _meta->method(i); if(requestSlot.methodType() != QMetaMethod::Slot) - continue; + continue; returnTypeName = requestSlot.typeName(); if(QMetaType::Void == (QMetaType::Type)returnType(i)) - continue; + continue; signature = QByteArray(requestSlot.signature()); if(!signature.startsWith("request")) - continue; + continue; paramsPos = signature.indexOf('('); if(paramsPos == -1) - continue; + continue; methodName = signature.left(paramsPos); params = signature.mid(paramsPos); @@ -1265,53 +1183,24 @@ const QHash &SignalProxy::ExtendedMetaObject::receiveMap() { receiverId = _meta->indexOfSlot(signature); if(receiverId == -1) { - signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); - receiverId = _meta->indexOfSlot(signature); + signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); + receiverId = _meta->indexOfSlot(signature); } - if(receiverId != -1) - receiveMap[i] = receiverId; + if(receiverId != -1) { + receiveMap[i] = receiverId; + } } _receiveMap = receiveMap; } return _receiveMap; } -int SignalProxy::ExtendedMetaObject::updatedRemotelyId() { - if(_updatedRemotelyId == -1) { - _updatedRemotelyId = _meta->indexOfSignal("updatedRemotely()"); - } - return _updatedRemotelyId; -} - QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method) { QByteArray sig(method.signature()); return sig.left(sig.indexOf("(")); } -bool SignalProxy::ExtendedMetaObject::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) { - // if we don't even have the same basename it's a sure NO - QString baseName = methodBaseName(signal); - if(baseName != methodBaseName(slot)) - return false; - - // are the signatures compatible? - if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature())) - return false; - - // we take an educated guess if the signals and slots match - QString signalsuffix = methodName(signal); - QString slotprefix = methodName(slot); - if(!baseName.isEmpty()) { - signalsuffix = signalsuffix.mid(baseName.count()).toLower(); - slotprefix = slotprefix.left(slotprefix.count() - baseName.count()).toLower(); - } - - uint sizediff = qAbs(slotprefix.size() - signalsuffix.size()); - int ratio = editingDistance(slotprefix, signalsuffix) - sizediff; - return (ratio < 2); -} - QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method) { QString methodname = QString(method.signature()).section("(", 0, 0); @@ -1336,3 +1225,24 @@ 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())) +{ + // determine argTypes + QList paramTypes = method.parameterTypes(); + QList argTypes; + for(int i = 0; i < paramTypes.count(); i++) { + argTypes.append(QMetaType::type(paramTypes[i])); + } + _argTypes = argTypes; + + // determine minArgCount + QString signature(method.signature()); + _minArgCount = method.parameterTypes().count() - signature.count("="); + + _receiverMode = (_methodName.startsWith("request")) + ? SignalProxy::Server + : SignalProxy::Client; +} +