src/common/signalproxy.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-07 by the Quassel IRC Team                         *
   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 #include <QObject>
  23 #include <QIODevice>
  24 #include <QAbstractSocket>
  25 #include <QHash>
  26 #include <QMultiHash>
  27 #include <QList>
  28 #include <QSet>
  29 #include <QDebug>
  30 #include <QMetaMethod>
  31 #include <QMetaProperty>
  32 #include <QRegExp>
  33 #include "util.h"
  34
  35 class SignalRelay: public QObject {
  36
  37 /* Q_OBJECT is not necessary or even allowed, because we implement
  38    qt_metacall ourselves (and don't use any other features of the meta
  39    object system)
  40 */
  41 public:
  42   SignalRelay(SignalProxy* parent, QObject* source);
  43   int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
  44
  45   void attachSignal(int methodId, const QByteArray &func);
  46
  47   void setSynchronize(bool);
  48   bool synchronize() const;
  49
  50   int sigCount() const;
  51
  52 private:
  53   SignalProxy* proxy;
  54   QObject* caller;
  55   QMultiHash<int, QByteArray> sigNames;
  56   bool _sync;
  57 };
  58
  59 SignalRelay::SignalRelay(SignalProxy* parent, QObject* source)
  60   : QObject(parent),
  61     proxy(parent),
  62     caller(source),
  63     _sync(false)
  64 {
  65   QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()));
  66 }
  67
  68 int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
  69   _id = QObject::qt_metacall(_c, _id, _a);
  70   if(_id < 0)
  71     return _id;
  72   if(_c == QMetaObject::InvokeMetaMethod) {
  73     if(sigNames.contains(_id) || synchronize()) {
  74       const QList<int> &argTypes = proxy->argTypes(caller, _id);
  75       QVariantList params;
  76       int n = argTypes.size();
  77       for(int i=0; i<n; i++)
  78         params.append(QVariant(argTypes[i], _a[i+1]));
  79       QMultiHash<int, QByteArray>::const_iterator funcIter = sigNames.constFind(_id);
  80       while(funcIter != sigNames.constEnd() && funcIter.key() == _id) {
  81         proxy->dispatchSignal(funcIter.value(), params);
  82         funcIter++;
  83       }
  84       if(synchronize() && proxy->syncMap(caller).contains(_id)) {
  85         // qDebug() << "__SYNC__ >>>"
  86         //       << caller->metaObject()->className()
  87         //       << caller->objectName()
  88         //       << proxy->methodName(caller, _id)
  89         //       << params;
  90         params.prepend(QVariant(_id));
  91         params.prepend(caller->objectName());
  92         params.prepend(caller->metaObject()->className());
  93         proxy->dispatchSignal((int)SignalProxy::Sync, params);
  94       }
  95     }
  96     _id -= 1;
  97   }
  98   return _id;
  99 }
 100
 101 void SignalRelay::setSynchronize(bool sync) {
 102   QHash<int, int>::const_iterator iter = proxy->syncMap(caller).constBegin();
 103   if(!_sync && sync) {
 104     while(iter != proxy->syncMap(caller).constEnd()) {
 105       QMetaObject::connect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key());
 106       iter++;
 107     }
 108   } else if (_sync && !sync) {
 109     while(iter != proxy->syncMap(caller).constEnd()) {
 110       QMetaObject::disconnect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key());
 111       iter++;
 112     }
 113   }
 114   _sync = sync;
 115 }
 116
 117 bool SignalRelay::synchronize() const {
 118   return _sync;
 119 }
 120
 121 int SignalRelay::sigCount() const {
 122   // only for debuging purpose
 123   return sigNames.count();
 124 }
 125
 126 void SignalRelay::attachSignal(int methodId, const QByteArray &func) {
 127   // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
 128   // all connected methodIds are offset by the standard methodCount of QObject
 129   if(!sigNames.contains(methodId))
 130     QMetaObject::connect(caller, methodId, this, QObject::staticMetaObject.methodCount() + methodId);
 131
 132   QByteArray fn;
 133   if(!func.isEmpty()) {
 134     fn = QMetaObject::normalizedSignature(func);
 135   } else {
 136     fn = QByteArray("2") + caller->metaObject()->method(methodId).signature();
 137   }
 138   sigNames.insert(methodId, fn);
 139 }
 140 // ====================
 141 // END SIGNALRELAY
 142 // ====================
 143
 144
 145 // ====================
 146 //  SignalProxy
 147 // ====================
 148 SignalProxy::SignalProxy(QObject* parent)
 149   : QObject(parent)
 150 {
 151   setProxyMode(Client);
 152 }
 153
 154 SignalProxy::SignalProxy(ProxyMode mode, QObject* parent)
 155   : QObject(parent)
 156 {
 157   setProxyMode(mode);
 158 }
 159
 160 SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent)
 161   : QObject(parent)
 162 {
 163   setProxyMode(mode);
 164   addPeer(device);
 165 }
 166
 167 SignalProxy::~SignalProxy() {
 168   QList<QObject*> senders = _relayHash.keys();
 169   foreach(QObject* sender, senders)
 170     detachObject(sender);
 171 }
 172
 173 void SignalProxy::setProxyMode(ProxyMode mode) {
 174   foreach(QIODevice* peer, _peerByteCount.keys()) {
 175     if(peer->isOpen()) {
 176       qWarning() << "SignalProxy: Cannot change proxy mode while connected";
 177       return;
 178     }
 179   }
 180   _proxyMode = mode;
 181   if(mode == Server)
 182     initServer();
 183   else
 184     initClient();
 185 }
 186
 187 SignalProxy::ProxyMode SignalProxy::proxyMode() const {
 188   return _proxyMode;
 189 }
 190
 191 void SignalProxy::initServer() {
 192 }
 193
 194 void SignalProxy::initClient() {
 195   attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString)));
 196 }
 197
 198 bool SignalProxy::addPeer(QIODevice* iodev) {
 199   if(!iodev)
 200     return false;
 201
 202   if(_peerByteCount.contains(iodev))
 203     return true;
 204
 205   if(proxyMode() == Client && !_peerByteCount.isEmpty()) {
 206     qWarning("SignalProxy: only one peer allowed in client mode!");
 207     return false;
 208   }
 209
 210   if(!iodev->isOpen())
 211     qWarning("SignalProxy::the device you passed is not open!");
 212
 213   connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
 214   connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
 215
 216   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(iodev);
 217   if(sock) {
 218     connect(sock, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
 219   }
 220
 221   _peerByteCount[iodev] = 0;
 222
 223   if(_peerByteCount.count() == 1)
 224     emit connected();
 225
 226   return true;
 227 }
 228
 229 void SignalProxy::removePeerBySender() {
 230   // OK we're brutal here... but since it's a private slot we know what we've got connected to it...
 231   QIODevice *ioDev = (QIODevice *)(sender());
 232   removePeer(ioDev);
 233 }
 234
 235 void SignalProxy::objectRenamed(QString oldname, QString newname) {
 236   const QMetaObject *meta = sender()->metaObject();
 237   const QByteArray className(meta->className());
 238   objectRenamed(className, oldname, newname);
 239
 240   if(proxyMode() == Client)
 241     return;
 242
 243   QVariantList params;
 244   params << className << oldname << newname;
 245   dispatchSignal("__objectRenamed__", params);
 246 }
 247
 248 void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) {
 249   if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname))
 250     _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
 251 }
 252
 253
 254 void SignalProxy::removePeer(QIODevice* iodev) {
 255   if(_peerByteCount.isEmpty()) {
 256     qWarning() << "SignalProxy: No peers in use!";
 257     return;
 258   }
 259
 260   if(proxyMode() == Server && !iodev) {
 261     // disconnect all
 262     QList<QIODevice *> peers = _peerByteCount.keys();
 263     foreach(QIODevice *peer, peers)
 264       removePeer(peer);
 265   }
 266
 267   if(proxyMode() != Server && !iodev)
 268     iodev = _peerByteCount.keys().first();
 269
 270   Q_ASSERT(iodev);
 271
 272   if(!_peerByteCount.contains(iodev)) {
 273     qWarning() << "SignalProxy: unknown QIODevice" << iodev;
 274     return;
 275   }
 276
 277   // take a last gasp
 278   while(true) {
 279     QVariant var;
 280     if(readDataFromDevice(iodev, _peerByteCount[iodev], var))
 281       receivePeerSignal(iodev, var);
 282     else
 283       break;
 284   }
 285   _peerByteCount.remove(iodev);
 286
 287   disconnect(iodev, 0, this, 0);
 288   emit peerRemoved(iodev);
 289
 290   if(_peerByteCount.isEmpty())
 291     emit disconnected();
 292 }
 293
 294 void SignalProxy::setArgTypes(QObject* obj, int methodId) {
 295   const QMetaObject *meta = obj->metaObject();
 296   QList<QByteArray> p = meta->method(methodId).parameterTypes();
 297   QList<int> argTypes;
 298   int ct = p.count();
 299   for(int i=0; i<ct; i++)
 300     argTypes.append(QMetaType::type(p.value(i)));
 301
 302   Q_ASSERT(!_classInfo[meta]->argTypes.contains(methodId));
 303   _classInfo[meta]->argTypes[methodId] = argTypes;
 304 }
 305
 306 const QList<int> &SignalProxy::argTypes(QObject *obj, int methodId) {
 307   Q_ASSERT(_classInfo.contains(obj->metaObject()));
 308   if(!_classInfo[obj->metaObject()]->argTypes.contains(methodId))
 309     setArgTypes(obj, methodId);
 310   return _classInfo[obj->metaObject()]->argTypes[methodId];
 311 }
 312
 313 void SignalProxy::setMethodName(QObject *obj, int methodId) {
 314   const QMetaObject *meta = obj->metaObject();
 315   QByteArray method(::methodName(meta->method(methodId)));
 316   Q_ASSERT(!_classInfo[meta]->methodNames.contains(methodId));
 317   _classInfo[meta]->methodNames[methodId] = method;
 318 }
 319
 320 const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) {
 321   Q_ASSERT(_classInfo.contains(obj->metaObject()));
 322   if(!_classInfo[obj->metaObject()]->methodNames.contains(methodId))
 323     setMethodName(obj, methodId);
 324   return _classInfo[obj->metaObject()]->methodNames[methodId];
 325 }
 326
 327
 328 void SignalProxy::setSyncMap(QObject *obj) {
 329   const QMetaObject *meta = obj->metaObject();
 330   QHash<int, int> syncMap;
 331
 332   QList<int> slotIndexes;
 333   for(int i = 0; i < meta->methodCount(); i++) {
 334     if(meta->method(i).methodType() == QMetaMethod::Slot)
 335       slotIndexes << i;
 336   }
 337
 338   QMetaMethod signal, slot;
 339   int matchIdx;
 340   for(int signalIdx = 0; signalIdx < meta->methodCount(); signalIdx++) {
 341     signal = meta->method(signalIdx);
 342     if(signal.methodType() != QMetaMethod::Signal)
 343       continue;
 344
 345     matchIdx = -1;
 346     foreach(int slotIdx, slotIndexes) {
 347       slot = meta->method(slotIdx);
 348       if(methodsMatch(signal, slot)) {
 349         matchIdx = slotIdx;
 350         break;
 351       }
 352     }
 353     if(matchIdx != -1) {
 354       slotIndexes.removeAt(slotIndexes.indexOf(matchIdx));
 355       syncMap[signalIdx] = matchIdx;
 356     }
 357   }
 358
 359   Q_ASSERT(_classInfo[meta]->syncMap.isEmpty());
 360   _classInfo[meta]->syncMap = syncMap;
 361 }
 362
 363 const QHash<int,int> &SignalProxy::syncMap(QObject *obj) {
 364   Q_ASSERT(_classInfo.contains(obj->metaObject()));
 365   if(_classInfo[obj->metaObject()]->syncMap.isEmpty())
 366     setSyncMap(obj);
 367   return _classInfo[obj->metaObject()]->syncMap;
 368 }
 369
 370 void SignalProxy::createClassInfo(QObject *obj) {
 371   if(!_classInfo.contains(obj->metaObject()))
 372     _classInfo[obj->metaObject()] = new ClassInfo();
 373 }
 374
 375 bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) {
 376   const QMetaObject* meta = sender->metaObject();
 377   QByteArray sig(meta->normalizedSignature(signal).mid(1));
 378   int methodId = meta->indexOfMethod(sig.constData());
 379   if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
 380     qWarning() << "SignalProxy::attachSignal(): No such signal" << signal;
 381     return false;
 382   }
 383
 384   createClassInfo(sender);
 385
 386   SignalRelay* relay;
 387   if(_relayHash.contains(sender))
 388     relay = _relayHash[sender];
 389   else
 390     relay = _relayHash[sender] = new SignalRelay(this, sender);
 391
 392   relay->attachSignal(methodId, sigName);
 393
 394   return true;
 395 }
 396
 397
 398 bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) {
 399   const QMetaObject* meta = recv->metaObject();
 400   int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
 401   if(methodId == -1 || meta->method(methodId).methodType() == QMetaMethod::Method) {
 402     qWarning() << "SignalProxy::attachSlot(): No such slot" << slot;
 403     return false;
 404   }
 405
 406   createClassInfo(recv);
 407
 408   QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
 409   _attachedSlots.insert(funcName, qMakePair(recv, methodId));
 410
 411   QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
 412   QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
 413   return true;
 414 }
 415
 416 void SignalProxy::synchronize(QObject *obj) {
 417   if(proxyMode() == Server)
 418     return synchronizeAsMaster(obj);
 419   else
 420     return synchronizeAsSlave(obj);
 421 }
 422
 423 void SignalProxy::synchronizeAsMaster(QObject *sender) {
 424   createClassInfo(sender);
 425
 426   SignalRelay* relay;
 427   if(_relayHash.contains(sender))
 428     relay = _relayHash[sender];
 429   else
 430     relay = _relayHash[sender] = new SignalRelay(this, sender);
 431
 432   relay->setSynchronize(true);
 433
 434   if(sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
 435     connect(sender, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
 436
 437   QByteArray className(sender->metaObject()->className());
 438   _syncSlave[className][sender->objectName()] = sender;
 439
 440   setInitialized(sender);
 441 }
 442
 443 void SignalProxy::synchronizeAsSlave(QObject *receiver) {
 444   QByteArray className(receiver->metaObject()->className());
 445   _syncSlave[className][receiver->objectName()] = receiver;
 446
 447   createClassInfo(receiver);
 448
 449   requestInit(receiver);
 450 }
 451
 452 void SignalProxy::setInitialized(QObject *obj) {
 453   QMetaObject::invokeMethod(obj, "setInitialized");
 454 }
 455
 456 bool SignalProxy::initialized(QObject *obj) {
 457   bool init;
 458   if(!QMetaObject::invokeMethod(obj, "initialized", Q_RETURN_ARG(bool, init)))
 459     init = false;
 460   return init;
 461 }
 462
 463 void SignalProxy::requestInit(QObject *obj) {
 464   if(proxyMode() == Server || initialized(obj))
 465     return;
 466
 467   QVariantList params;
 468   params << obj->metaObject()->className()
 469          << obj->objectName();
 470   dispatchSignal((int)InitRequest, params);
 471 }
 472
 473 void SignalProxy::detachSender() {
 474   // this is a slot so we can bypass the QueuedConnection
 475   // and if someone is forcing direct connection in a multithreaded environment he's just nuts...
 476   _detachSignals(sender());
 477   _detachSlots(sender());
 478 }
 479
 480 // detachObject/Signals/Slots() can be called as a result of an incoming call
 481 // this might destroy our the iterator used for delivery
 482 // thus we wrap the actual disconnection by using QueuedConnections
 483 void SignalProxy::detachObject(QObject* obj) {
 484   detachSignals(obj);
 485   detachSlots(obj);
 486 }
 487
 488 void SignalProxy::detachSignals(QObject* sender) {
 489   QMetaObject::invokeMethod(this, "_detachSignals",
 490                             Qt::QueuedConnection,
 491                             Q_ARG(QObject*, sender));
 492 }
 493
 494 void SignalProxy::detachSlots(QObject* receiver) {
 495   QMetaObject::invokeMethod(this, "_detachSlots",
 496                             Qt::QueuedConnection,
 497                             Q_ARG(QObject*, receiver));
 498 }
 499
 500 void SignalProxy::_detachSignals(QObject* sender) {
 501   if(!_relayHash.contains(sender))
 502     return;
 503   _relayHash.take(sender)->deleteLater();
 504 }
 505
 506 void SignalProxy::_detachSlots(QObject* receiver) {
 507   SlotHash::iterator slotIter = _attachedSlots.begin();
 508   while(slotIter != _attachedSlots.end()) {
 509     if(slotIter.value().first == receiver) {
 510       slotIter = _attachedSlots.erase(slotIter);
 511     } else
 512       slotIter++;
 513   }
 514 }
 515
 516 void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList &params) {
 517   QVariantList packedFunc;
 518   packedFunc << identifier;
 519   packedFunc << params;
 520   writeDataToDevice(receiver, QVariant(packedFunc));
 521 }
 522
 523 void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList &params) {
 524   // yes I know we have a little code duplication here... it's for the sake of performance
 525   QVariantList packedFunc;
 526   packedFunc << identifier;
 527   packedFunc << params;
 528   foreach(QIODevice* dev, _peerByteCount.keys())
 529     writeDataToDevice(dev, QVariant(packedFunc));
 530 }
 531
 532 void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) {
 533   QVariantList params(packedFunc.toList());
 534
 535   QVariant call = params.takeFirst();
 536   if(call.type() != QVariant::Int)
 537     return handleSignal(call.toByteArray(), params);
 538
 539   switch(call.toInt()) {
 540   case Sync:
 541     return handleSync(params);
 542   case InitRequest:
 543     return handleInitRequest(sender, params);
 544   case InitData:
 545     return handleInitData(sender, params);
 546   default:
 547     qWarning() << "received undefined CallType" << call.toInt();
 548     return;
 549   }
 550 }
 551
 552 void SignalProxy::handleSync(QVariantList params) {
 553   if(params.count() < 3) {
 554     qWarning() << "received invalid Sync call" << params;
 555     return;
 556   }
 557
 558   QByteArray className =params.takeFirst().toByteArray();
 559   QString objectName = params.takeFirst().toString();
 560   int signalId = params.takeFirst().toInt();
 561
 562   if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
 563     qWarning() << "no registered receiver:" << className << objectName << "for Sync call" << signalId << params;
 564     return;
 565   }
 566
 567   QObject *receiver = _syncSlave[className][objectName];
 568   if(!syncMap(receiver).contains(signalId)) {
 569     const QMetaObject *meta = receiver->metaObject();
 570     QString signalName;
 571     if(signalId < meta->methodCount())
 572       signalName = QString(meta->method(signalId).signature());
 573     else
 574       signalName = QString::number(signalId);
 575
 576     qWarning() << "received Sync Call for Object" << receiver
 577                << "- no matching Slot for Signal:" << signalName;
 578     return;
 579    }
 580   int slotId = syncMap(receiver)[signalId];
 581   if(!invokeSlot(receiver, slotId, params))
 582     qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData());
 583 }
 584
 585 void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList &params) {
 586   if(params.count() != 2) {
 587     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
 588                << params;
 589     return;
 590   }
 591
 592   QByteArray className(params[0].toByteArray());
 593   QString objectName(params[1].toString());
 594
 595   if(!_syncSlave.contains(className)) {
 596     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
 597                << className;
 598     return;
 599   }
 600
 601   if(!_syncSlave[className].contains(objectName)) {
 602     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
 603                << className << objectName;
 604     return;
 605   }
 606
 607   QObject *obj = _syncSlave[className][objectName];
 608
 609   QVariantList params_;
 610   params_ << obj->metaObject()->className()
 611           << obj->objectName()
 612           << initData(obj);
 613
 614   dispatchSignal(sender, (int)InitData, params_);
 615 }
 616
 617 void SignalProxy::handleInitData(QIODevice *sender, const QVariantList &params) {
 618   Q_UNUSED(sender)
 619   if(params.count() != 3) {
 620     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
 621                << params;
 622     return;
 623   }
 624
 625   QByteArray className(params[0].toByteArray());
 626   QString objectName(params[1].toString());
 627   QVariantMap propertyMap(params[2].toMap());
 628
 629   if(!_syncSlave.contains(className)) {
 630     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
 631                << className;
 632     return;
 633   }
 634
 635   if(!_syncSlave[className].contains(objectName)) {
 636     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
 637                << className << objectName;
 638     return;
 639   }
 640
 641   QObject *obj = _syncSlave[className][objectName];
 642   setInitData(obj, propertyMap);
 643 }
 644
 645 void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &params) {
 646   QObject* receiver;
 647   int methodId;
 648   SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
 649   while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
 650     receiver = (*slot).first;
 651     methodId = (*slot).second;
 652     if(!invokeSlot(receiver, methodId, params))
 653       qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
 654     slot++;
 655   }
 656 }
 657
 658 bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params) {
 659   int numParams = argTypes(receiver, methodId).count();
 660   QGenericArgument args[9];
 661   for(int i = 0; i < numParams; i++)
 662     args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
 663   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]);
 664 }
 665
 666 void SignalProxy::dataAvailable() {
 667   // yet again. it's a private slot. no need for checks.
 668   QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
 669   QVariant var;
 670   while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
 671     receivePeerSignal(ioDev, var);
 672 }
 673
 674 void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) {
 675   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(dev);
 676   if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) {
 677     qWarning("SignalProxy: Can't call on a closed device");
 678     return;
 679   }
 680   QByteArray block;
 681   QDataStream out(&block, QIODevice::WriteOnly);
 682   out.setVersion(QDataStream::Qt_4_2);
 683   out << (quint32)0 << item;
 684   out.device()->seek(0);
 685   out << (quint32)(block.size() - sizeof(quint32));
 686   dev->write(block);
 687 }
 688
 689 bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item) {
 690   QDataStream in(dev);
 691   in.setVersion(QDataStream::Qt_4_2);
 692
 693   if(blockSize == 0) {
 694     if(dev->bytesAvailable() < (int)sizeof(quint32)) return false;
 695     in >> blockSize;
 696   }
 697
 698   if(dev->bytesAvailable() < blockSize)
 699     return false;
 700   in >> item;
 701   blockSize = 0;
 702   return true;
 703 }
 704
 705 bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const {
 706   // if we don't even have the same basename it's a sure NO
 707   if(methodBaseName(signal) != methodBaseName(slot))
 708     return false;
 709
 710   // are the signatures compatible?
 711   if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature()))
 712     return false;
 713
 714   // we take an educated guess if the signals and slots match
 715   QString signalsuffix = ::methodName(signal).mid(QString(::methodName(signal)).lastIndexOf(QRegExp("[A-Z]"))).toLower();
 716   QString slotprefix = ::methodName(slot).left(QString(::methodName(slot)).indexOf(QRegExp("[A-Z]"))).toLower();
 717
 718   uint sizediff = qAbs(slotprefix.size() - signalsuffix.size());
 719   int ratio = editingDistance(slotprefix, signalsuffix) - sizediff;
 720   return (ratio < 2);
 721 }
 722
 723 QString SignalProxy::methodBaseName(const QMetaMethod &method) {
 724   QString methodname = QString(method.signature()).section("(", 0, 0);
 725
 726   // determine where we have to chop:
 727   if(method.methodType() == QMetaMethod::Slot) {
 728     // we take evertyhing from the first uppercase char if it's slot
 729     methodname = methodname.mid(methodname.indexOf(QRegExp("[A-Z]")));
 730   } else {
 731     // and if it's a signal we discard everything from the last uppercase char
 732     methodname = methodname.left(methodname.lastIndexOf(QRegExp("[A-Z]")));
 733   }
 734
 735   methodname[0] = methodname[0].toUpper();
 736
 737   return methodname;
 738 }
 739
 740 QVariantMap SignalProxy::initData(QObject *obj) const {
 741   QVariantMap properties;
 742
 743   const QMetaObject* meta = obj->metaObject();
 744
 745   // we collect data from properties
 746   for(int i = 0; i < meta->propertyCount(); i++) {
 747     QMetaProperty prop = meta->property(i);
 748     properties[QString(prop.name())] = prop.read(obj);
 749   }
 750
 751   // ...as well as methods, which have names starting with "init"
 752   for(int i = 0; i < meta->methodCount(); i++) {
 753     QMetaMethod method = meta->method(i);
 754     QString methodname(::methodName(method));
 755     if(!methodname.startsWith("init") || methodname.startsWith("initSet"))
 756       continue;
 757
 758     QVariant value = QVariant(QVariant::nameToType(method.typeName()));
 759     QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value);
 760     QMetaObject::invokeMethod(obj, methodname.toAscii(), genericvalue);
 761
 762     properties[methodBaseName(method)] = value;
 763     // qDebug() << ">>> SYNC:" << methodBaseName(method) << value;
 764   }
 765
 766   // properties["Payload"] = QByteArray(10000000, 'a');  // for testing purposes
 767   return properties;
 768 }
 769
 770 void SignalProxy::setInitData(QObject *obj, const QVariantMap &properties) {
 771   if(initialized(obj))
 772     return;
 773
 774   const QMetaObject *meta = obj->metaObject();
 775
 776   QVariantMap::const_iterator iterator = properties.constBegin();
 777   while(iterator != properties.constEnd()) {
 778     QString name = iterator.key();
 779     int propertyIndex = meta->indexOfProperty(name.toAscii());
 780
 781     if(propertyIndex == -1 || !meta->property(propertyIndex).isWritable())
 782       setInitValue(obj, name, iterator.value());
 783     else
 784       obj->setProperty(name.toAscii(), iterator.value());
 785     // qDebug() << "<<< SYNC:" << name << iterator.value();
 786     iterator++;
 787   }
 788   setInitialized(obj);
 789 }
 790
 791 bool SignalProxy::setInitValue(QObject *obj, const QString &property, const QVariant &value) {
 792   QString handlername = QString("initSet") + property;
 793   handlername[7] = handlername[7].toUpper();
 794   QGenericArgument param(value.typeName(), value.constData());
 795   return QMetaObject::invokeMethod(obj, handlername.toAscii(), param);
 796 }
 797
 798 void SignalProxy::dumpProxyStats() {
 799   QString mode;
 800   if(proxyMode() == Server)
 801     mode = "Server";
 802   else
 803     mode = "Client";
 804
 805   int sigCount = 0;
 806   foreach(SignalRelay *relay, _relayHash.values())
 807     sigCount += relay->sigCount();
 808
 809   int slaveCount = 0;
 810   foreach(ObjectId oid, _syncSlave.values())
 811     slaveCount += oid.count();
 812
 813   qDebug() << this;
 814   qDebug() << "              Proxy Mode:" << mode;
 815   qDebug() << "attached sending Objects:" << _relayHash.count();
 816   qDebug() << "       number of Signals:" << sigCount;
 817   qDebug() << "          attached Slots:" << _attachedSlots.count();
 818   qDebug() << " number of synced Slaves:" << slaveCount;
 819   qDebug() << "number of Classes cached:" << _classInfo.count();
 820 }
 821
 822 void SignalProxy::dumpSyncMap(QObject *object) {
 823   const QMetaObject *meta = object->metaObject();
 824   qDebug() << "SignalProxy: SyncMap for Class" << meta->className();
 825
 826   QHash<int, int> syncMap_ = syncMap(object);
 827   QHash<int, int>::const_iterator iter = syncMap_.constBegin();
 828   while(iter != syncMap_.constEnd()) {
 829     qDebug() << iter.key() << meta->method(iter.key()).signature() << "-->" << iter.value() << meta->method(iter.value()).signature();
 830     iter++;
 831   }
 832 }