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