From d5095471627f6399b277d7c6d06b6bbcb915c57f Mon Sep 17 00:00:00 2001 From: Marcus Eggenberger Date: Tue, 6 Jan 2009 01:16:21 +0100 Subject: [PATCH] Internal cleanup of the SignalProxy. --- src/common/signalproxy.cpp | 552 ++++++++++++++++------------------ src/common/signalproxy.h | 185 ++++++------ src/common/syncableobject.cpp | 4 +- src/common/util.cpp | 5 - src/common/util.h | 2 - 5 files changed, 358 insertions(+), 390 deletions(-) diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 7c43592c..4459c047 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -75,9 +75,9 @@ public: void attachSignal(int methodId, const QByteArray &func); void setSynchronize(bool); - bool synchronize() const; - int sigCount() const; + inline bool synchronize() const { return _sync; } + inline int sigCount() const { return sigNames.count(); } private: bool isSyncMethod(int i); @@ -101,9 +101,12 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QObject::qt_metacall(_c, _id, _a); if(_id < 0) return _id; + + SignalProxy::ExtendedMetaObject *eMeta = proxy->extendedMetaObject(caller); + Q_ASSERT(eMeta); if(_c == QMetaObject::InvokeMetaMethod) { if(sigNames.contains(_id) || synchronize()) { - const QList &argTypes = proxy->argTypes(caller, _id); + const QList &argTypes = eMeta->argTypes(_id); QVariantList params; int n = argTypes.size(); for(int i=0; imetaObject()->method(_id).signature()); SyncableObject *syncObject = qobject_cast(caller); - if(synchronize() && proxy->syncMap(syncObject).contains(signature)) { + if(synchronize() && eMeta->syncMap().contains(signature)) { //qDebug() << "__SYNC__ >>>" // << caller->metaObject()->className() // << caller->objectName() @@ -169,7 +172,9 @@ bool SignalRelay::isSyncMethod(int i) { return false; QByteArray signature = syncObject->syncMetaObject()->method(i).signature(); - if(!proxy->syncMap(syncObject).contains(signature)) + SignalProxy::ExtendedMetaObject *eMeta = proxy->extendedMetaObject(caller); + Q_ASSERT(eMeta); + if(!eMeta->syncMap().contains(signature)) return false; if(proxy->proxyMode() == SignalProxy::Server && !signature.contains("Requested")) @@ -181,15 +186,6 @@ bool SignalRelay::isSyncMethod(int i) { return false; } -bool SignalRelay::synchronize() const { - return _sync; -} - -int SignalRelay::sigCount() const { - // only for debuging purpose - return sigNames.count(); -} - void SignalRelay::attachSignal(int methodId, const QByteArray &func) { // 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 @@ -456,210 +452,25 @@ void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newn } } -void SignalProxy::setArgTypes(QObject* obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QList p = meta->method(methodId).parameterTypes(); - QList argTypes; - int ct = p.count(); - for(int i=0; iargTypes.contains(methodId)); - _classInfo[meta]->argTypes[methodId] = argTypes; -} - -const QList &SignalProxy::argTypes(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->argTypes.contains(methodId)) - setArgTypes(obj, methodId); - return _classInfo[meta]->argTypes[methodId]; -} - -void SignalProxy::setReturnType(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - int returnType = QMetaType::type(meta->method(methodId).typeName()); - - Q_ASSERT(!_classInfo[meta]->returnType.contains(methodId)); - _classInfo[meta]->returnType[methodId] = returnType; -} - -const int &SignalProxy::returnType(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->returnType.contains(methodId)) - setReturnType(obj, methodId); - return _classInfo[meta]->returnType[methodId]; -} - -void SignalProxy::setMinArgCount(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QString signature(meta->method(methodId).signature()); - int minCount = meta->method(methodId).parameterTypes().count() - signature.count("="); - Q_ASSERT(!_classInfo[meta]->minArgCount.contains(methodId)); - _classInfo[meta]->minArgCount[methodId] = minCount; -} - -const int &SignalProxy::minArgCount(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->minArgCount.contains(methodId)) - setMinArgCount(obj, methodId); - return _classInfo[meta]->minArgCount[methodId]; -} - -void SignalProxy::setMethodName(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QByteArray method(::methodName(meta->method(methodId))); - Q_ASSERT(!_classInfo[meta]->methodNames.contains(methodId)); - _classInfo[meta]->methodNames[methodId] = method; -} - -const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->methodNames.contains(methodId)) - setMethodName(obj, methodId); - return _classInfo[meta]->methodNames[methodId]; -} - - -void SignalProxy::setSyncMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - QHash syncMap; - - QList slotIndexes; - for(int i = 0; i < meta->methodCount(); i++) { - if(meta->method(i).methodType() == QMetaMethod::Slot) - slotIndexes << i; - } - - // we're faking sync pairs for sync replies - QByteArray slotSignature; - foreach(int slotIdx, slotIndexes) { - slotSignature = QByteArray(meta->method(slotIdx).signature()); - if(!slotSignature.startsWith("receive")) - continue; - syncMap[slotSignature] = slotIdx; - } - - 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; - } - } - if(matchIdx != -1) { - slotIndexes.removeAt(slotIndexes.indexOf(matchIdx)); - syncMap[QByteArray(signal.signature())] = matchIdx; - } - } - - Q_ASSERT(_classInfo[meta]->syncMap.isEmpty()); - _classInfo[meta]->syncMap = syncMap; -} - -const QHash &SignalProxy::syncMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - if(_classInfo[meta]->syncMap.isEmpty()) - setSyncMap(obj); - return _classInfo[meta]->syncMap; -} - -void SignalProxy::setReceiveMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - - QHash receiveMap; - - QMetaMethod requestSlot; - QByteArray returnTypeName; - QByteArray signature; - QByteArray methodName; - QByteArray params; - int paramsPos; - int receiverId; - const int methodCount = meta->methodCount(); - for(int i = 0; i < methodCount; i++) { - requestSlot = meta->method(i); - if(requestSlot.methodType() != QMetaMethod::Slot) - continue; - - returnTypeName = requestSlot.typeName(); - if(QMetaType::Void == (QMetaType::Type)returnType(obj, i)) - continue; - - signature = QByteArray(requestSlot.signature()); - if(!signature.startsWith("request")) - continue; - - paramsPos = signature.indexOf('('); - if(paramsPos == -1) - continue; - - methodName = signature.left(paramsPos); - params = signature.mid(paramsPos); - - methodName = methodName.replace("request", "receive"); - params = params.left(params.count() - 1) + ", " + returnTypeName + ")"; - - signature = QMetaObject::normalizedSignature(methodName + params); - receiverId = meta->indexOfSlot(signature); - - if(receiverId == -1) { - signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); - receiverId = meta->indexOfSlot(signature); - } - - if(receiverId != -1) - receiveMap[i] = receiverId; - } - _classInfo[meta]->receiveMap = receiveMap; -} - -const QHash &SignalProxy::receiveMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - if(_classInfo[meta]->receiveMap.isEmpty()) - setReceiveMap(obj); - return _classInfo[meta]->receiveMap; -} - -void SignalProxy::setUpdatedRemotelyId(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - _classInfo[meta]->updatedRemotelyId = meta->indexOfSignal("updatedRemotely()"); -} - -int SignalProxy::updatedRemotelyId(SyncableObject *obj) { - Q_ASSERT(_classInfo.contains(obj->syncMetaObject())); - return _classInfo[obj->syncMetaObject()]->updatedRemotelyId; -} - -const QMetaObject *SignalProxy::metaObject(QObject *obj) { - if(SyncableObject *syncObject = qobject_cast(obj)) +const QMetaObject *SignalProxy::metaObject(const QObject *obj) { + if(const SyncableObject *syncObject = qobject_cast(obj)) return syncObject->syncMetaObject(); else return obj->metaObject(); } -void SignalProxy::createClassInfo(QObject *obj) { - const QMetaObject *meta = metaObject(obj); - if(_classInfo.contains(meta)) - return; +SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QObject *obj) const { + if(_extendedMetaObjects.contains(metaObject(obj))) + return _extendedMetaObjects[metaObject(obj)]; + else + return 0; +} - ClassInfo *classInfo = new ClassInfo(); - _classInfo[meta] = classInfo; +void SignalProxy::createExtendedMetaObject(const QObject *obj) { + const QMetaObject *meta = metaObject(obj); + if(!_extendedMetaObjects.contains(meta)) { + _extendedMetaObjects[meta] = new ExtendedMetaObject(meta); + } } bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) { @@ -671,7 +482,7 @@ bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteA return false; } - createClassInfo(sender); + createExtendedMetaObject(sender); SignalRelay* relay; if(_relayHash.contains(sender)) @@ -693,7 +504,7 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha return false; } - createClassInfo(recv); + createExtendedMetaObject(recv); QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData()); _attachedSlots.insert(funcName, qMakePair(recv, methodId)); @@ -704,8 +515,7 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha } void SignalProxy::synchronize(SyncableObject *obj) { - createClassInfo(obj); - setUpdatedRemotelyId(obj); + createExtendedMetaObject(obj); // attaching all the Signals SignalRelay* relay; @@ -732,16 +542,6 @@ void SignalProxy::synchronize(SyncableObject *obj) { } } -void SignalProxy::requestInit(SyncableObject *obj) { - if(proxyMode() == Server || obj->isInitialized()) - return; - - QVariantList params; - params << obj->syncMetaObject()->className() - << obj->objectName(); - dispatchSignal(InitRequest, params); -} - void SignalProxy::detachSender() { detachObject(sender()); } @@ -881,34 +681,35 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { } SyncableObject *receiver = _syncSlave[className][objectName]; - if(!syncMap(receiver).contains(signal)) { + 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; return; } - int slotId = syncMap(receiver)[signal]; + int slotId = eMeta->syncMap()[signal]; - QVariant returnValue((QVariant::Type)returnType(receiver, slotId)); + QVariant returnValue((QVariant::Type)eMeta->returnType(slotId)); if(!invokeSlot(receiver, slotId, params, returnValue)) { - qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); + qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData()); return; } - if(returnValue.type() != QVariant::Invalid && receiveMap(receiver).contains(slotId)) { - int receiverId = receiveMap(receiver)[slotId]; + 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()); - if(argTypes(receiver, receiverId).count() > 1) + if(eMeta->argTypes(receiverId).count() > 1) returnParams << params; returnParams << returnValue; sender->dispatchSignal(Sync, returnParams); } // send emit update signal - invokeSlot(receiver, updatedRemotelyId(receiver)); + invokeSlot(receiver, eMeta->updatedRemotelyId()); } void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList ¶ms) { @@ -982,20 +783,23 @@ void SignalProxy::handleSignal(const QVariantList &data) { while(slot != _attachedSlots.constEnd() && slot.key() == funcName) { receiver = (*slot).first; methodId = (*slot).second; - if(!invokeSlot(receiver, methodId, params)) - qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData()); + 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) { - const QList args = argTypes(receiver, methodId); + ExtendedMetaObject *eMeta = extendedMetaObject(receiver); + const QList args = eMeta->argTypes(methodId); const int numArgs = params.count() < args.count() ? params.count() : args.count(); - if(minArgCount(receiver, methodId) > params.count()) { - qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << methodName(receiver, methodId); + if(eMeta->minArgCount(methodId) > params.count()) { + qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId); return false; } @@ -1011,7 +815,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList return false; } if(args[i] != QMetaType::type(params[i].typeName())) { - qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << methodName(receiver, methodId); + qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId); return false; } _a[i+1] = const_cast(params[i].constData()); @@ -1135,56 +939,14 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian return true; } -bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const { - // 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; -// if(ratio < 2) { -// qDebug() << Q_FUNC_INFO; -// qDebug() << methodBaseName(signal) << methodBaseName(slot); -// qDebug() << signalsuffix << slotprefix << sizediff << ratio; -// } - return (ratio < 2); -} - -QString SignalProxy::methodBaseName(const QMetaMethod &method) { - QString methodname = QString(method.signature()).section("(", 0, 0); - - // determine where we have to chop: - int upperCharPos; - if(method.methodType() == QMetaMethod::Slot) { - // we take evertyhing from the first uppercase char if it's slot - upperCharPos = methodname.indexOf(QRegExp("[A-Z]")); - if(upperCharPos == -1) - return QString(); - methodname = methodname.mid(upperCharPos); - } else { - // and if it's a signal we discard everything from the last uppercase char - upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]")); - if(upperCharPos == -1) - return QString(); - methodname = methodname.left(upperCharPos); - } - - methodname[0] = methodname[0].toUpper(); +void SignalProxy::requestInit(SyncableObject *obj) { + if(proxyMode() == Server || obj->isInitialized()) + return; - return methodname; + QVariantList params; + params << obj->syncMetaObject()->className() + << obj->objectName(); + dispatchSignal(InitRequest, params); } QVariantMap SignalProxy::initData(SyncableObject *obj) const { @@ -1197,7 +959,7 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties obj->fromVariantMap(properties); obj->setInitialized(); emit objectInitialized(obj); - invokeSlot(obj, updatedRemotelyId(obj)); + invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId()); } void SignalProxy::sendHeartBeat() { @@ -1281,7 +1043,6 @@ void SignalProxy::updateLag(IODevicePeer *peer, int lag) { } } - void SignalProxy::dumpProxyStats() { QString mode; if(proxyMode() == Server) @@ -1303,14 +1064,15 @@ void SignalProxy::dumpProxyStats() { qDebug() << " number of Signals:" << sigCount; qDebug() << " attached Slots:" << _attachedSlots.count(); qDebug() << " number of synced Slaves:" << slaveCount; - qDebug() << "number of Classes cached:" << _classInfo.count(); + 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_ = syncMap(object); + 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()))); @@ -1330,3 +1092,207 @@ void SignalProxy::updateSecureState() { if(wasSecure != _secure) emit secureStateChanged(_secure); } + + +// ================================================== +// ExtendedMetaObject +// ================================================== +SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta) + : _meta(meta), + _updatedRemotelyId(-1) +{ +} + +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; + } + + // 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; + slotIndexes.erase(slotIter); + } 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; + } + } + if(matchIdx != -1) { + slotIndexes.removeAll(matchIdx); + syncMap[QByteArray(signal.signature())] = matchIdx; + } + } + _syncMap = syncMap; + } + return _syncMap; +} + +const QHash &SignalProxy::ExtendedMetaObject::receiveMap() { + if(_receiveMap.isEmpty()) { + QHash receiveMap; + + QMetaMethod requestSlot; + QByteArray returnTypeName; + QByteArray signature; + QByteArray methodName; + QByteArray params; + int paramsPos; + int receiverId; + const int methodCount = _meta->methodCount(); + for(int i = 0; i < methodCount; i++) { + requestSlot = _meta->method(i); + if(requestSlot.methodType() != QMetaMethod::Slot) + continue; + + returnTypeName = requestSlot.typeName(); + if(QMetaType::Void == (QMetaType::Type)returnType(i)) + continue; + + signature = QByteArray(requestSlot.signature()); + if(!signature.startsWith("request")) + continue; + + paramsPos = signature.indexOf('('); + if(paramsPos == -1) + continue; + + methodName = signature.left(paramsPos); + params = signature.mid(paramsPos); + + methodName = methodName.replace("request", "receive"); + params = params.left(params.count() - 1) + ", " + returnTypeName + ")"; + + signature = QMetaObject::normalizedSignature(methodName + params); + receiverId = _meta->indexOfSlot(signature); + + if(receiverId == -1) { + signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); + receiverId = _meta->indexOfSlot(signature); + } + + if(receiverId != -1) + receiveMap[i] = receiverId; + } + } + 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); + + // determine where we have to chop: + int upperCharPos; + if(method.methodType() == QMetaMethod::Slot) { + // we take evertyhing from the first uppercase char if it's slot + upperCharPos = methodname.indexOf(QRegExp("[A-Z]")); + if(upperCharPos == -1) + return QString(); + methodname = methodname.mid(upperCharPos); + } else { + // and if it's a signal we discard everything from the last uppercase char + upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]")); + if(upperCharPos == -1) + return QString(); + methodname = methodname.left(upperCharPos); + } + + methodname[0] = methodname[0].toUpper(); + + return methodname; +} + diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h index 129a6a29..584626e0 100644 --- a/src/common/signalproxy.h +++ b/src/common/signalproxy.h @@ -40,6 +40,7 @@ class SignalProxy : public QObject { class AbstractPeer; class IODevicePeer; + class SignalProxyPeer; public: enum ProxyMode { @@ -78,7 +79,7 @@ public: bool addPeer(SignalProxy *proxy); void removePeer(QObject *peer); void removeAllPeers(); - + bool attachSignal(QObject *sender, const char *signal, const QByteArray& sigName = QByteArray()); bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot); @@ -86,8 +87,6 @@ public: // void setInitialized(SyncableObject *obj); // bool isInitialized(SyncableObject *obj) const; - void requestInit(SyncableObject *obj); - void detachObject(QObject *obj); void detachSignals(QObject *sender); void detachSlots(QObject *receiver); @@ -106,32 +105,13 @@ public: */ static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed = false); - bool isSecure() const { return _secure; } - - static QString methodBaseName(const QMetaMethod &method); - - const QList &argTypes(QObject *obj, int methodId); - const int &returnType(QObject *obj, int methodId); - const int &minArgCount(QObject *obj, int methodId); - const QByteArray &methodName(QObject *obj, int methodId); - const QHash &syncMap(SyncableObject *obj); - const QHash &receiveMap(SyncableObject *obj); - int updatedRemotelyId(SyncableObject *obj); - - typedef QHash > ArgHash; - typedef QHash MethodNameHash; - struct ClassInfo { - ArgHash argTypes; - QHash returnType; - QHash minArgCount; - MethodNameHash methodNames; - int updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster - QHash syncMap; - QHash receiveMap; - }; + class ExtendedMetaObject; + ExtendedMetaObject *extendedMetaObject(const QObject *obj) const; + void createExtendedMetaObject(const QObject *obj); + bool isSecure() const { return _secure; } void dumpProxyStats(); - + protected: void customEvent(QEvent *event); @@ -160,18 +140,8 @@ private: void init(); void initServer(); void initClient(); - - const QMetaObject *metaObject(QObject *obj); - void createClassInfo(QObject *obj); - void setArgTypes(QObject *obj, int methodId); - void setReturnType(QObject *obj, int methodId); - void setMinArgCount(QObject *obj, int methodId); - void setMethodName(QObject *obj, int methodId); - void setSyncMap(SyncableObject *obj); - void setReceiveMap(SyncableObject *obj); - void setUpdatedRemotelyId(SyncableObject *obj); - - bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const; + + static const QMetaObject *metaObject(const QObject *obj); void dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList ¶ms); void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms); @@ -187,6 +157,7 @@ private: bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms, QVariant &returnValue); bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms = QVariantList()); + void requestInit(SyncableObject *obj); QVariantMap initData(SyncableObject *obj) const; void setInitData(SyncableObject *obj, const QVariantMap &properties); @@ -195,63 +166,17 @@ private: public: void dumpSyncMap(SyncableObject *object); inline int peerCount() const { return _peers.size(); } - + private: static void disconnectDevice(QIODevice *dev, const QString &reason = QString()); - class AbstractPeer { - public: - enum PeerType { - NotAPeer = 0, - IODevicePeer = 1, - SignalProxyPeer = 2 - }; - AbstractPeer() : _type(NotAPeer) {} - AbstractPeer(PeerType type) : _type(type) {} - virtual ~AbstractPeer() {} - inline PeerType type() const { return _type; } - virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) = 0; - virtual bool isSecure() const = 0; - private: - PeerType _type; - }; - - class IODevicePeer : public AbstractPeer { - public: - IODevicePeer(QIODevice *device, bool compress) : AbstractPeer(AbstractPeer::IODevicePeer), _device(device), byteCount(0), usesCompression(compress), sentHeartBeats(0), lag(0) {} - virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms); - virtual bool isSecure() const; - inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); } - QString address() const; - inline bool isOpen() const { return _device->isOpen(); } - inline void close() const { _device->close(); } - inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); } - private: - QIODevice *_device; - quint32 byteCount; - bool usesCompression; - public: - int sentHeartBeats; - int lag; - }; - - class SignalProxyPeer : public AbstractPeer { - public: - SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {} - virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms); - virtual inline bool isSecure() const { return true; } - private: - SignalProxy *sender; - SignalProxy *receiver; - }; - // a Hash of the actual used communication object to it's corresponding peer // currently a communication object can either be an arbitrary QIODevice or another SignalProxy typedef QHash PeerHash; PeerHash _peers; // containg a list of argtypes for fast access - QHash _classInfo; + QHash _extendedMetaObjects; // we use one SignalRelay per QObject QHash _relayHash; @@ -270,8 +195,92 @@ private: QTimer _heartBeatTimer; bool _secure; // determines if all connections are in a secured state (using ssl or internal connections) - + friend class SignalRelay; }; + +// ================================================== +// ExtendedMetaObject +// ================================================== +class SignalProxy::ExtendedMetaObject { +public: + ExtendedMetaObject(const QMetaObject *meta); + + const QList &argTypes(int methodId); + const int &returnType(int methodId); + const int &minArgCount(int methodId); + const QByteArray &methodName(int methodId); + const QHash &syncMap(); + const QHash &receiveMap(); + int updatedRemotelyId(); + + static QByteArray methodName(const QMetaMethod &method); + static bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot); + static QString methodBaseName(const QMetaMethod &method); + +private: + typedef QHash > ArgHash; + typedef QHash MethodNameHash; + + const QMetaObject *_meta; + ArgHash _argTypes; + QHash _returnType; + QHash _minArgCount; + MethodNameHash _methodNames; + int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster + QHash _syncMap; + QHash _receiveMap; +}; + + +// ================================================== +// Peers +// ================================================== +class SignalProxy::AbstractPeer { +public: + enum PeerType { + NotAPeer = 0, + IODevicePeer = 1, + SignalProxyPeer = 2 + }; + AbstractPeer() : _type(NotAPeer) {} + AbstractPeer(PeerType type) : _type(type) {} + virtual ~AbstractPeer() {} + inline PeerType type() const { return _type; } + virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) = 0; + virtual bool isSecure() const = 0; +private: + PeerType _type; +}; + +class SignalProxy::IODevicePeer : public SignalProxy::AbstractPeer { +public: + IODevicePeer(QIODevice *device, bool compress) : AbstractPeer(AbstractPeer::IODevicePeer), _device(device), byteCount(0), usesCompression(compress), sentHeartBeats(0), lag(0) {} + virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms); + virtual bool isSecure() const; + inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); } + QString address() const; + inline bool isOpen() const { return _device->isOpen(); } + inline void close() const { _device->close(); } + inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); } +private: + QIODevice *_device; + quint32 byteCount; + bool usesCompression; +public: + int sentHeartBeats; + int lag; +}; + +class SignalProxy::SignalProxyPeer : public SignalProxy::AbstractPeer { +public: + SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {} + virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms); + virtual inline bool isSecure() const { return true; } +private: + SignalProxy *sender; + SignalProxy *receiver; +}; + #endif diff --git a/src/common/syncableobject.cpp b/src/common/syncableobject.cpp index ec34708a..fe320a96 100644 --- a/src/common/syncableobject.cpp +++ b/src/common/syncableobject.cpp @@ -86,7 +86,7 @@ QVariantMap SyncableObject::toVariantMap() { // ...as well as methods, which have names starting with "init" for(int i = 0; i < meta->methodCount(); i++) { QMetaMethod method = meta->method(i); - QString methodname(::methodName(method)); + QString methodname(SignalProxy::ExtendedMetaObject::methodName(method)); if(!methodname.startsWith("init") || methodname.startsWith("initSet") || methodname.startsWith("initDone")) continue; @@ -99,7 +99,7 @@ QVariantMap SyncableObject::toVariantMap() { QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value); QMetaObject::invokeMethod(this, methodname.toAscii(), genericvalue); - properties[SignalProxy::methodBaseName(method)] = value; + properties[SignalProxy::ExtendedMetaObject::methodBaseName(method)] = value; } // properties["Payload"] = QByteArray(10000000, 'a'); // for testing purposes return properties; diff --git a/src/common/util.cpp b/src/common/util.cpp index c267d0bf..d7e7ae18 100644 --- a/src/common/util.cpp +++ b/src/common/util.cpp @@ -150,11 +150,6 @@ uint editingDistance(const QString &s1, const QString &s2) { return matrix[n-1][m-1]; } -QByteArray methodName(const QMetaMethod &method) { - QByteArray sig(method.signature()); - return sig.left(sig.indexOf("(")); -} - QDir quasselDir() { QString quasselDir; if(Quassel::isOptionSet("datadir")) { diff --git a/src/common/util.h b/src/common/util.h index 6725a8d5..bbacda04 100644 --- a/src/common/util.h +++ b/src/common/util.h @@ -50,8 +50,6 @@ QString decodeString(const QByteArray &input, QTextCodec *codec = 0); uint editingDistance(const QString &s1, const QString &s2); -QByteArray methodName(const QMetaMethod &method); - QDir quasselDir(); void loadTranslation(const QLocale &locale); -- 2.20.1