X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=f6f75d65ca1f3d76ee5079d4aba6b4eb1cb2ba27;hp=b2b6c771e80e1dc0519a27fb1fe232c2da7a1684;hb=72d25daa2c6cc00c17e79f756ad70bc00b41f9a8;hpb=e579b77068ae216e275fee0bb560c2a4ea9c7225 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index b2b6c771..f6f75d65 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-07 by the Quassel IRC Team * + * Copyright (C) 2005-08 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -19,6 +19,7 @@ ***************************************************************************/ #include "signalproxy.h" + #include #include #include @@ -29,8 +30,10 @@ #include #include #include -#include #include +#include + +#include "syncableobject.h" #include "util.h" class SignalRelay: public QObject { @@ -65,7 +68,7 @@ SignalRelay::SignalRelay(SignalProxy* parent, QObject* source) caller(source), _sync(false) { - QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()), Qt::DirectConnection); + QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender())); } int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { @@ -87,12 +90,12 @@ int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { // dispatch Sync Signal if necessary QByteArray signature(caller->metaObject()->method(_id).signature()); - if(synchronize() && proxy->syncMap(caller).contains(signature)) { - // qDebug() << "__SYNC__ >>>" - // << caller->metaObject()->className() - // << caller->objectName() - // << proxy->methodName(caller, _id) - // << params; + if(synchronize() && proxy->syncMap(qobject_cast(caller)).contains(signature)) { + //qDebug() << "__SYNC__ >>>" + // << caller->metaObject()->className() + // << caller->objectName() + // << signature + // << params; // params.prepend(QVariant(_id)); params.prepend(signature); params.prepend(caller->objectName()); @@ -125,13 +128,13 @@ void SignalRelay::setSynchronize(bool sync) { bool SignalRelay::isSyncMethod(int i) { QByteArray signature = caller->metaObject()->method(i).signature(); - if(!proxy->syncMap(caller).contains(signature)) + if(!proxy->syncMap(qobject_cast(caller)).contains(signature)) return false; - if(proxy->proxyMode() == SignalProxy::Server && !signature.startsWith("request")) + if(proxy->proxyMode() == SignalProxy::Server && !signature.contains("Requested")) return true; - if(proxy->proxyMode() == SignalProxy::Client && signature.startsWith("request")) + if(proxy->proxyMode() == SignalProxy::Client && signature.contains("Requested")) return true; return false; @@ -253,6 +256,7 @@ void SignalProxy::removePeerBySender() { // OK we're brutal here... but since it's a private slot we know what we've got connected to it... QIODevice *ioDev = (QIODevice *)(sender()); removePeer(ioDev); + qDebug() << "Client disconnected."; } void SignalProxy::objectRenamed(QString oldname, QString newname) { @@ -269,7 +273,6 @@ void SignalProxy::objectRenamed(QString oldname, QString newname) { } void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) { - QMutexLocker locker(&slaveMutex); if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); } @@ -334,10 +337,19 @@ const QList &SignalProxy::argTypes(QObject *obj, int methodId) { return _classInfo[obj->metaObject()]->argTypes[methodId]; } -bool SignalProxy::hasUpdateSignal(QObject *obj) { - if(!_classInfo.contains(obj->metaObject())) - return false; - return _classInfo[obj->metaObject()]->hasUpdateSignal; +void SignalProxy::setMinArgCount(QObject *obj, int methodId) { + const QMetaObject *meta = obj->metaObject(); + 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) { + Q_ASSERT(_classInfo.contains(obj->metaObject())); + if(!_classInfo[obj->metaObject()]->minArgCount.contains(methodId)) + setMinArgCount(obj, methodId); + return _classInfo[obj->metaObject()]->minArgCount[methodId]; } void SignalProxy::setMethodName(QObject *obj, int methodId) { @@ -355,7 +367,7 @@ const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { } -void SignalProxy::setSyncMap(QObject *obj) { +void SignalProxy::setSyncMap(SyncableObject *obj) { const QMetaObject *meta = obj->metaObject(); QHash syncMap; @@ -390,20 +402,31 @@ void SignalProxy::setSyncMap(QObject *obj) { _classInfo[meta]->syncMap = syncMap; } -const QHash &SignalProxy::syncMap(QObject *obj) { +const QHash &SignalProxy::syncMap(SyncableObject *obj) { Q_ASSERT(_classInfo.contains(obj->metaObject())); if(_classInfo[obj->metaObject()]->syncMap.isEmpty()) setSyncMap(obj); return _classInfo[obj->metaObject()]->syncMap; } +void SignalProxy::setUpdatedRemotelyId(QObject *obj) { + const QMetaObject *meta = obj->metaObject(); + Q_ASSERT(_classInfo.contains(meta)); + _classInfo[meta]->updatedRemotelyId = meta->indexOfSignal("updatedRemotely()"); +} + +int SignalProxy::updatedRemotelyId(SyncableObject *obj) { + Q_ASSERT(_classInfo.contains(obj->metaObject())); + return _classInfo[obj->metaObject()]->updatedRemotelyId; +} + void SignalProxy::createClassInfo(QObject *obj) { if(_classInfo.contains(obj->metaObject())) return; ClassInfo *classInfo = new ClassInfo(); - classInfo->hasUpdateSignal = (obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("updatedRemotely()")) != -1); _classInfo[obj->metaObject()] = classInfo; + setUpdatedRemotelyId(obj); } bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) { @@ -443,11 +466,11 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha _attachedSlots.insert(funcName, qMakePair(recv, methodId)); QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); - QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()), Qt::DirectConnection); + QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); return true; } -void SignalProxy::synchronize(QObject *obj) { +void SignalProxy::synchronize(SyncableObject *obj) { createClassInfo(obj); // attaching all the Signals @@ -465,7 +488,7 @@ void SignalProxy::synchronize(QObject *obj) { if(proxyMode() == Server) { if(obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1) - connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)), Qt::DirectConnection); + connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString))); setInitialized(obj); } else { @@ -473,19 +496,17 @@ void SignalProxy::synchronize(QObject *obj) { } } -void SignalProxy::setInitialized(QObject *obj) { - QMetaObject::invokeMethod(obj, "setInitialized"); +void SignalProxy::setInitialized(SyncableObject *obj) { + obj->setInitialized(); + emit objectInitialized(obj); } -bool SignalProxy::initialized(QObject *obj) { - bool init; - if(!QMetaObject::invokeMethod(obj, "initialized", Q_RETURN_ARG(bool, init))) - init = false; - return init; +bool SignalProxy::isInitialized(SyncableObject *obj) const { + return obj->isInitialized(); } -void SignalProxy::requestInit(QObject *obj) { - if(proxyMode() == Server || initialized(obj)) +void SignalProxy::requestInit(SyncableObject *obj) { + if(proxyMode() == Server || isInitialized(obj)) return; QVariantList params; @@ -495,46 +516,22 @@ void SignalProxy::requestInit(QObject *obj) { } void SignalProxy::detachSender() { - // this is a private slot. the reason for that is, that we enfoce Qt::DirectConnection. - // the result is, that we can be sure, that a registered receiver is removed immediately when it's destroyed. - // since we're guarding the the internal datastructures with mutexes this means, - // that the object destruction is deffered until we're finished delivering our sync/init/whatever request. - // all in all: thread safety! *sigh* detachObject(sender()); } -// detachObject/Signals/Slots() can be called as a result of an incoming call -// this might destroy our the iterator used for delivery -// thus we wrap the actual disconnection by using QueuedConnections void SignalProxy::detachObject(QObject* obj) { - QMutexLocker locker(&slaveMutex); - _detachSignals(obj); - _detachSlots(obj); - _stopSync(obj); + detachSignals(obj); + detachSlots(obj); + stopSync(static_cast(obj)); } void SignalProxy::detachSignals(QObject* sender) { - QMutexLocker locker(&slaveMutex); - _detachSignals(sender); -} - -void SignalProxy::detachSlots(QObject* receiver) { - QMutexLocker locker(&slaveMutex); - _detachSlots(receiver); -} - -void SignalProxy::stopSync(QObject* obj) { - QMutexLocker locker(&slaveMutex); - _stopSync(obj); -} - -void SignalProxy::_detachSignals(QObject* sender) { if(!_relayHash.contains(sender)) return; _relayHash.take(sender)->deleteLater(); } -void SignalProxy::_detachSlots(QObject* receiver) { +void SignalProxy::detachSlots(QObject* receiver) { SlotHash::iterator slotIter = _attachedSlots.begin(); while(slotIter != _attachedSlots.end()) { if(slotIter.value().first == receiver) { @@ -544,7 +541,7 @@ void SignalProxy::_detachSlots(QObject* receiver) { } } -void SignalProxy::_stopSync(QObject* obj) { +void SignalProxy::stopSync(SyncableObject* obj) { if(_relayHash.contains(obj)) _relayHash[obj]->setSynchronize(false); @@ -583,11 +580,6 @@ void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFun if(call.type() != QVariant::Int) return handleSignal(call.toByteArray(), params); - // well yes we are locking code here and not only data. - // otherwise each handler would have to lock the data anyway. this leaves us on the safe side - // unable to forget a lock - QMutexLocker locker(&slaveMutex); - switch(call.toInt()) { case Sync: return handleSync(params); @@ -617,7 +609,7 @@ void SignalProxy::handleSync(QVariantList params) { return; } - QObject *receiver = _syncSlave[className][objectName]; + SyncableObject *receiver = _syncSlave[className][objectName]; if(!syncMap(receiver).contains(signal)) { qWarning() << QString("no matching slot for sync call: %s::%s (objectName=\"%s\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) << params; @@ -629,8 +621,7 @@ void SignalProxy::handleSync(QVariantList params) { qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); return; } - if(hasUpdateSignal(receiver)) - QMetaObject::invokeMethod(receiver, "updatedRemotely"); + invokeSlot(receiver, updatedRemotelyId(receiver)); } void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶ms) { @@ -655,7 +646,7 @@ void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶m return; } - QObject *obj = _syncSlave[className][objectName]; + SyncableObject *obj = _syncSlave[className][objectName]; QVariantList params_; params_ << obj->metaObject()->className() @@ -668,7 +659,7 @@ void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList ¶m void SignalProxy::handleInitData(QIODevice *sender, const QVariantList ¶ms) { Q_UNUSED(sender) if(params.count() != 3) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:" + qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:" << params; return; } @@ -678,18 +669,18 @@ void SignalProxy::handleInitData(QIODevice *sender, const QVariantList ¶ms) QVariantMap propertyMap(params[2].toMap()); if(!_syncSlave.contains(className)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:" + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:" << className; return; } if(!_syncSlave[className].contains(objectName)) { - qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:" + qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:" << className << objectName; return; } - QObject *obj = _syncSlave[className][objectName]; + SyncableObject *obj = _syncSlave[className][objectName]; setInitData(obj, propertyMap); } @@ -707,11 +698,41 @@ void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &p } bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms) { - int numParams = argTypes(receiver, methodId).count(); - QGenericArgument args[9]; - for(int i = 0; i < numParams; i++) - args[i] = QGenericArgument(params[i].typeName(), params[i].constData()); - return QMetaObject::invokeMethod(receiver, methodName(receiver, methodId), args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]); + const QList args = argTypes(receiver, 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); + 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}; + // check for argument compatibility and build params array + for(int i = 0; i < numArgs; i++) { + if(args[i] != QMetaType::type(params[i].typeName())) { + qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << methodName(receiver, methodId); + return false; + } + _a[i+1] = const_cast(params[i].constData()); + } + + + Qt::ConnectionType type = QThread::currentThread() == receiver->thread() + ? Qt::DirectConnection + : Qt::QueuedConnection; + + if (type == Qt::DirectConnection) { + return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0; + } else { + qWarning() << "Queued Connections are not implemented yet"; + // not to self: qmetaobject.cpp:990 ff + return false; + } + } void SignalProxy::dataAvailable() { @@ -788,62 +809,16 @@ QString SignalProxy::methodBaseName(const QMetaMethod &method) { return methodname; } -QVariantMap SignalProxy::initData(QObject *obj) const { - QVariantMap properties; - - const QMetaObject* meta = obj->metaObject(); - - // we collect data from properties - for(int i = 0; i < meta->propertyCount(); i++) { - QMetaProperty prop = meta->property(i); - properties[QString(prop.name())] = prop.read(obj); - } - - // ...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)); - if(!methodname.startsWith("init") || methodname.startsWith("initSet")) - continue; - - QVariant value = QVariant(QVariant::nameToType(method.typeName())); - QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value); - QMetaObject::invokeMethod(obj, methodname.toAscii(), genericvalue); - - properties[methodBaseName(method)] = value; - // qDebug() << ">>> SYNC:" << methodBaseName(method) << value; - } - - // properties["Payload"] = QByteArray(10000000, 'a'); // for testing purposes - return properties; +QVariantMap SignalProxy::initData(SyncableObject *obj) const { + return obj->toVariantMap(); } -void SignalProxy::setInitData(QObject *obj, const QVariantMap &properties) { - if(initialized(obj)) +void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties) { + if(isInitialized(obj)) return; - - const QMetaObject *meta = obj->metaObject(); - - QVariantMap::const_iterator iterator = properties.constBegin(); - while(iterator != properties.constEnd()) { - QString name = iterator.key(); - int propertyIndex = meta->indexOfProperty(name.toAscii()); - - if(propertyIndex == -1 || !meta->property(propertyIndex).isWritable()) - setInitValue(obj, name, iterator.value()); - else - obj->setProperty(name.toAscii(), iterator.value()); - // qDebug() << "<<< SYNC:" << name << iterator.value(); - iterator++; - } + obj->fromVariantMap(properties); setInitialized(obj); -} - -bool SignalProxy::setInitValue(QObject *obj, const QString &property, const QVariant &value) { - QString handlername = QString("initSet") + property; - handlername[7] = handlername[7].toUpper(); - QGenericArgument param(value.typeName(), value.constData()); - return QMetaObject::invokeMethod(obj, handlername.toAscii(), param); + invokeSlot(obj, updatedRemotelyId(obj)); } void SignalProxy::dumpProxyStats() { @@ -870,7 +845,7 @@ void SignalProxy::dumpProxyStats() { qDebug() << "number of Classes cached:" << _classInfo.count(); } -void SignalProxy::dumpSyncMap(QObject *object) { +void SignalProxy::dumpSyncMap(SyncableObject *object) { const QMetaObject *meta = object->metaObject(); qDebug() << "SignalProxy: SyncMap for Class" << meta->className();