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) any later version.                                   *
   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
 331   QHash<int, int> syncMap;
 332
 333   QList<int> slotIndexes;
 334   for(int i = 0; i < meta->methodCount(); i++) {
 335     if(meta->method(i).methodType() == QMetaMethod::Slot)
 336       slotIndexes << i;
 337   }
 338
 339   QMetaMethod signal, slot;
 340   int matchIdx;
 341   for(int signalIdx = 0; signalIdx < meta->methodCount(); signalIdx++) {
 342     signal = meta->method(signalIdx);
 343     if(signal.methodType() != QMetaMethod::Signal)
 344       continue;
 345
 346     matchIdx = -1;
 347     foreach(int slotIdx, slotIndexes) {
 348       slot = meta->method(slotIdx);
 349       if(methodsMatch(signal, slot)) {
 350         matchIdx = slotIdx;
 351         break;
 352       }
 353     }
 354     if(matchIdx != -1) {
 355       slotIndexes.removeAt(slotIndexes.indexOf(matchIdx));
 356       syncMap[signalIdx] = matchIdx;
 357     }
 358   }
 359
 360   Q_ASSERT(_classInfo[meta]->syncMap.isEmpty());
 361   _classInfo[meta]->syncMap = syncMap;
 362 }
 363
 364 const QHash<int,int> &SignalProxy::syncMap(QObject *obj) {
 365   Q_ASSERT(_classInfo.contains(obj->metaObject()));
 366   if(_classInfo[obj->metaObject()]->syncMap.isEmpty())
 367     setSyncMap(obj);
 368   return _classInfo[obj->metaObject()]->syncMap;
 369 }
 370
 371 void SignalProxy::createClassInfo(QObject *obj) {
 372   if(!_classInfo.contains(obj->metaObject()))
 373     _classInfo[obj->metaObject()] = new ClassInfo();
 374 }
 375
 376 bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) {
 377   const QMetaObject* meta = sender->metaObject();
 378   QByteArray sig(meta->normalizedSignature(signal).mid(1));
 379   int methodId = meta->indexOfMethod(sig.constData());
 380   if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
 381     qWarning() << "SignalProxy::attachSignal(): No such signal" << signal;
 382     return false;
 383   }
 384
 385   createClassInfo(sender);
 386
 387   SignalRelay* relay;
 388   if(_relayHash.contains(sender))
 389     relay = _relayHash[sender];
 390   else
 391     relay = _relayHash[sender] = new SignalRelay(this, sender);
 392
 393   relay->attachSignal(methodId, sigName);
 394
 395   return true;
 396 }
 397
 398
 399 bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) {
 400   const QMetaObject* meta = recv->metaObject();
 401   int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
 402   if(methodId == -1 || meta->method(methodId).methodType() == QMetaMethod::Method) {
 403     qWarning() << "SignalProxy::attachSlot(): No such slot" << slot;
 404     return false;
 405   }
 406
 407   createClassInfo(recv);
 408
 409   QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
 410   _attachedSlots.insert(funcName, qMakePair(recv, methodId));
 411
 412   QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
 413   QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
 414   return true;
 415 }
 416
 417 void SignalProxy::synchronize(QObject *obj) {
 418   if(proxyMode() == Server)
 419     return synchronizeAsMaster(obj);
 420   else
 421     return synchronizeAsSlave(obj);
 422 }
 423
 424 void SignalProxy::synchronizeAsMaster(QObject *sender) {
 425   createClassInfo(sender);
 426
 427   SignalRelay* relay;
 428   if(_relayHash.contains(sender))
 429     relay = _relayHash[sender];
 430   else
 431     relay = _relayHash[sender] = new SignalRelay(this, sender);
 432
 433   relay->setSynchronize(true);
 434
 435   if(sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
 436     connect(sender, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
 437
 438   QByteArray className(sender->metaObject()->className());
 439   _syncSlave[className][sender->objectName()] = sender;
 440
 441   setInitialized(sender);
 442 }
 443
 444 void SignalProxy::synchronizeAsSlave(QObject *receiver) {
 445   QByteArray className(receiver->metaObject()->className());
 446   _syncSlave[className][receiver->objectName()] = receiver;
 447
 448   createClassInfo(receiver);
 449
 450   requestInit(receiver);
 451 }
 452
 453 void SignalProxy::setInitialized(QObject *obj) {
 454   QMetaObject::invokeMethod(obj, "setInitialized");
 455 }
 456
 457 bool SignalProxy::initialized(QObject *obj) {
 458   bool init;
 459   if(!QMetaObject::invokeMethod(obj, "initialized", Q_RETURN_ARG(bool, init)))
 460     init = false;
 461   return init;
 462 }
 463
 464 void SignalProxy::requestInit(QObject *obj) {
 465   if(proxyMode() == Server || initialized(obj))
 466     return;
 467
 468   QVariantList params;
 469   params << obj->metaObject()->className()
 470          << obj->objectName();
 471   dispatchSignal((int)InitRequest, params);
 472 }
 473
 474 void SignalProxy::detachSender() {
 475   // this is a slot so we can bypass the QueuedConnection
 476   // and if someone is forcing direct connection in a multithreaded environment he's just nuts...
 477   _detachSignals(sender());
 478   _detachSlots(sender());
 479 }
 480
 481 // detachObject/Signals/Slots() can be called as a result of an incoming call
 482 // this might destroy our the iterator used for delivery
 483 // thus we wrap the actual disconnection by using QueuedConnections
 484 void SignalProxy::detachObject(QObject* obj) {
 485   detachSignals(obj);
 486   detachSlots(obj);
 487 }
 488
 489 void SignalProxy::detachSignals(QObject* sender) {
 490   QMetaObject::invokeMethod(this, "_detachSignals",
 491                             Qt::QueuedConnection,
 492                             Q_ARG(QObject*, sender));
 493 }
 494
 495 void SignalProxy::detachSlots(QObject* receiver) {
 496   QMetaObject::invokeMethod(this, "_detachSlots",
 497                             Qt::QueuedConnection,
 498                             Q_ARG(QObject*, receiver));
 499 }
 500
 501 void SignalProxy::_detachSignals(QObject* sender) {
 502   if(!_relayHash.contains(sender))
 503     return;
 504   _relayHash.take(sender)->deleteLater();
 505 }
 506
 507 void SignalProxy::_detachSlots(QObject* receiver) {
 508   SlotHash::iterator slotIter = _attachedSlots.begin();
 509   while(slotIter != _attachedSlots.end()) {
 510     if(slotIter.value().first == receiver) {
 511       slotIter = _attachedSlots.erase(slotIter);
 512     } else
 513       slotIter++;
 514   }
 515 }
 516
 517 void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList &params) {
 518   QVariantList packedFunc;
 519   packedFunc << identifier;
 520   packedFunc << params;
 521   writeDataToDevice(receiver, QVariant(packedFunc));
 522 }
 523
 524 void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList &params) {
 525   // yes I know we have a little code duplication here... it's for the sake of performance
 526   QVariantList packedFunc;
 527   packedFunc << identifier;
 528   packedFunc << params;
 529   foreach(QIODevice* dev, _peerByteCount.keys())
 530     writeDataToDevice(dev, QVariant(packedFunc));
 531 }
 532
 533 void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) {
 534   QVariantList params(packedFunc.toList());
 535
 536   QVariant call = params.takeFirst();
 537   if(call.type() != QVariant::Int)
 538     return handleSignal(call.toByteArray(), params);
 539
 540   switch(call.toInt()) {
 541   case Sync:
 542     return handleSync(params);
 543   case InitRequest:
 544     return handleInitRequest(sender, params);
 545   case InitData:
 546     return handleInitData(sender, params);
 547   default:
 548     qWarning() << "received undefined CallType" << call.toInt();
 549     return;
 550   }
 551 }
 552
 553 void SignalProxy::handleSync(QVariantList params) {
 554   if(params.count() < 3) {
 555     qWarning() << "received invalid Sync call" << params;
 556     return;
 557   }
 558
 559   QByteArray className =params.takeFirst().toByteArray();
 560   QString objectName = params.takeFirst().toString();
 561   int signalId = params.takeFirst().toInt();
 562
 563   if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
 564     qWarning() << "no registered receiver:" << className << objectName << "for Sync call" << signalId << params;
 565     return;
 566   }
 567
 568   QObject *receiver = _syncSlave[className][objectName];
 569   if(!syncMap(receiver).contains(signalId)) {
 570     qWarning() << "received Sync Call with invalid SignalId" << className << objectName << signalId;
 571   }
 572   int slotId = syncMap(receiver)[signalId];
 573   if(!invokeSlot(receiver, slotId, params))
 574     qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData());
 575 }
 576
 577 void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList &params) {
 578   if(params.count() != 2) {
 579     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
 580                << params;
 581     return;
 582   }
 583
 584   QByteArray className(params[0].toByteArray());
 585   QString objectName(params[1].toString());
 586
 587   if(!_syncSlave.contains(className)) {
 588     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
 589                << className;
 590     return;
 591   }
 592
 593   if(!_syncSlave[className].contains(objectName)) {
 594     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
 595                << className << objectName;
 596     return;
 597   }
 598
 599   QObject *obj = _syncSlave[className][objectName];
 600
 601   QVariantList params_;
 602   params_ << obj->metaObject()->className()
 603           << obj->objectName()
 604           << initData(obj);
 605
 606   dispatchSignal(sender, (int)InitData, params_);
 607 }
 608
 609 void SignalProxy::handleInitData(QIODevice *sender, const QVariantList &params) {
 610   Q_UNUSED(sender)
 611   if(params.count() != 3) {
 612     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
 613                << params;
 614     return;
 615   }
 616
 617   QByteArray className(params[0].toByteArray());
 618   QString objectName(params[1].toString());
 619   QVariantMap propertyMap(params[2].toMap());
 620
 621   if(!_syncSlave.contains(className)) {
 622     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
 623                << className;
 624     return;
 625   }
 626
 627   if(!_syncSlave[className].contains(objectName)) {
 628     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
 629                << className << objectName;
 630     return;
 631   }
 632
 633   QObject *obj = _syncSlave[className][objectName];
 634   setInitData(obj, propertyMap);
 635 }
 636
 637 void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &params) {
 638   QObject* receiver;
 639   int methodId;
 640   SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
 641   while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
 642     receiver = (*slot).first;
 643     methodId = (*slot).second;
 644     if(!invokeSlot(receiver, methodId, params))
 645       qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
 646     slot++;
 647   }
 648 }
 649
 650 bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params) {
 651   int numParams = argTypes(receiver, methodId).count();
 652   QGenericArgument args[9];
 653   for(int i = 0; i < numParams; i++)
 654     args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
 655   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]);
 656 }
 657
 658 void SignalProxy::dataAvailable() {
 659   // yet again. it's a private slot. no need for checks.
 660   QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
 661   QVariant var;
 662   while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
 663     receivePeerSignal(ioDev, var);
 664 }
 665
 666 void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) {
 667   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(dev);
 668   if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) {
 669     qWarning("SignalProxy: Can't call on a closed device");
 670     return;
 671   }
 672   QByteArray block;
 673   QDataStream out(&block, QIODevice::WriteOnly);
 674   out.setVersion(QDataStream::Qt_4_2);
 675   out << (quint32)0 << item;
 676   out.device()->seek(0);
 677   out << (quint32)(block.size() - sizeof(quint32));
 678   dev->write(block);
 679 }
 680
 681 bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item) {
 682   QDataStream in(dev);
 683   in.setVersion(QDataStream::Qt_4_2);
 684
 685   if(blockSize == 0) {
 686     if(dev->bytesAvailable() < (int)sizeof(quint32)) return false;
 687     in >> blockSize;
 688   }
 689
 690   if(dev->bytesAvailable() < blockSize)
 691     return false;
 692   in >> item;
 693   blockSize = 0;
 694   return true;
 695 }
 696
 697 bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const {
 698   // if we don't even have the same basename it's a sure NO
 699   if(methodBaseName(signal) != methodBaseName(slot))
 700     return false;
 701
 702   // are the signatures compatible?
 703   if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature()))
 704     return false;
 705
 706   // we take an educated guess if the signals and slots match
 707   QString signalsuffix = ::methodName(signal).mid(QString(::methodName(signal)).lastIndexOf(QRegExp("[A-Z]"))).toLower();
 708   QString slotprefix = ::methodName(slot).left(QString(::methodName(slot)).indexOf(QRegExp("[A-Z]"))).toLower();
 709
 710   uint sizediff = qAbs(slotprefix.size() - signalsuffix.size());
 711   int ratio = editingDistance(slotprefix, signalsuffix) - sizediff;
 712   return (ratio < 2);
 713 }
 714
 715 QString SignalProxy::methodBaseName(const QMetaMethod &method) {
 716   QString methodname = QString(method.signature()).section("(", 0, 0);
 717
 718   // determine where we have to chop:
 719   if(method.methodType() == QMetaMethod::Slot) {
 720     // we take evertyhing from the first uppercase char if it's slot
 721     methodname = methodname.mid(methodname.indexOf(QRegExp("[A-Z]")));
 722   } else {
 723     // and if it's a signal we discard everything from the last uppercase char
 724     methodname = methodname.left(methodname.lastIndexOf(QRegExp("[A-Z]")));
 725   }
 726
 727   methodname[0] = methodname[0].toUpper();
 728
 729   return methodname;
 730 }
 731
 732 QVariantMap SignalProxy::initData(QObject *obj) const {
 733   QVariantMap properties;
 734
 735   const QMetaObject* meta = obj->metaObject();
 736
 737   // we collect data from properties
 738   for(int i = 0; i < meta->propertyCount(); i++) {
 739     QMetaProperty prop = meta->property(i);
 740     properties[QString(prop.name())] = prop.read(obj);
 741   }
 742
 743   // ...as well as methods, which have names starting with "init"
 744   for(int i = 0; i < meta->methodCount(); i++) {
 745     QMetaMethod method = meta->method(i);
 746     QString methodname(::methodName(method));
 747     if(!methodname.startsWith("init") || methodname.startsWith("initSet"))
 748       continue;
 749
 750     QVariant value = QVariant(QVariant::nameToType(method.typeName()));
 751     QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value);
 752     QMetaObject::invokeMethod(obj, methodname.toAscii(), genericvalue);
 753
 754     properties[methodBaseName(method)] = value;
 755     // qDebug() << ">>> SYNC:" << methodBaseName(method) << value;
 756   }
 757
 758   // properties["Payload"] = QByteArray(10000000, 'a');  // for testing purposes
 759   return properties;
 760 }
 761
 762 void SignalProxy::setInitData(QObject *obj, const QVariantMap &properties) {
 763   if(initialized(obj))
 764     return;
 765
 766   const QMetaObject *meta = obj->metaObject();
 767
 768   QVariantMap::const_iterator iterator = properties.constBegin();
 769   while(iterator != properties.constEnd()) {
 770     QString name = iterator.key();
 771     int propertyIndex = meta->indexOfProperty(name.toAscii());
 772
 773     if(propertyIndex == -1 || !meta->property(propertyIndex).isWritable())
 774       setInitValue(obj, name, iterator.value());
 775     else
 776       obj->setProperty(name.toAscii(), iterator.value());
 777     // qDebug() << "<<< SYNC:" << name << iterator.value();
 778     iterator++;
 779   }
 780   setInitialized(obj);
 781 }
 782
 783 bool SignalProxy::setInitValue(QObject *obj, const QString &property, const QVariant &value) {
 784   QString handlername = QString("initSet") + property;
 785   handlername[7] = handlername[7].toUpper();
 786   QGenericArgument param(value.typeName(), value.constData());
 787   return QMetaObject::invokeMethod(obj, handlername.toAscii(), param);
 788 }
 789
 790 void SignalProxy::dumpProxyStats() {
 791   QString mode;
 792   if(proxyMode() == Server)
 793     mode = "Server";
 794   else
 795     mode = "Client";
 796
 797   int sigCount = 0;
 798   foreach(SignalRelay *relay, _relayHash.values())
 799     sigCount += relay->sigCount();
 800
 801   int slaveCount = 0;
 802   foreach(ObjectId oid, _syncSlave.values())
 803     slaveCount += oid.count();
 804
 805   qDebug() << this;
 806   qDebug() << "              Proxy Mode:" << mode;
 807   qDebug() << "attached sending Objects:" << _relayHash.count();
 808   qDebug() << "       number of Signals:" << sigCount;
 809   qDebug() << "          attached Slots:" << _attachedSlots.count();
 810   qDebug() << " number of synced Slaves:" << slaveCount;
 811   qDebug() << "number of Classes cached:" << _classInfo.count();
 812 }
 813
 814