src/common/signalproxy.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "signalproxy.h"
  22
  23 #include <QObject>
  24 #include <QIODevice>
  25 #include <QAbstractSocket>
  26 #include <QHostAddress>
  27 #include <QHash>
  28 #include <QMultiHash>
  29 #include <QList>
  30 #include <QSet>
  31 #include <QDebug>
  32 #include <QMetaMethod>
  33 #include <QMetaProperty>
  34 #include <QRegExp>
  35 #ifdef HAVE_SSL
  36 #include <QSslSocket>
  37 #endif
  38 #include <QThread>
  39 #include <QTime>
  40 #include <QEvent>
  41 #include <QCoreApplication>
  42
  43 #include "syncableobject.h"
  44 #include "util.h"
  45
  46 // ==================================================
  47 //  PeerSignalEvent
  48 // ==================================================
  49 class PeerSignalEvent : public QEvent {
  50 public:
  51   PeerSignalEvent(SignalProxy *sender, SignalProxy::RequestType requestType, const QVariantList &params) : QEvent(QEvent::Type(SignalProxy::PeerSignal)), sender(sender), requestType(requestType), params(params) {}
  52   SignalProxy *sender;
  53   SignalProxy::RequestType requestType;
  54   QVariantList params;
  55 };
  56
  57 class RemovePeerEvent : public QEvent {
  58 public:
  59   RemovePeerEvent(QObject *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeer)), peer(peer) {}
  60   QObject *peer;
  61 };
  62
  63 // ==================================================
  64 //  SignalRelay
  65 // ==================================================
  66 class SignalProxy::SignalRelay : public QObject {
  67 /* Q_OBJECT is not necessary or even allowed, because we implement
  68    qt_metacall ourselves (and don't use any other features of the meta
  69    object system)
  70 */
  71 public:
  72   SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {}
  73   inline SignalProxy *proxy() const { return _proxy; }
  74
  75   int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
  76
  77   void attachSignal(QObject *sender, int signalId, const QByteArray &funcName);
  78   void detachSignal(QObject *sender, int signalId = -1);
  79
  80 private:
  81   struct Signal {
  82     QObject *sender;
  83     int signalId;
  84     QByteArray signature;
  85     Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {}
  86     Signal() : sender(0), signalId(-1) {}
  87   };
  88
  89   SignalProxy *_proxy;
  90   QHash<int, Signal> _slots;
  91 };
  92
  93 void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const QByteArray &funcName) {
  94   // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
  95   // all connected methodIds are offset by the standard methodCount of QObject
  96   int slotId;
  97   for(int i = 0;; i++) {
  98     if(!_slots.contains(i)) {
  99       slotId = i;
 100       break;
 101     }
 102   }
 103
 104   QByteArray fn;
 105   if(!funcName.isEmpty()) {
 106     fn = QMetaObject::normalizedSignature(funcName);
 107   } else {
 108     fn = SIGNAL(fakeMethodSignature());
 109     fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature());
 110   }
 111
 112   _slots[slotId] = Signal(sender, signalId, fn);
 113
 114   QMetaObject::connect(sender, signalId, this, QObject::staticMetaObject.methodCount() + slotId);
 115 }
 116
 117 void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId) {
 118   QHash<int, Signal>::iterator slotIter = _slots.begin();
 119   while(slotIter != _slots.end()) {
 120     if(slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) {
 121       slotIter = _slots.erase(slotIter);
 122       if(signalId != -1)
 123         break;
 124     } else {
 125       slotIter++;
 126     }
 127   }
 128 }
 129
 130 int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
 131   _id = QObject::qt_metacall(_c, _id, _a);
 132   if(_id < 0)
 133     return _id;
 134
 135   if(_c == QMetaObject::InvokeMetaMethod) {
 136     if(_slots.contains(_id)) {
 137       QObject *caller = sender();
 138
 139       SignalProxy::ExtendedMetaObject *eMeta = proxy()->extendedMetaObject(caller->metaObject());
 140       Q_ASSERT(eMeta);
 141
 142       const Signal &signal = _slots[_id];
 143
 144       QVariantList params;
 145       params << signal.signature;
 146
 147       const QList<int> &argTypes = eMeta->argTypes(signal.signalId);
 148       for(int i = 0; i < argTypes.size(); i++) {
 149         if(argTypes[i] == 0) {
 150           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());
 151           qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
 152           return _id;
 153         }
 154         params << QVariant(argTypes[i], _a[i+1]);
 155       }
 156
 157       proxy()->dispatchSignal(SignalProxy::RpcCall, params);
 158     }
 159     _id -= _slots.count();
 160   }
 161   return _id;
 162 }
 163
 164 // ==================================================
 165 //  Peers
 166 // ==================================================
 167 void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList &params) {
 168   QVariantList packedFunc;
 169   packedFunc << (qint16)requestType
 170              << params;
 171   dispatchPackedFunc(QVariant(packedFunc));
 172 }
 173
 174 bool SignalProxy::IODevicePeer::isSecure() const {
 175 #ifdef HAVE_SSL
 176   QSslSocket *sslSocket = qobject_cast<QSslSocket *>(_device);
 177   if(sslSocket)
 178     return sslSocket->isEncrypted() || sslSocket->localAddress() == QHostAddress::LocalHost || sslSocket->localAddress() == QHostAddress::LocalHostIPv6;
 179 #endif
 180
 181   QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device);
 182   if(socket)
 183     return socket->localAddress() == QHostAddress::LocalHost || socket->localAddress() == QHostAddress::LocalHostIPv6;
 184
 185   return false;
 186 }
 187
 188 QString SignalProxy::IODevicePeer::address() const {
 189   QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device);
 190   if(socket)
 191     return socket->peerAddress().toString();
 192   else
 193     return QString();
 194 }
 195
 196 void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType, const QVariantList &params) {
 197   Qt::ConnectionType type = QThread::currentThread() == receiver->thread()
 198     ? Qt::DirectConnection
 199     : Qt::QueuedConnection;
 200
 201   if(type == Qt::DirectConnection) {
 202     receiver->receivePeerSignal(sender, requestType, params);
 203   } else {
 204     QCoreApplication::postEvent(receiver, new PeerSignalEvent(sender, requestType, params));
 205   }
 206 }
 207
 208 // ==================================================
 209 //  SignalProxy
 210 // ==================================================
 211 SignalProxy::SignalProxy(QObject* parent)
 212   : QObject(parent)
 213 {
 214   setProxyMode(Client);
 215   init();
 216 }
 217
 218 SignalProxy::SignalProxy(ProxyMode mode, QObject* parent)
 219   : QObject(parent)
 220 {
 221   setProxyMode(mode);
 222   init();
 223 }
 224
 225 SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent)
 226   : QObject(parent)
 227 {
 228   setProxyMode(mode);
 229   addPeer(device);
 230   init();
 231 }
 232
 233 SignalProxy::~SignalProxy() {
 234   removeAllPeers();
 235 }
 236
 237 void SignalProxy::setProxyMode(ProxyMode mode) {
 238   PeerHash::iterator peer = _peers.begin();
 239   while(peer != _peers.end()) {
 240     if((*peer)->type() != AbstractPeer::IODevicePeer) {
 241       IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
 242       if(ioPeer->isOpen()) {
 243         qWarning() << "SignalProxy: Cannot change proxy mode while connected";
 244         return;
 245       }
 246     }
 247     if((*peer)->type() != AbstractPeer::SignalProxyPeer) {
 248       qWarning() << "SignalProxy: Cannot change proxy mode while connected to another internal SignalProxy";
 249       return;
 250     }
 251     peer++;
 252   }
 253
 254   _proxyMode = mode;
 255   if(mode == Server)
 256     initServer();
 257   else
 258     initClient();
 259 }
 260
 261 void SignalProxy::init() {
 262   _signalRelay = new SignalRelay(this);
 263   connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat()));
 264   _heartBeatTimer.start(30 * 1000);
 265   _secure = false;
 266   updateSecureState();
 267 }
 268
 269 void SignalProxy::initServer() {
 270 }
 271
 272 void SignalProxy::initClient() {
 273   attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString)));
 274 }
 275
 276 bool SignalProxy::addPeer(QIODevice* iodev) {
 277   if(!iodev)
 278     return false;
 279
 280   if(_peers.contains(iodev))
 281     return true;
 282
 283   if(proxyMode() == Client && !_peers.isEmpty()) {
 284     qWarning("SignalProxy: only one peer allowed in client mode!");
 285     return false;
 286   }
 287
 288   if(!iodev->isOpen()) {
 289     qWarning("SignalProxy::addPeer(QIODevice *iodev): iodev needs to be open!");
 290     return false;
 291   }
 292
 293   connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
 294   connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
 295
 296 #ifdef HAVE_SSL
 297   QSslSocket *sslSocket = qobject_cast<QSslSocket *>(iodev);
 298   if(sslSocket) {
 299     connect(iodev, SIGNAL(encrypted()), this, SLOT(updateSecureState()));
 300   }
 301 #endif
 302
 303   if(!iodev->parent())
 304     iodev->setParent(this);
 305
 306   _peers[iodev] = new IODevicePeer(iodev, iodev->property("UseCompression").toBool());
 307
 308   if(_peers.count() == 1)
 309     emit connected();
 310
 311   updateSecureState();
 312   return true;
 313 }
 314
 315 bool SignalProxy::addPeer(SignalProxy* proxy) {
 316   if(!proxy)
 317     return false;
 318
 319   if(proxyMode() == proxy->proxyMode()) {
 320     qWarning() << "SignalProxy::addPeer(): adding a SignalProxy as peer requires one proxy to be server and one client!";
 321     return false;
 322   }
 323
 324   if(_peers.contains(proxy)) {
 325     return true;
 326   }
 327
 328   if(proxyMode() == Client && !_peers.isEmpty()) {
 329     qWarning("SignalProxy: only one peer allowed in client mode!");
 330     return false;
 331   }
 332
 333   _peers[proxy] = new SignalProxyPeer(this, proxy);
 334   proxy->addPeer(this);
 335
 336   if(_peers.count() == 1)
 337     emit connected();
 338
 339   updateSecureState();
 340   return true;
 341 }
 342
 343 void SignalProxy::removeAllPeers() {
 344   Q_ASSERT(proxyMode() == Server || _peers.count() <= 1);
 345   // wee need to copy that list since we modify it in the loop
 346   QList<QObject *> peers = _peers.keys();
 347   foreach(QObject *peer, peers) {
 348     removePeer(peer);
 349   }
 350 }
 351
 352 void SignalProxy::removePeer(QObject* dev) {
 353   if(_peers.isEmpty()) {
 354     qWarning() << "SignalProxy::removePeer(): No peers in use!";
 355     return;
 356   }
 357
 358   Q_ASSERT(dev);
 359   if(!_peers.contains(dev)) {
 360     qWarning() << "SignalProxy: unknown Peer" << dev;
 361     return;
 362   }
 363
 364   AbstractPeer *peer = _peers[dev];
 365   _peers.remove(dev);
 366
 367   disconnect(dev, 0, this, 0);
 368   if(peer->type() == AbstractPeer::IODevicePeer)
 369     emit peerRemoved(static_cast<QIODevice *>(dev));
 370
 371   if(peer->type() == AbstractPeer::SignalProxyPeer) {
 372     SignalProxy *proxy = static_cast<SignalProxy *>(dev);
 373     if(proxy->_peers.contains(this))
 374       proxy->removePeer(this);
 375   }
 376
 377   if(dev->parent() == this)
 378     dev->deleteLater();
 379
 380   delete peer;
 381
 382   updateSecureState();
 383
 384   if(_peers.isEmpty())
 385     emit disconnected();
 386 }
 387
 388 void SignalProxy::removePeerBySender() {
 389   removePeer(sender());
 390 }
 391
 392 void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) {
 393   SyncableObject *syncObject = qobject_cast<SyncableObject *>(sender());
 394   const QMetaObject *meta = syncObject->syncMetaObject();
 395   const QByteArray className(meta->className());
 396   objectRenamed(className, newname, oldname);
 397
 398   if(proxyMode() == Client)
 399     return;
 400
 401   QVariantList params;
 402   params << "__objectRenamed__" << className << newname << oldname;
 403   dispatchSignal(RpcCall, params);
 404 }
 405
 406 void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname) {
 407   if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) {
 408     SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
 409     requestInit(obj);
 410   }
 411 }
 412
 413 const QMetaObject *SignalProxy::metaObject(const QObject *obj) {
 414   if(const SyncableObject *syncObject = qobject_cast<const SyncableObject *>(obj))
 415     return syncObject->syncMetaObject();
 416   else
 417     return obj->metaObject();
 418 }
 419
 420 SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObject *meta) const {
 421   if(_extendedMetaObjects.contains(meta))
 422     return _extendedMetaObjects[meta];
 423   else
 424     return 0;
 425 }
 426
 427 SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta) {
 428   if(!_extendedMetaObjects.contains(meta)) {
 429     _extendedMetaObjects[meta] = new ExtendedMetaObject(meta);
 430   }
 431   return _extendedMetaObjects[meta];
 432 }
 433
 434 bool SignalProxy::attachSignal(QObject *sender, const char* signal, const QByteArray& sigName) {
 435   const QMetaObject* meta = sender->metaObject();
 436   QByteArray sig(meta->normalizedSignature(signal).mid(1));
 437   int methodId = meta->indexOfMethod(sig.constData());
 438   if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
 439     qWarning() << "SignalProxy::attachSignal(): No such signal" << signal;
 440     return false;
 441   }
 442
 443   createExtendedMetaObject(meta);
 444   _signalRelay->attachSignal(sender, methodId, sigName);
 445
 446   disconnect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 447   connect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 448   return true;
 449 }
 450
 451 bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) {
 452   const QMetaObject* meta = recv->metaObject();
 453   int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
 454   if(methodId == -1 || meta->method(methodId).methodType() == QMetaMethod::Method) {
 455     qWarning() << "SignalProxy::attachSlot(): No such slot" << slot;
 456     return false;
 457   }
 458
 459   createExtendedMetaObject(meta);
 460
 461   QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
 462   _attachedSlots.insert(funcName, qMakePair(recv, methodId));
 463
 464   disconnect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 465   connect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 466   return true;
 467 }
 468
 469 void SignalProxy::synchronize(SyncableObject *obj) {
 470   createExtendedMetaObject(obj);
 471
 472   // attaching as slave to receive sync Calls
 473   QByteArray className(obj->syncMetaObject()->className());
 474   _syncSlave[className][obj->objectName()] = obj;
 475   disconnect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 476   connect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
 477
 478   if(proxyMode() == Server) {
 479     connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
 480     obj->setInitialized();
 481     emit objectInitialized(obj);
 482   } else {
 483     if(obj->isInitialized())
 484       emit objectInitialized(obj);
 485     else
 486       requestInit(obj);
 487   }
 488
 489   obj->synchronize(this);
 490 }
 491
 492 void SignalProxy::detachObject(QObject *obj) {
 493   stopSync(obj);
 494   detachSignals(obj);
 495   detachSlots(obj);
 496 }
 497
 498 void SignalProxy::detachSignals(QObject *sender) {
 499   _signalRelay->detachSignal(sender);
 500 }
 501
 502 void SignalProxy::detachSlots(QObject* receiver) {
 503   SlotHash::iterator slotIter = _attachedSlots.begin();
 504   while(slotIter != _attachedSlots.end()) {
 505     if(slotIter.value().first == receiver) {
 506       slotIter = _attachedSlots.erase(slotIter);
 507     } else
 508       slotIter++;
 509   }
 510 }
 511
 512 void SignalProxy::stopSync(QObject *obj) {
 513   // we can't use a className here, since it might be effed up, if we receive the call as a result of a decon
 514   // gladly the objectName() is still valid. So we have only to iterate over the classes not each instance! *sigh*
 515   QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
 516   while(classIter != _syncSlave.end()) {
 517     if(classIter->contains(obj->objectName()) && classIter.value()[obj->objectName()] == obj) {
 518       classIter->remove(obj->objectName());
 519       break;
 520     }
 521     classIter++;
 522   }
 523 }
 524
 525 void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList &params) {
 526   QVariant packedFunc(QVariantList() << (qint16)requestType << params);
 527   PeerHash::iterator peer = _peers.begin();
 528   while(peer != _peers.end()) {
 529     switch((*peer)->type()) {
 530     case AbstractPeer::IODevicePeer:
 531       {
 532         IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
 533         if(ioPeer->isOpen())
 534           ioPeer->dispatchPackedFunc(packedFunc);
 535         else
 536           QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
 537       }
 538       break;
 539     case AbstractPeer::SignalProxyPeer:
 540       (*peer)->dispatchSignal(requestType, params);
 541       break;
 542     default:
 543       Q_ASSERT(false); // there shouldn't be any peers with wrong / unknown type
 544     }
 545     peer++;
 546   }
 547 }
 548
 549 void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packedFunc) {
 550   QVariantList params(packedFunc.toList());
 551
 552   if(params.isEmpty()) {
 553     qWarning() << "SignalProxy::receivePeerSignal(): received incompatible Data:" << packedFunc;
 554     return;
 555   }
 556
 557   RequestType requestType = (RequestType)params.takeFirst().value<int>();
 558   receivePeerSignal(sender, requestType, params);
 559 }
 560
 561 void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList &params) {
 562   switch(requestType) {
 563     // list all RequestTypes that shouldnot trigger a heartbeat counter reset here
 564   case HeartBeatReply:
 565     break;
 566   default:
 567     if(sender->type() == AbstractPeer::IODevicePeer) {
 568       IODevicePeer *ioPeer = static_cast<IODevicePeer *>(sender);
 569       ioPeer->sentHeartBeats = 0;
 570     }
 571   }
 572
 573   switch(requestType) {
 574   case RpcCall:
 575     if(params.empty())
 576       qWarning() << "SignalProxy::receivePeerSignal(): received empty RPC-Call";
 577     else
 578       handleSignal(params);
 579       //handleSignal(params.takeFirst().toByteArray(), params);
 580     break;
 581
 582   case Sync:
 583     handleSync(sender, params);
 584     break;
 585
 586   case InitRequest:
 587     handleInitRequest(sender, params);
 588     break;
 589
 590   case InitData:
 591     handleInitData(sender, params);
 592     break;
 593
 594   case HeartBeat:
 595     receiveHeartBeat(sender, params);
 596     break;
 597
 598   case HeartBeatReply:
 599     receiveHeartBeatReply(sender, params);
 600     break;
 601
 602   default:
 603     qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << requestType << params;
 604   }
 605 }
 606
 607 void SignalProxy::receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList &params) {
 608   if(!_peers.contains(sender)) {
 609     // 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.
 610     qWarning() << "SignalProxy::receivePeerSignal(): received Signal from unknown Proxy" << reinterpret_cast<void *>(sender);
 611     return;
 612   }
 613   receivePeerSignal(_peers[sender], requestType, params);
 614 }
 615
 616 void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) {
 617   if(params.count() < 3) {
 618     qWarning() << "received invalid Sync call" << params;
 619     return;
 620   }
 621
 622   QByteArray className = params.takeFirst().toByteArray();
 623   QString objectName = params.takeFirst().toString();
 624   QByteArray signal = params.takeFirst().toByteArray();
 625
 626   if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
 627     qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName)
 628                << params;
 629     return;
 630   }
 631
 632   SyncableObject *receiver = _syncSlave[className][objectName];
 633   ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
 634   if(!eMeta->syncMap().contains(signal)) {
 635     qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName)
 636                << params;
 637     return;
 638   }
 639
 640   int slotId = eMeta->syncMap()[signal];
 641
 642   QVariant returnValue((QVariant::Type)eMeta->returnType(slotId));
 643   if(!invokeSlot(receiver, slotId, params, returnValue)) {
 644     qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData());
 645     return;
 646   }
 647
 648   if(returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) {
 649     int receiverId = eMeta->receiveMap()[slotId];
 650     QVariantList returnParams;
 651     returnParams << className
 652                  << objectName
 653                  << QByteArray(receiver->metaObject()->method(receiverId).signature());
 654     if(eMeta->argTypes(receiverId).count() > 1)
 655       returnParams << params;
 656     returnParams << returnValue;
 657     sender->dispatchSignal(Sync, returnParams);
 658   }
 659
 660   // send emit update signal
 661   invokeSlot(receiver, eMeta->updatedRemotelyId());
 662 }
 663
 664 void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &params) {
 665   if(params.count() != 2) {
 666     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
 667                << params;
 668     return;
 669   }
 670
 671   QByteArray className(params[0].toByteArray());
 672   QString objectName(params[1].toString());
 673
 674   if(!_syncSlave.contains(className)) {
 675     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
 676                << className;
 677     return;
 678   }
 679
 680   if(!_syncSlave[className].contains(objectName)) {
 681     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
 682                << className << objectName;
 683     return;
 684   }
 685
 686   SyncableObject *obj = _syncSlave[className][objectName];
 687
 688   QVariantList params_;
 689   params_ << className
 690           << objectName
 691           << initData(obj);
 692
 693   sender->dispatchSignal(InitData, params_);
 694 }
 695
 696 void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList &params) {
 697   Q_UNUSED(sender)
 698   if(params.count() != 3) {
 699     qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:"
 700                << params;
 701     return;
 702   }
 703
 704   QByteArray className(params[0].toByteArray());
 705   QString objectName(params[1].toString());
 706   QVariantMap propertyMap(params[2].toMap());
 707
 708   if(!_syncSlave.contains(className)) {
 709     qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
 710                << className;
 711     return;
 712   }
 713
 714   if(!_syncSlave[className].contains(objectName)) {
 715     qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
 716                << className << objectName;
 717     return;
 718   }
 719
 720   SyncableObject *obj = _syncSlave[className][objectName];
 721   setInitData(obj, propertyMap);
 722 }
 723
 724 //void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &params) {
 725 void SignalProxy::handleSignal(const QVariantList &data) {
 726   QVariantList params = data;
 727   QByteArray funcName = params.takeFirst().toByteArray();
 728
 729   QObject* receiver;
 730   int methodId;
 731   SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
 732   while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
 733     receiver = (*slot).first;
 734     methodId = (*slot).second;
 735     if(!invokeSlot(receiver, methodId, params)) {
 736       ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
 737       qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData());
 738     }
 739     slot++;
 740   }
 741 }
 742
 743 bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue) {
 744   ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
 745   const QList<int> args = eMeta->argTypes(methodId);
 746   const int numArgs = params.count() < args.count()
 747     ? params.count()
 748     : args.count();
 749
 750   if(eMeta->minArgCount(methodId) > params.count()) {
 751       qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId);
 752       return false;
 753   }
 754
 755   void *_a[] = {0,              // return type...
 756                 0, 0, 0, 0 , 0, // and 10 args - that's the max size qt can handle with signals and slots
 757                 0, 0, 0, 0 , 0};
 758
 759   // check for argument compatibility and build params array
 760   for(int i = 0; i < numArgs; i++) {
 761     if(!params[i].isValid()) {
 762       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());
 763       qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
 764       return false;
 765     }
 766     if(args[i] != QMetaType::type(params[i].typeName())) {
 767       qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
 768       return false;
 769     }
 770     _a[i+1] = const_cast<void *>(params[i].constData());
 771   }
 772
 773   if(returnValue.type() != QVariant::Invalid)
 774     _a[0] = const_cast<void *>(returnValue.constData());
 775
 776   Qt::ConnectionType type = QThread::currentThread() == receiver->thread()
 777     ? Qt::DirectConnection
 778     : Qt::QueuedConnection;
 779
 780   if(type == Qt::DirectConnection) {
 781     return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
 782   } else {
 783     qWarning() << "Queued Connections are not implemented yet";
 784     // note to self: qmetaobject.cpp:990 ff
 785     return false;
 786   }
 787
 788 }
 789
 790 bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params) {
 791   QVariant ret;
 792   return invokeSlot(receiver, methodId, params, ret);
 793 }
 794
 795 void SignalProxy::dataAvailable() {
 796   // yet again. it's a private slot. no need for checks.
 797   QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
 798   Q_ASSERT(_peers.contains(ioDev) && _peers[ioDev]->type() == AbstractPeer::IODevicePeer);
 799   IODevicePeer *peer = static_cast<IODevicePeer *>(_peers[ioDev]);
 800   QVariant var;
 801   while(peer->readData(var))
 802     receivePackedFunc(peer, var);
 803 }
 804
 805 void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool compressed) {
 806   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(dev);
 807   if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) {
 808     qWarning("SignalProxy: Can't call write on a closed device");
 809     return;
 810   }
 811
 812   QByteArray block;
 813   QDataStream out(&block, QIODevice::WriteOnly);
 814   out.setVersion(QDataStream::Qt_4_2);
 815   out << (quint32)0;
 816
 817   if(compressed) {
 818     QByteArray rawItem;
 819     QDataStream itemStream(&rawItem, QIODevice::WriteOnly);
 820
 821     itemStream.setVersion(QDataStream::Qt_4_2);
 822     itemStream << item;
 823
 824     rawItem = qCompress(rawItem);
 825
 826     out << rawItem;
 827   } else {
 828     out << item;
 829   }
 830
 831   out.device()->seek(0);
 832   out << (quint32)(block.size() - sizeof(quint32));
 833
 834   dev->write(block);
 835 }
 836
 837 bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) {
 838   if(!dev)
 839     return false;
 840
 841   QDataStream in(dev);
 842   in.setVersion(QDataStream::Qt_4_2);
 843
 844   if(blockSize == 0) {
 845     if(dev->bytesAvailable() < (int)sizeof(quint32)) return false;
 846     in >> blockSize;
 847   }
 848
 849   if(blockSize > 1 << 22) {
 850     disconnectDevice(dev, tr("Peer tried to send package larger than max package size!"));
 851     return false;
 852   }
 853
 854   if(blockSize == 0) {
 855     disconnectDevice(dev, tr("Peer tried to send 0 byte package!"));
 856     return false;
 857   }
 858
 859   if(dev->bytesAvailable() < blockSize)
 860     return false;
 861
 862   blockSize = 0;
 863
 864   if(compressed) {
 865     QByteArray rawItem;
 866     in >> rawItem;
 867
 868     int nbytes = rawItem.size();
 869     if(nbytes <= 4) {
 870       const char *data = rawItem.constData();
 871       if(nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) {
 872         disconnectDevice(dev, tr("Peer sent corrupted compressed data!"));
 873         return false;
 874       }
 875     }
 876
 877     rawItem = qUncompress(rawItem);
 878
 879     QDataStream itemStream(&rawItem, QIODevice::ReadOnly);
 880     itemStream.setVersion(QDataStream::Qt_4_2);
 881     itemStream >> item;
 882   } else {
 883     in >> item;
 884   }
 885
 886   if(!item.isValid()) {
 887     disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!"));
 888     return false;
 889   }
 890
 891   return true;
 892 }
 893
 894 void SignalProxy::requestInit(SyncableObject *obj) {
 895   if(proxyMode() == Server || obj->isInitialized())
 896     return;
 897
 898   QVariantList params;
 899   params << obj->syncMetaObject()->className()
 900          << obj->objectName();
 901   dispatchSignal(InitRequest, params);
 902 }
 903
 904 QVariantMap SignalProxy::initData(SyncableObject *obj) const {
 905   return obj->toVariantMap();
 906 }
 907
 908 void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties) {
 909   if(obj->isInitialized())
 910     return;
 911   obj->fromVariantMap(properties);
 912   obj->setInitialized();
 913   emit objectInitialized(obj);
 914   invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId());
 915 }
 916
 917 void SignalProxy::sendHeartBeat() {
 918   QVariantList heartBeatParams;
 919   heartBeatParams << QTime::currentTime();
 920   PeerHash::iterator peer = _peers.begin();
 921   while(peer != _peers.end()) {
 922     if((*peer)->type() == AbstractPeer::IODevicePeer) {
 923       IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
 924       ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams);
 925       if(ioPeer->sentHeartBeats > 0) {
 926         updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
 927       }
 928       if(ioPeer->sentHeartBeats > 1) {
 929         qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
 930                    << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)";
 931         ioPeer->close();
 932       } else {
 933         ioPeer->sentHeartBeats++;
 934       }
 935     }
 936     peer++;
 937   }
 938 }
 939
 940 void SignalProxy::receiveHeartBeat(AbstractPeer *peer, const QVariantList &params) {
 941   peer->dispatchSignal(SignalProxy::HeartBeatReply, params);
 942 }
 943
 944 void SignalProxy::receiveHeartBeatReply(AbstractPeer *peer, const QVariantList &params) {
 945   if(peer->type() != AbstractPeer::IODevicePeer) {
 946     qWarning() << "SignalProxy::receiveHeartBeatReply: received heart beat from a non IODevicePeer!";
 947     return;
 948   }
 949
 950   IODevicePeer *ioPeer = static_cast<IODevicePeer *>(peer);
 951   ioPeer->sentHeartBeats = 0;
 952
 953   if(params.isEmpty()) {
 954     qWarning() << "SignalProxy: received heart beat reply with less params then sent from:" << ioPeer->address();
 955     return;
 956   }
 957
 958   QTime sendTime = params[0].value<QTime>();
 959   updateLag(ioPeer, sendTime.msecsTo(QTime::currentTime()) / 2);
 960 }
 961
 962 void SignalProxy::customEvent(QEvent *event) {
 963   switch(event->type()) {
 964   case PeerSignal:
 965     {
 966       PeerSignalEvent *e = static_cast<PeerSignalEvent *>(event);
 967       receivePeerSignal(e->sender, e->requestType, e->params);
 968     }
 969     event->accept();
 970     break;
 971   case RemovePeer:
 972     {
 973       RemovePeerEvent *e = static_cast<RemovePeerEvent *>(event);
 974       removePeer(e->peer);
 975     }
 976     event->accept();
 977   default:
 978     return;
 979   }
 980 }
 981
 982 void SignalProxy::syncCall(const SyncableObject *obj, SignalProxy::ProxyMode modeType, const char *funcname, va_list ap) {
 983   if(modeType != _proxyMode)
 984     return;
 985
 986   ExtendedMetaObject *eMeta = extendedMetaObject(obj);
 987
 988   QVariantList params;
 989
 990   params << eMeta->metaObject()->className()
 991          << obj->objectName()
 992          << QByteArray(funcname);
 993
 994
 995   const QList<int> &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname)));
 996
 997   for(int i = 0; i < argTypes.size(); i++) {
 998     if(argTypes[i] == 0) {
 999       qWarning() << Q_FUNC_INFO << "received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(eMeta->metaObject()->className()).arg(funcname);
1000       qWarning() << "        - make sure all your data types are known by the Qt MetaSystem";
1001       return;
1002     }
1003     params << QVariant(argTypes[i], va_arg(ap, void *));
1004   }
1005 }
1006
1007 void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) {
1008   if(!reason.isEmpty())
1009     qWarning() << qPrintable(reason);
1010   QAbstractSocket *sock  = qobject_cast<QAbstractSocket *>(dev);
1011   if(sock)
1012     qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString());
1013   dev->close();
1014 }
1015
1016 void SignalProxy::updateLag(IODevicePeer *peer, int lag) {
1017   peer->lag = lag;
1018   if(proxyMode() == Client) {
1019     emit lagUpdated(lag);
1020   }
1021 }
1022
1023 void SignalProxy::dumpProxyStats() {
1024   QString mode;
1025   if(proxyMode() == Server)
1026     mode = "Server";
1027   else
1028     mode = "Client";
1029
1030   int slaveCount = 0;
1031   foreach(ObjectId oid, _syncSlave.values())
1032     slaveCount += oid.count();
1033
1034   qDebug() << this;
1035   qDebug() << "              Proxy Mode:" << mode;
1036   qDebug() << "          attached Slots:" << _attachedSlots.count();
1037   qDebug() << " number of synced Slaves:" << slaveCount;
1038   qDebug() << "number of Classes cached:" << _extendedMetaObjects.count();
1039 }
1040
1041 void SignalProxy::dumpSyncMap(SyncableObject *object) {
1042   const QMetaObject *meta = object->metaObject();
1043   ExtendedMetaObject *eMeta = extendedMetaObject(object);
1044   qDebug() << "SignalProxy: SyncMap for Class" << meta->className();
1045
1046   QHash<QByteArray, int> syncMap_ = eMeta->syncMap();
1047   QHash<QByteArray, int>::const_iterator iter = syncMap_.constBegin();
1048   while(iter != syncMap_.constEnd()) {
1049     qDebug() << qPrintable(QString("%1 --> %2 %3").arg(QString(iter.key()), 40).arg(iter.value()).arg(QString(meta->method(iter.value()).signature())));
1050     iter++;
1051   }
1052 }
1053
1054 void SignalProxy::updateSecureState() {
1055   bool wasSecure = _secure;
1056
1057   _secure = !_peers.isEmpty();
1058   PeerHash::const_iterator peerIter;
1059   for(peerIter = _peers.constBegin(); peerIter != _peers.constEnd(); peerIter++) {
1060     _secure &= (*peerIter)->isSecure();
1061   }
1062
1063   if(wasSecure != _secure)
1064     emit secureStateChanged(_secure);
1065 }
1066
1067
1068 // ==================================================
1069 //  ExtendedMetaObject
1070 // ==================================================
1071 SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta)
1072   : _meta(meta),
1073     _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
1074 {
1075 }
1076
1077 const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId) {
1078   if(!_methods.contains(methodId)) {
1079     _methods[methodId] = MethodDescriptor(_meta->method(methodId));
1080   }
1081   return _methods[methodId];
1082 }
1083
1084 int SignalProxy::ExtendedMetaObject::methodId(const QByteArray &methodName) {
1085   if(_methodIds.contains(methodName)) {
1086     return _methodIds[methodName];
1087   } else {
1088     for(int i = _meta->methodOffset(); i < _meta->methodCount(); i++) {
1089       if(ExtendedMetaObject::methodName(_meta->method(i)) == methodName) {
1090         _methodIds[methodName] = i;
1091         return i;
1092       }
1093     }
1094   }
1095   Q_ASSERT(false);
1096   return -1;
1097 }
1098
1099 const QHash<QByteArray, int> &SignalProxy::ExtendedMetaObject::syncMap() {
1100   if(_syncMap.isEmpty()) {
1101     QHash<QByteArray, int> syncMap;
1102
1103     QList<int> slotIndexes;
1104     for(int i = 0; i < _meta->methodCount(); i++) {
1105       if(_meta->method(i).methodType() == QMetaMethod::Slot)
1106         slotIndexes << i;
1107     }
1108
1109     // we're faking sync pairs for sync replies
1110     // --> we deliver to every slot starting with "receive"
1111     QByteArray slotSignature;
1112     QList<int>::iterator slotIter = slotIndexes.begin();
1113     while(slotIter != slotIndexes.end()) {
1114       slotSignature = QByteArray(_meta->method(*slotIter).signature());
1115       if(slotSignature.startsWith("receive")) {
1116         syncMap[slotSignature] = *slotIter;
1117         slotIter = slotIndexes.erase(slotIter);
1118       } else {
1119         slotIter++;
1120       }
1121     }
1122
1123     // find the proper sig -> slot matches
1124     QMetaMethod signal, slot;
1125     int matchIdx;
1126     for(int signalIdx = 0; signalIdx < _meta->methodCount(); signalIdx++) {
1127       signal = _meta->method(signalIdx);
1128       if(signal.methodType() != QMetaMethod::Signal)
1129         continue;
1130
1131       matchIdx = -1;
1132       foreach(int slotIdx, slotIndexes) {
1133         slot = _meta->method(slotIdx);
1134         if(methodsMatch(signal, slot)) {
1135           matchIdx = slotIdx;
1136           break;
1137         }
1138       }
1139       if(matchIdx != -1) {
1140         slotIndexes.removeAll(matchIdx);
1141         syncMap[QByteArray(signal.signature())] = matchIdx;
1142       }
1143     }
1144     _syncMap = syncMap;
1145   }
1146   return _syncMap;
1147 }
1148
1149 const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap() {
1150   if(_receiveMap.isEmpty()) {
1151     QHash<int, int> receiveMap;
1152
1153     QMetaMethod requestSlot;
1154     QByteArray returnTypeName;
1155     QByteArray signature;
1156     QByteArray methodName;
1157     QByteArray params;
1158     int paramsPos;
1159     int receiverId;
1160     const int methodCount = _meta->methodCount();
1161     for(int i = 0; i < methodCount; i++) {
1162       requestSlot = _meta->method(i);
1163       if(requestSlot.methodType() != QMetaMethod::Slot)
1164         continue;
1165
1166       returnTypeName = requestSlot.typeName();
1167       if(QMetaType::Void == (QMetaType::Type)returnType(i))
1168         continue;
1169
1170       signature = QByteArray(requestSlot.signature());
1171       if(!signature.startsWith("request"))
1172         continue;
1173
1174       paramsPos = signature.indexOf('(');
1175       if(paramsPos == -1)
1176         continue;
1177
1178       methodName = signature.left(paramsPos);
1179       params = signature.mid(paramsPos);
1180
1181       methodName = methodName.replace("request", "receive");
1182       params = params.left(params.count() - 1) + ", " + returnTypeName + ")";
1183
1184       signature = QMetaObject::normalizedSignature(methodName + params);
1185       receiverId = _meta->indexOfSlot(signature);
1186
1187       if(receiverId == -1) {
1188         signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
1189         receiverId = _meta->indexOfSlot(signature);
1190       }
1191
1192       if(receiverId != -1)
1193         receiveMap[i] = receiverId;
1194     }
1195     _receiveMap = receiveMap;
1196   }
1197   return _receiveMap;
1198 }
1199
1200 QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method) {
1201   QByteArray sig(method.signature());
1202   return sig.left(sig.indexOf("("));
1203 }
1204
1205 bool SignalProxy::ExtendedMetaObject::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) {
1206   // if we don't even have the same basename it's a sure NO
1207   QString baseName = methodBaseName(signal);
1208   if(baseName != methodBaseName(slot))
1209     return false;
1210
1211   // are the signatures compatible?
1212   if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature()))
1213     return false;
1214
1215   // we take an educated guess if the signals and slots match
1216   QString signalsuffix = methodName(signal);
1217   QString slotprefix = methodName(slot);
1218   if(!baseName.isEmpty()) {
1219     signalsuffix = signalsuffix.mid(baseName.count()).toLower();
1220     slotprefix = slotprefix.left(slotprefix.count() - baseName.count()).toLower();
1221   }
1222
1223   uint sizediff = qAbs(slotprefix.size() - signalsuffix.size());
1224   int ratio = editingDistance(slotprefix, signalsuffix) - sizediff;
1225   return (ratio < 2);
1226 }
1227
1228 QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method) {
1229   QString methodname = QString(method.signature()).section("(", 0, 0);
1230
1231   // determine where we have to chop:
1232   int upperCharPos;
1233   if(method.methodType() == QMetaMethod::Slot) {
1234     // we take evertyhing from the first uppercase char if it's slot
1235     upperCharPos = methodname.indexOf(QRegExp("[A-Z]"));
1236     if(upperCharPos == -1)
1237       return QString();
1238     methodname = methodname.mid(upperCharPos);
1239   } else {
1240     // and if it's a signal we discard everything from the last uppercase char
1241     upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]"));
1242     if(upperCharPos == -1)
1243       return QString();
1244     methodname = methodname.left(upperCharPos);
1245   }
1246
1247   methodname[0] = methodname[0].toUpper();
1248
1249   return methodname;
1250 }
1251
1252 SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaMethod &method)
1253   : _methodName(SignalProxy::ExtendedMetaObject::methodName(method)),
1254     _returnType(QMetaType::type(method.typeName()))
1255 {
1256   // determine argTypes
1257   QList<QByteArray> paramTypes = method.parameterTypes();
1258   QList<int> argTypes;
1259   for(int i = 0; i < paramTypes.count(); i++) {
1260     argTypes.append(QMetaType::type(paramTypes[i]));
1261   }
1262   _argTypes = argTypes;
1263
1264   // determine minArgCount
1265   QString signature(method.signature());
1266   _minArgCount = method.parameterTypes().count() - signature.count("=");
1267 }
1268