X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=ac39e3640b6a22117bb24e1bd24585536a232e48;hp=7c43592c837e6b7daf01b5808eefce71abd2619d;hb=dfcf836c5f1f57cadcdbea5c5a7a7034d21ce332;hpb=1adc00219ba072da57994764d086beed8ffb7bb4

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index 7c43592c..ac39e364 100644
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-08 by the Quassel Project                          *
+ *   Copyright (C) 2005-09 by the Quassel Project                          *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -61,148 +61,104 @@ public:
 };
 
 // ==================================================
-//  SIGNALRELAY
+//  SignalRelay
 // ==================================================
-class SignalRelay: public QObject {
+class SignalProxy::SignalRelay : public QObject {
 /* Q_OBJECT is not necessary or even allowed, because we implement
    qt_metacall ourselves (and don't use any other features of the meta
    object system)
 */
 public:
-  SignalRelay(SignalProxy* parent, QObject* source);
-  int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
-
-  void attachSignal(int methodId, const QByteArray &func);
+  SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {}
+  inline SignalProxy *proxy() const { return _proxy; }
 
-  void setSynchronize(bool);
-  bool synchronize() const;
+  int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
 
-  int sigCount() const;
+  void attachSignal(QObject *sender, int signalId, const QByteArray &funcName);
+  void detachSignal(QObject *sender, int signalId = -1);
 
 private:
-  bool isSyncMethod(int i);
-
-  SignalProxy* proxy;
-  QObject* caller;
-  QMultiHash<int, QByteArray> sigNames;
-  bool _sync;
+  struct Signal {
+    QObject *sender;
+    int signalId;
+    QByteArray signature;
+    Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {}
+    Signal() : sender(0), signalId(-1) {}
+  };
+
+  SignalProxy *_proxy;
+  QHash<int, Signal> _slots;
 };
 
-SignalRelay::SignalRelay(SignalProxy* parent, QObject* source)
-  : QObject(parent),
-    proxy(parent),
-    caller(source),
-    _sync(false)
-{
-  QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()));
-}
-
-int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
-  _id = QObject::qt_metacall(_c, _id, _a);
-  if(_id < 0)
-    return _id;
-  if(_c == QMetaObject::InvokeMetaMethod) {
-    if(sigNames.contains(_id) || synchronize()) {
-      const QList<int> &argTypes = proxy->argTypes(caller, _id);
-      QVariantList params;
-      int n = argTypes.size();
-      for(int i=0; i<n; i++) {
-	if(argTypes[i] == 0) {
-	  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());
-	  qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
-	  return _id;
-	}
-	params.append(QVariant(argTypes[i], _a[i+1]));
-      }
-      QMultiHash<int, QByteArray>::const_iterator funcIter = sigNames.constFind(_id);
-      while(funcIter != sigNames.constEnd() && funcIter.key() == _id) {
-        proxy->dispatchSignal(SignalProxy::RpcCall, QVariantList() << funcIter.value() << params);
-        funcIter++;
-      }
-
-      // dispatch Sync Signal if necessary
-      QByteArray signature(caller->metaObject()->method(_id).signature());
-      SyncableObject *syncObject = qobject_cast<SyncableObject *>(caller);
-      if(synchronize() && proxy->syncMap(syncObject).contains(signature)) {
-	 //qDebug() << "__SYNC__ >>>"
-	 //	 << caller->metaObject()->className()
-	 //	 << caller->objectName()
-	 //	 << signature
-	 //	 << params;
-	// params.prepend(QVariant(_id));
-	params.prepend(signature);
-	params.prepend(syncObject->objectName());
-	params.prepend(syncObject->syncMetaObject()->className());
-	proxy->dispatchSignal(SignalProxy::Sync, params);
-      }
+void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const QByteArray &funcName) {
+  // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
+  // all connected methodIds are offset by the standard methodCount of QObject
+  int slotId;
+  for(int i = 0;; i++) {
+    if(!_slots.contains(i)) {
+      slotId = i;
+      break;
     }
-    _id -= QObject::staticMetaObject.methodCount();
   }
-  return _id;
-}
-
-void SignalRelay::setSynchronize(bool sync) {
-  SyncableObject *syncObject = qobject_cast<SyncableObject *>(caller);
-  if(!syncObject)
-    return;
 
-  const QMetaObject *meta = syncObject->syncMetaObject();
-  if(!_sync && sync) {
-    // enable Sync
-    for(int i = 0; i < meta->methodCount(); i++ ) {
-      if(isSyncMethod(i))
-	QMetaObject::connect(caller, i, this, QObject::staticMetaObject.methodCount() + i);
-    }
-  } else if (_sync && !sync) {
-    // disable Sync
-    for(int i = 0; i < meta->methodCount(); i++ ) {
-      if(isSyncMethod(i))
-	QMetaObject::disconnect(caller, i, this, QObject::staticMetaObject.methodCount() + i);
-    }
+  QByteArray fn;
+  if(!funcName.isEmpty()) {
+    fn = QMetaObject::normalizedSignature(funcName);
+  } else {
+    fn = SIGNAL(fakeMethodSignature());
+    fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature());
   }
-  _sync = sync;
-}
 
-bool SignalRelay::isSyncMethod(int i) {
-  SyncableObject *syncObject = qobject_cast<SyncableObject *>(caller);
-  if(!syncObject)
-    return false;
+  _slots[slotId] = Signal(sender, signalId, fn);
 
-  QByteArray signature = syncObject->syncMetaObject()->method(i).signature();
-  if(!proxy->syncMap(syncObject).contains(signature))
-    return false;
+  QMetaObject::connect(sender, signalId, this, QObject::staticMetaObject.methodCount() + slotId);
+}
 
-  if(proxy->proxyMode() == SignalProxy::Server && !signature.contains("Requested"))
-    return true;
+void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId) {
+  QHash<int, Signal>::iterator slotIter = _slots.begin();
+  while(slotIter != _slots.end()) {
+    if(slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) {
+      slotIter = _slots.erase(slotIter);
+      if(signalId != -1)
+        break;
+    } else {
+      slotIter++;
+    }
+  }
+}
 
-  if(proxy->proxyMode() == SignalProxy::Client && signature.contains("Requested"))
-    return true;
+int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
+  _id = QObject::qt_metacall(_c, _id, _a);
+  if(_id < 0)
+    return _id;
 
-  return false;
-}
+  if(_c == QMetaObject::InvokeMetaMethod) {
+    if(_slots.contains(_id)) {
+      QObject *caller = sender();
 
-bool SignalRelay::synchronize() const {
-  return _sync;
-}
+      SignalProxy::ExtendedMetaObject *eMeta = proxy()->extendedMetaObject(caller->metaObject());
+      Q_ASSERT(eMeta);
 
-int SignalRelay::sigCount() const {
-  // only for debuging purpose
-  return sigNames.count();
-}
+      const Signal &signal = _slots[_id];
 
-void SignalRelay::attachSignal(int methodId, const QByteArray &func) {
-  // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
-  // all connected methodIds are offset by the standard methodCount of QObject
-  if(!sigNames.contains(methodId))
-    QMetaObject::connect(caller, methodId, this, QObject::staticMetaObject.methodCount() + methodId);
+      QVariantList params;
+      params << signal.signature;
+
+      const QList<int> &argTypes = eMeta->argTypes(signal.signalId);
+      for(int i = 0; i < argTypes.size(); i++) {
+        if(argTypes[i] == 0) {
+          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());
+          qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
+          return _id;
+        }
+        params << QVariant(argTypes[i], _a[i+1]);
+      }
 
-  QByteArray fn;
-  if(!func.isEmpty()) {
-    fn = QMetaObject::normalizedSignature(func);
-  } else {
-    fn = QByteArray("2") + caller->metaObject()->method(methodId).signature();
+      proxy()->dispatchSignal(SignalProxy::RpcCall, params);
+    }
+    _id -= _slots.count();
   }
-  sigNames.insert(methodId, fn);
+  return _id;
 }
 
 // ==================================================
@@ -211,7 +167,7 @@ void SignalRelay::attachSignal(int methodId, const QByteArray &func) {
 void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList &params) {
   QVariantList packedFunc;
   packedFunc << (qint16)requestType
-	     << params;
+             << params;
   dispatchPackedFunc(QVariant(packedFunc));
 }
 
@@ -253,7 +209,9 @@ void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType
 //  SignalProxy
 // ==================================================
 SignalProxy::SignalProxy(QObject* parent)
-  : QObject(parent)
+  : QObject(parent),
+  _heartBeatInterval(30),
+  _maxHeartBeatCount(2)
 {
   setProxyMode(Client);
   init();
@@ -275,9 +233,18 @@ SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent)
 }
 
 SignalProxy::~SignalProxy() {
-  QList<QObject*> senders = _relayHash.keys();
-  foreach(QObject* sender, senders)
-    detachObject(sender);
+  QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
+  while(classIter != _syncSlave.end()) {
+    ObjectId::iterator objIter = classIter->begin();
+    while(objIter != classIter->end()) {
+      SyncableObject *obj = objIter.value();
+      objIter = classIter->erase(objIter);
+      obj->stopSynchronize(this);
+    }
+    classIter++;
+  }
+  _syncSlave.clear();
+
   removeAllPeers();
 }
 
@@ -287,8 +254,8 @@ void SignalProxy::setProxyMode(ProxyMode mode) {
     if((*peer)->type() != AbstractPeer::IODevicePeer) {
       IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
       if(ioPeer->isOpen()) {
-	qWarning() << "SignalProxy: Cannot change proxy mode while connected";
-	return;
+        qWarning() << "SignalProxy: Cannot change proxy mode while connected";
+        return;
       }
     }
     if((*peer)->type() != AbstractPeer::SignalProxyPeer) {
@@ -306,8 +273,11 @@ void SignalProxy::setProxyMode(ProxyMode mode) {
 }
 
 void SignalProxy::init() {
+  _signalRelay = new SignalRelay(this);
   connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat()));
-  _heartBeatTimer.start(30 * 1000);
+  setHeartBeatInterval(30);
+  setMaxHeartBeatCount(2);
+  _heartBeatTimer.start();
   _secure = false;
   updateSecureState();
 }
@@ -358,6 +328,17 @@ bool SignalProxy::addPeer(QIODevice* iodev) {
   return true;
 }
 
+void SignalProxy::setHeartBeatInterval(int secs) {
+  if(secs != _heartBeatInterval) {
+    _heartBeatInterval = secs;
+    _heartBeatTimer.setInterval(secs * 1000);
+  }
+}
+
+void SignalProxy::setMaxHeartBeatCount(int max) {
+  _maxHeartBeatCount = max;
+}
+
 bool SignalProxy::addPeer(SignalProxy* proxy) {
   if(!proxy)
     return false;
@@ -435,15 +416,14 @@ void SignalProxy::removePeerBySender() {
   removePeer(sender());
 }
 
-void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) {
-  SyncableObject *syncObject = qobject_cast<SyncableObject *>(sender());
-  const QMetaObject *meta = syncObject->syncMetaObject();
-  const QByteArray className(meta->className());
-  objectRenamed(className, newname, oldname);
-
+void SignalProxy::renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname) {
   if(proxyMode() == Client)
     return;
 
+  const QMetaObject *meta = obj->syncMetaObject();
+  const QByteArray className(meta->className());
+  objectRenamed(className, newname, oldname);
+
   QVariantList params;
   params << "__objectRenamed__" << className << newname << oldname;
   dispatchSignal(RpcCall, params);
@@ -456,214 +436,29 @@ void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newn
   }
 }
 
-void SignalProxy::setArgTypes(QObject* obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  QList<QByteArray> p = meta->method(methodId).parameterTypes();
-  QList<int> argTypes;
-  int ct = p.count();
-  for(int i=0; i<ct; i++)
-    argTypes.append(QMetaType::type(p.value(i)));
-
-  Q_ASSERT(!_classInfo[meta]->argTypes.contains(methodId));
-  _classInfo[meta]->argTypes[methodId] = argTypes;
-}
-
-const QList<int> &SignalProxy::argTypes(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  Q_ASSERT(_classInfo.contains(meta));
-  if(!_classInfo[meta]->argTypes.contains(methodId))
-    setArgTypes(obj, methodId);
-  return _classInfo[meta]->argTypes[methodId];
-}
-
-void SignalProxy::setReturnType(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  int returnType = QMetaType::type(meta->method(methodId).typeName());
-
-  Q_ASSERT(!_classInfo[meta]->returnType.contains(methodId));
-  _classInfo[meta]->returnType[methodId] = returnType;
-}
-
-const int &SignalProxy::returnType(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  Q_ASSERT(_classInfo.contains(meta));
-  if(!_classInfo[meta]->returnType.contains(methodId))
-    setReturnType(obj, methodId);
-  return _classInfo[meta]->returnType[methodId];
-}
-
-void SignalProxy::setMinArgCount(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  QString signature(meta->method(methodId).signature());
-  int minCount = meta->method(methodId).parameterTypes().count() - signature.count("=");
-  Q_ASSERT(!_classInfo[meta]->minArgCount.contains(methodId));
-  _classInfo[meta]->minArgCount[methodId] = minCount;
-}
-
-const int &SignalProxy::minArgCount(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  Q_ASSERT(_classInfo.contains(meta));
-  if(!_classInfo[meta]->minArgCount.contains(methodId))
-    setMinArgCount(obj, methodId);
-  return _classInfo[meta]->minArgCount[methodId];
-}
-
-void SignalProxy::setMethodName(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  QByteArray method(::methodName(meta->method(methodId)));
-  Q_ASSERT(!_classInfo[meta]->methodNames.contains(methodId));
-  _classInfo[meta]->methodNames[methodId] = method;
-}
-
-const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) {
-  const QMetaObject *meta = metaObject(obj);
-  Q_ASSERT(_classInfo.contains(meta));
-  if(!_classInfo[meta]->methodNames.contains(methodId))
-    setMethodName(obj, methodId);
-  return _classInfo[meta]->methodNames[methodId];
-}
-
-
-void SignalProxy::setSyncMap(SyncableObject *obj) {
-  const QMetaObject *meta = obj->syncMetaObject();
-  QHash<QByteArray, int> syncMap;
-
-  QList<int> slotIndexes;
-  for(int i = 0; i < meta->methodCount(); i++) {
-    if(meta->method(i).methodType() == QMetaMethod::Slot)
-      slotIndexes << i;
-  }
-
-  // we're faking sync pairs for sync replies
-  QByteArray slotSignature;
-  foreach(int slotIdx, slotIndexes) {
-    slotSignature = QByteArray(meta->method(slotIdx).signature());
-    if(!slotSignature.startsWith("receive"))
-      continue;
-    syncMap[slotSignature] = slotIdx;
-  }
-
-  QMetaMethod signal, slot;
-  int matchIdx;
-  for(int signalIdx = 0; signalIdx < meta->methodCount(); signalIdx++) {
-    signal = meta->method(signalIdx);
-    if(signal.methodType() != QMetaMethod::Signal)
-      continue;
-
-    matchIdx = -1;
-    foreach(int slotIdx, slotIndexes) {
-      slot = meta->method(slotIdx);
-      if(methodsMatch(signal, slot)) {
-	matchIdx = slotIdx;
-	break;
-      }
-    }
-    if(matchIdx != -1) {
-      slotIndexes.removeAt(slotIndexes.indexOf(matchIdx));
-      syncMap[QByteArray(signal.signature())] = matchIdx;
-    }
-  }
-
-  Q_ASSERT(_classInfo[meta]->syncMap.isEmpty());
-  _classInfo[meta]->syncMap = syncMap;
-}
-
-const QHash<QByteArray,int> &SignalProxy::syncMap(SyncableObject *obj) {
-  const QMetaObject *meta = obj->syncMetaObject();
-  Q_ASSERT(_classInfo.contains(meta));
-  if(_classInfo[meta]->syncMap.isEmpty())
-    setSyncMap(obj);
-  return _classInfo[meta]->syncMap;
-}
-
-void SignalProxy::setReceiveMap(SyncableObject *obj) {
-  const QMetaObject *meta = obj->syncMetaObject();
-  Q_ASSERT(_classInfo.contains(meta));
-
-  QHash<int, int> receiveMap;
-
-  QMetaMethod requestSlot;
-  QByteArray returnTypeName;
-  QByteArray signature;
-  QByteArray methodName;
-  QByteArray params;
-  int paramsPos;
-  int receiverId;
-  const int methodCount = meta->methodCount();
-  for(int i = 0; i < methodCount; i++) {
-    requestSlot = meta->method(i);
-    if(requestSlot.methodType() != QMetaMethod::Slot)
-      continue;
-
-    returnTypeName = requestSlot.typeName();
-    if(QMetaType::Void == (QMetaType::Type)returnType(obj, i))
-      continue;
-
-    signature = QByteArray(requestSlot.signature());
-    if(!signature.startsWith("request"))
-      continue;
-
-    paramsPos = signature.indexOf('(');
-    if(paramsPos == -1)
-      continue;
-
-    methodName = signature.left(paramsPos);
-    params = signature.mid(paramsPos);
-
-    methodName = methodName.replace("request", "receive");
-    params = params.left(params.count() - 1) + ", " + returnTypeName + ")";
-
-    signature = QMetaObject::normalizedSignature(methodName + params);
-    receiverId = meta->indexOfSlot(signature);
-
-    if(receiverId == -1) {
-      signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
-      receiverId = meta->indexOfSlot(signature);
-    }
-
-    if(receiverId != -1)
-      receiveMap[i] = receiverId;
-  }
-  _classInfo[meta]->receiveMap = receiveMap;
-}
-
-const QHash<int, int> &SignalProxy::receiveMap(SyncableObject *obj) {
-  const QMetaObject *meta = obj->syncMetaObject();
-  Q_ASSERT(_classInfo.contains(meta));
-  if(_classInfo[meta]->receiveMap.isEmpty())
-    setReceiveMap(obj);
-  return _classInfo[meta]->receiveMap;
-}
-
-void SignalProxy::setUpdatedRemotelyId(SyncableObject *obj) {
-  const QMetaObject *meta = obj->syncMetaObject();
-  Q_ASSERT(_classInfo.contains(meta));
-  _classInfo[meta]->updatedRemotelyId = meta->indexOfSignal("updatedRemotely()");
-}
-
-int SignalProxy::updatedRemotelyId(SyncableObject *obj) {
-  Q_ASSERT(_classInfo.contains(obj->syncMetaObject()));
-  return _classInfo[obj->syncMetaObject()]->updatedRemotelyId;
-}
-
-const QMetaObject *SignalProxy::metaObject(QObject *obj) {
-  if(SyncableObject *syncObject = qobject_cast<SyncableObject *>(obj))
+const QMetaObject *SignalProxy::metaObject(const QObject *obj) {
+  if(const SyncableObject *syncObject = qobject_cast<const SyncableObject *>(obj))
     return syncObject->syncMetaObject();
   else
     return obj->metaObject();
 }
 
-void SignalProxy::createClassInfo(QObject *obj) {
-  const QMetaObject *meta = metaObject(obj);
-  if(_classInfo.contains(meta))
-    return;
+SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObject *meta) const {
+  if(_extendedMetaObjects.contains(meta))
+    return _extendedMetaObjects[meta];
+  else
+    return 0;
+}
 
-  ClassInfo *classInfo = new ClassInfo();
-  _classInfo[meta] = classInfo;
+SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) {
+  if(!_extendedMetaObjects.contains(meta)) {
+    _extendedMetaObjects[meta] = new ExtendedMetaObject(meta, checkConflicts);
+  }
+  return _extendedMetaObjects[meta];
 }
 
-bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) {
-  const QMetaObject* meta = metaObject(sender);
+bool SignalProxy::attachSignal(QObject *sender, const char* signal, const QByteArray& sigName) {
+  const QMetaObject* meta = sender->metaObject();
   QByteArray sig(meta->normalizedSignature(signal).mid(1));
   int methodId = meta->indexOfMethod(sig.constData());
   if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
@@ -671,20 +466,14 @@ bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteA
     return false;
   }
 
-  createClassInfo(sender);
-
-  SignalRelay* relay;
-  if(_relayHash.contains(sender))
-    relay = _relayHash[sender];
-  else
-    relay = _relayHash[sender] = new SignalRelay(this, sender);
-
-  relay->attachSignal(methodId, sigName);
+  createExtendedMetaObject(meta);
+  _signalRelay->attachSignal(sender, methodId, sigName);
 
+  disconnect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
+  connect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
   return true;
 }
 
-
 bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) {
   const QMetaObject* meta = recv->metaObject();
   int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
@@ -693,35 +482,24 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha
     return false;
   }
 
-  createClassInfo(recv);
+  createExtendedMetaObject(meta);
 
   QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
   _attachedSlots.insert(funcName, qMakePair(recv, methodId));
 
-  QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
-  QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
+  disconnect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
+  connect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
   return true;
 }
 
 void SignalProxy::synchronize(SyncableObject *obj) {
-  createClassInfo(obj);
-  setUpdatedRemotelyId(obj);
-
-  // attaching all the Signals
-  SignalRelay* relay;
-  if(_relayHash.contains(obj))
-    relay = _relayHash[obj];
-  else
-    relay = _relayHash[obj] = new SignalRelay(this, obj);
-
-  relay->setSynchronize(true);
+  createExtendedMetaObject(obj, true);
 
   // attaching as slave to receive sync Calls
   QByteArray className(obj->syncMetaObject()->className());
   _syncSlave[className][obj->objectName()] = obj;
 
   if(proxyMode() == Server) {
-    connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
     obj->setInitialized();
     emit objectInitialized(obj);
   } else {
@@ -730,32 +508,17 @@ void SignalProxy::synchronize(SyncableObject *obj) {
     else
       requestInit(obj);
   }
-}
 
-void SignalProxy::requestInit(SyncableObject *obj) {
-  if(proxyMode() == Server || obj->isInitialized())
-    return;
-
-  QVariantList params;
-  params << obj->syncMetaObject()->className()
-	 << obj->objectName();
-  dispatchSignal(InitRequest, params);
+  obj->synchronize(this);
 }
 
-void SignalProxy::detachSender() {
-  detachObject(sender());
-}
-
-void SignalProxy::detachObject(QObject* obj) {
-  stopSync(static_cast<SyncableObject *>(obj));
+void SignalProxy::detachObject(QObject *obj) {
   detachSignals(obj);
   detachSlots(obj);
 }
 
-void SignalProxy::detachSignals(QObject* sender) {
-  if(!_relayHash.contains(sender))
-    return;
-  _relayHash.take(sender)->deleteLater();
+void SignalProxy::detachSignals(QObject *sender) {
+  _signalRelay->detachSignal(sender);
 }
 
 void SignalProxy::detachSlots(QObject* receiver) {
@@ -768,10 +531,7 @@ void SignalProxy::detachSlots(QObject* receiver) {
   }
 }
 
-void SignalProxy::stopSync(SyncableObject* obj) {
-  if(_relayHash.contains(obj))
-    _relayHash[obj]->setSynchronize(false);
-
+void SignalProxy::stopSynchronize(SyncableObject *obj) {
   // we can't use a className here, since it might be effed up, if we receive the call as a result of a decon
   // gladly the objectName() is still valid. So we have only to iterate over the classes not each instance! *sigh*
   QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
@@ -782,6 +542,7 @@ void SignalProxy::stopSync(SyncableObject* obj) {
     }
     classIter++;
   }
+  obj->stopSynchronize(this);
 }
 
 void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList &params) {
@@ -791,11 +552,11 @@ void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantL
     switch((*peer)->type()) {
     case AbstractPeer::IODevicePeer:
       {
-	IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
-	if(ioPeer->isOpen())
-	  ioPeer->dispatchPackedFunc(packedFunc);
-	else
-	  QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
+        IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
+        if(ioPeer->isOpen())
+          ioPeer->dispatchPackedFunc(packedFunc);
+        else
+          QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
       }
       break;
     case AbstractPeer::SignalProxyPeer:
@@ -821,6 +582,18 @@ void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packed
 }
 
 void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList &params) {
+  switch(requestType) {
+    // list all RequestTypes that shouldnot trigger a heartbeat counter reset here
+  case HeartBeatReply:
+    break;
+  default:
+    if(sender->type() == AbstractPeer::IODevicePeer) {
+      IODevicePeer *ioPeer = static_cast<IODevicePeer *>(sender);
+      ioPeer->sentHeartBeats = 0;
+    }
+  }
+
+  // qDebug() << "SignalProxy::receivePeerSignal)" << requestType << params;
   switch(requestType) {
   case RpcCall:
     if(params.empty())
@@ -872,49 +645,56 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) {
 
   QByteArray className = params.takeFirst().toByteArray();
   QString objectName = params.takeFirst().toString();
-  QByteArray signal = params.takeFirst().toByteArray();
+  QByteArray slot = params.takeFirst().toByteArray();
 
   if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
-    qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName)
-	       << params;
+    qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName)
+               << params;
     return;
   }
 
   SyncableObject *receiver = _syncSlave[className][objectName];
-  if(!syncMap(receiver).contains(signal)) {
-    qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName)
-	       << params;
+  ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
+  if(!eMeta->slotMap().contains(slot)) {
+    qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName)
+               << params;
     return;
   }
 
-  int slotId = syncMap(receiver)[signal];
+  int slotId = eMeta->slotMap()[slot];
+  if(proxyMode() != eMeta->receiverMode(slotId)) {
+    qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed. Wrong ProxyMode!", eMeta->methodName(slotId).constData());
+    return;
+  }
 
-  QVariant returnValue((QVariant::Type)returnType(receiver, slotId));
+  QVariant returnValue((QVariant::Type)eMeta->returnType(slotId));
   if(!invokeSlot(receiver, slotId, params, returnValue)) {
-    qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData());
+    qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData());
     return;
   }
 
-  if(returnValue.type() != QVariant::Invalid && receiveMap(receiver).contains(slotId)) {
-    int receiverId = receiveMap(receiver)[slotId];
+
+  if(returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) {
+    int receiverId = eMeta->receiveMap()[slotId];
     QVariantList returnParams;
     returnParams << className
-		 << objectName
-		 << QByteArray(receiver->metaObject()->method(receiverId).signature());
-    if(argTypes(receiver, receiverId).count() > 1)
+                 << objectName
+                 << eMeta->methodName(receiverId);
+    //QByteArray(receiver->metaObject()->method(receiverId).signature());
+    if(eMeta->argTypes(receiverId).count() > 1)
       returnParams << params;
     returnParams << returnValue;
     sender->dispatchSignal(Sync, returnParams);
   }
 
   // send emit update signal
-  invokeSlot(receiver, updatedRemotelyId(receiver));
+  invokeSlot(receiver, eMeta->updatedRemotelyId());
 }
 
 void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &params) {
   if(params.count() != 2) {
     qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
-	       << params;
+               << params;
     return;
   }
 
@@ -923,13 +703,13 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa
 
   if(!_syncSlave.contains(className)) {
     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
-	       << className;
+               << className;
     return;
   }
 
   if(!_syncSlave[className].contains(objectName)) {
     qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
-	       << className << objectName;
+               << className << objectName;
     return;
   }
 
@@ -937,8 +717,8 @@ void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &pa
 
   QVariantList params_;
   params_ << className
-	  << objectName
-	  << initData(obj);
+          << objectName
+          << initData(obj);
 
   sender->dispatchSignal(InitData, params_);
 }
@@ -947,7 +727,7 @@ void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList &param
   Q_UNUSED(sender)
   if(params.count() != 3) {
     qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:"
-	       << params;
+               << params;
     return;
   }
 
@@ -957,13 +737,13 @@ void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList &param
 
   if(!_syncSlave.contains(className)) {
     qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
-	       << className;
+               << className;
     return;
   }
 
   if(!_syncSlave[className].contains(objectName)) {
     qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
-	       << className << objectName;
+               << className << objectName;
     return;
   }
 
@@ -982,26 +762,29 @@ void SignalProxy::handleSignal(const QVariantList &data) {
   while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
     receiver = (*slot).first;
     methodId = (*slot).second;
-    if(!invokeSlot(receiver, methodId, params))
-      qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
+    if(!invokeSlot(receiver, methodId, params)) {
+      ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
+      qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData());
+    }
     slot++;
   }
 }
 
 bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue) {
-  const QList<int> args = argTypes(receiver, methodId);
+  ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
+  const QList<int> args = eMeta->argTypes(methodId);
   const int numArgs = params.count() < args.count()
     ? params.count()
     : args.count();
 
-  if(minArgCount(receiver, methodId) > params.count()) {
-      qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << methodName(receiver, methodId);
+  if(eMeta->minArgCount(methodId) > params.count()) {
+      qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId);
       return false;
   }
 
   void *_a[] = {0,              // return type...
-		0, 0, 0, 0 , 0, // and 10 args - that's the max size qt can handle with signals and slots
-		0, 0, 0, 0 , 0};
+                0, 0, 0, 0 , 0, // and 10 args - that's the max size qt can handle with signals and slots
+                0, 0, 0, 0 , 0};
 
   // check for argument compatibility and build params array
   for(int i = 0; i < numArgs; i++) {
@@ -1011,7 +794,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
       return false;
     }
     if(args[i] != QMetaType::type(params[i].typeName())) {
-      qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << methodName(receiver, methodId);
+      qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
       return false;
     }
     _a[i+1] = const_cast<void *>(params[i].constData());
@@ -1024,7 +807,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
     ? Qt::DirectConnection
     : Qt::QueuedConnection;
 
-  if (type == Qt::DirectConnection) {
+  if(type == Qt::DirectConnection) {
     return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
   } else {
     qWarning() << "Queued Connections are not implemented yet";
@@ -1082,6 +865,9 @@ void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool c
 }
 
 bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) {
+  if(!dev)
+    return false;
+
   QDataStream in(dev);
   in.setVersion(QDataStream::Qt_4_2);
 
@@ -1091,12 +877,12 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian
   }
 
   if(blockSize > 1 << 22) {
-    disconnectDevice(dev, tr("Client tried to send package larger than max package size!"));
+    disconnectDevice(dev, tr("Peer tried to send package larger than max package size!"));
     return false;
   }
 
   if(blockSize == 0) {
-    disconnectDevice(dev, tr("Client tried to send 0 byte package!"));
+    disconnectDevice(dev, tr("Peer tried to send 0 byte package!"));
     return false;
   }
 
@@ -1113,8 +899,8 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian
     if(nbytes <= 4) {
       const char *data = rawItem.constData();
       if(nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) {
-	disconnectDevice(dev, tr("Client sent corrupted compressed data!"));
-	return false;
+        disconnectDevice(dev, tr("Peer sent corrupted compressed data!"));
+        return false;
       }
     }
 
@@ -1128,63 +914,21 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian
   }
 
   if(!item.isValid()) {
-    disconnectDevice(dev, tr("Client sent corrupt data: unable to load QVariant!"));
+    disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!"));
     return false;
   }
 
   return true;
 }
 
-bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const {
-  // if we don't even have the same basename it's a sure NO
-  QString baseName = methodBaseName(signal);
-  if(baseName != methodBaseName(slot))
-    return false;
-
-  // are the signatures compatible?
-  if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature()))
-    return false;
-
-  // we take an educated guess if the signals and slots match
-  QString signalsuffix = ::methodName(signal);
-  QString slotprefix = ::methodName(slot);
-  if(!baseName.isEmpty()) {
-    signalsuffix = signalsuffix.mid(baseName.count()).toLower();
-    slotprefix = slotprefix.left(slotprefix.count() - baseName.count()).toLower();
-  }
-
-  uint sizediff = qAbs(slotprefix.size() - signalsuffix.size());
-  int ratio = editingDistance(slotprefix, signalsuffix) - sizediff;
-//   if(ratio < 2) {
-//     qDebug() << Q_FUNC_INFO;
-//     qDebug() << methodBaseName(signal) << methodBaseName(slot);
-//     qDebug() << signalsuffix << slotprefix << sizediff << ratio;
-//   }
-  return (ratio < 2);
-}
-
-QString SignalProxy::methodBaseName(const QMetaMethod &method) {
-  QString methodname = QString(method.signature()).section("(", 0, 0);
-
-  // determine where we have to chop:
-  int upperCharPos;
-  if(method.methodType() == QMetaMethod::Slot) {
-    // we take evertyhing from the first uppercase char if it's slot
-    upperCharPos = methodname.indexOf(QRegExp("[A-Z]"));
-    if(upperCharPos == -1)
-      return QString();
-    methodname = methodname.mid(upperCharPos);
-  } else {
-    // and if it's a signal we discard everything from the last uppercase char
-    upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]"));
-    if(upperCharPos == -1)
-      return QString();
-    methodname = methodname.left(upperCharPos);
-  }
-
-  methodname[0] = methodname[0].toUpper();
+void SignalProxy::requestInit(SyncableObject *obj) {
+  if(proxyMode() == Server || obj->isInitialized())
+    return;
 
-  return methodname;
+  QVariantList params;
+  params << obj->syncMetaObject()->className()
+         << obj->objectName();
+  dispatchSignal(InitRequest, params);
 }
 
 QVariantMap SignalProxy::initData(SyncableObject *obj) const {
@@ -1197,29 +941,34 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties
   obj->fromVariantMap(properties);
   obj->setInitialized();
   emit objectInitialized(obj);
-  invokeSlot(obj, updatedRemotelyId(obj));
+  invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId());
 }
 
 void SignalProxy::sendHeartBeat() {
   QVariantList heartBeatParams;
   heartBeatParams << QTime::currentTime();
+  QList<IODevicePeer *> toClose;
+
   PeerHash::iterator peer = _peers.begin();
   while(peer != _peers.end()) {
     if((*peer)->type() == AbstractPeer::IODevicePeer) {
       IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
       ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams);
       if(ioPeer->sentHeartBeats > 0) {
-	updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
-      }
-      if(ioPeer->sentHeartBeats > 1) {
-	qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
-		   << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)";
-	ioPeer->close();
-      } else {
-	ioPeer->sentHeartBeats++;
+        updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
       }
+      if(maxHeartBeatCount() >= 0 && ioPeer->sentHeartBeats >= maxHeartBeatCount())
+        toClose.append(ioPeer);
+      else
+        ioPeer->sentHeartBeats++;
     }
-    peer++;
+    ++peer;
+  }
+
+  foreach(IODevicePeer *ioPeer, toClose) {
+    qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
+               << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats * _heartBeatTimer.interval() / 1000 << "seconds)";
+    ioPeer->close();
   }
 }
 
@@ -1265,6 +1014,34 @@ void SignalProxy::customEvent(QEvent *event) {
   }
 }
 
+void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode modeType, const char *funcname, va_list ap) {
+  // qDebug() << obj << modeType << "(" << _proxyMode << ")" << funcname;
+  if(modeType != _proxyMode)
+    return;
+
+  ExtendedMetaObject *eMeta = extendedMetaObject(obj);
+
+  QVariantList params;
+  params << eMeta->metaObject()->className()
+         << obj->objectName()
+         << QByteArray(funcname);
+
+  const QList<int> &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname)));
+
+  for(int i = 0; i < argTypes.size(); i++) {
+    if(argTypes[i] == 0) {
+      qWarning() << Q_FUNC_INFO << "received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(eMeta->metaObject()->className()).arg(funcname);
+      qWarning() << "        - make sure all your data types are known by the Qt MetaSystem";
+      return;
+    }
+    params << QVariant(argTypes[i], va_arg(ap, void *));
+  }
+
+  dispatchSignal(Sync, params);
+}
+
+
+
 void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) {
   if(!reason.isEmpty())
     qWarning() << qPrintable(reason);
@@ -1281,7 +1058,6 @@ void SignalProxy::updateLag(IODevicePeer *peer, int lag) {
   }
 }
 
-
 void SignalProxy::dumpProxyStats() {
   QString mode;
   if(proxyMode() == Server)
@@ -1289,33 +1065,15 @@ void SignalProxy::dumpProxyStats() {
   else
     mode = "Client";
 
-  int sigCount = 0;
-  foreach(SignalRelay *relay, _relayHash.values())
-    sigCount += relay->sigCount();
-
   int slaveCount = 0;
   foreach(ObjectId oid, _syncSlave.values())
     slaveCount += oid.count();
 
   qDebug() << this;
   qDebug() << "              Proxy Mode:" << mode;
-  qDebug() << "attached sending Objects:" << _relayHash.count();
-  qDebug() << "       number of Signals:" << sigCount;
   qDebug() << "          attached Slots:" << _attachedSlots.count();
   qDebug() << " number of synced Slaves:" << slaveCount;
-  qDebug() << "number of Classes cached:" << _classInfo.count();
-}
-
-void SignalProxy::dumpSyncMap(SyncableObject *object) {
-  const QMetaObject *meta = object->metaObject();
-  qDebug() << "SignalProxy: SyncMap for Class" << meta->className();
-
-  QHash<QByteArray, int> syncMap_ = syncMap(object);
-  QHash<QByteArray, int>::const_iterator iter = syncMap_.constBegin();
-  while(iter != syncMap_.constEnd()) {
-    qDebug() << qPrintable(QString("%1 --> %2 %3").arg(QString(iter.key()), 40).arg(iter.value()).arg(QString(meta->method(iter.value()).signature())));
-    iter++;
-  }
+  qDebug() << "number of Classes cached:" << _extendedMetaObjects.count();
 }
 
 void SignalProxy::updateSecureState() {
@@ -1330,3 +1088,161 @@ void SignalProxy::updateSecureState() {
   if(wasSecure != _secure)
     emit secureStateChanged(_secure);
 }
+
+
+// ==================================================
+//  ExtendedMetaObject
+// ==================================================
+SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts)
+  : _meta(meta),
+    _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
+{
+  for(int i = 0; i < _meta->methodCount(); i++) {
+    if(_meta->method(i).methodType() != QMetaMethod::Slot)
+      continue;
+
+    if(QByteArray(_meta->method(i).signature()).contains('*'))
+      continue; // skip methods with ptr params
+
+    QByteArray method = methodName(_meta->method(i));
+    if(method.startsWith("init"))
+      continue; // skip initializers
+
+    if(_methodIds.contains(method)) {
+      /* funny... moc creates for methods containing default parameters multiple metaMethod with separate methodIds.
+         we don't care... we just need the full fledged version
+       */
+      const QMetaMethod &current = _meta->method(_methodIds[method]);
+      const QMetaMethod &candidate = _meta->method(i);
+      if(current.parameterTypes().count() > candidate.parameterTypes().count()) {
+        int minCount = candidate.parameterTypes().count();
+        QList<QByteArray> commonParams = current.parameterTypes().mid(0, minCount);
+        if(commonParams == candidate.parameterTypes())
+          continue; // we already got the full featured version
+      } else {
+        int minCount = current.parameterTypes().count();
+        QList<QByteArray> commonParams = candidate.parameterTypes().mid(0, minCount);
+        if(commonParams == current.parameterTypes()) {
+          _methodIds[method] = i; // use the new one
+          continue;
+        }
+      }
+      if(checkConflicts) {
+        qWarning() << "class" << meta->className() << "contains overloaded methods which is currently not supported!";
+        qWarning() << " - " << _meta->method(i).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature();
+      }
+      continue;
+    }
+    _methodIds[method] = i;
+  }
+}
+
+const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId) {
+  if(!_methods.contains(methodId)) {
+    _methods[methodId] = MethodDescriptor(_meta->method(methodId));
+  }
+  return _methods[methodId];
+}
+
+const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap() {
+  if(_receiveMap.isEmpty()) {
+    QHash<int, int> receiveMap;
+
+    QMetaMethod requestSlot;
+    QByteArray returnTypeName;
+    QByteArray signature;
+    QByteArray methodName;
+    QByteArray params;
+    int paramsPos;
+    int receiverId;
+    const int methodCount = _meta->methodCount();
+    for(int i = 0; i < methodCount; i++) {
+      requestSlot = _meta->method(i);
+      if(requestSlot.methodType() != QMetaMethod::Slot)
+        continue;
+
+      returnTypeName = requestSlot.typeName();
+      if(QMetaType::Void == (QMetaType::Type)returnType(i))
+        continue;
+
+      signature = QByteArray(requestSlot.signature());
+      if(!signature.startsWith("request"))
+        continue;
+
+      paramsPos = signature.indexOf('(');
+      if(paramsPos == -1)
+        continue;
+
+      methodName = signature.left(paramsPos);
+      params = signature.mid(paramsPos);
+
+      methodName = methodName.replace("request", "receive");
+      params = params.left(params.count() - 1) + ", " + returnTypeName + ")";
+
+      signature = QMetaObject::normalizedSignature(methodName + params);
+      receiverId = _meta->indexOfSlot(signature);
+
+      if(receiverId == -1) {
+        signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
+        receiverId = _meta->indexOfSlot(signature);
+      }
+
+      if(receiverId != -1) {
+        receiveMap[i] = receiverId;
+      }
+    }
+    _receiveMap = receiveMap;
+  }
+  return _receiveMap;
+}
+
+QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method) {
+  QByteArray sig(method.signature());
+  return sig.left(sig.indexOf("("));
+}
+
+QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method) {
+  QString methodname = QString(method.signature()).section("(", 0, 0);
+
+  // determine where we have to chop:
+  int upperCharPos;
+  if(method.methodType() == QMetaMethod::Slot) {
+    // we take evertyhing from the first uppercase char if it's slot
+    upperCharPos = methodname.indexOf(QRegExp("[A-Z]"));
+    if(upperCharPos == -1)
+      return QString();
+    methodname = methodname.mid(upperCharPos);
+  } else {
+    // and if it's a signal we discard everything from the last uppercase char
+    upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]"));
+    if(upperCharPos == -1)
+      return QString();
+    methodname = methodname.left(upperCharPos);
+  }
+
+  methodname[0] = methodname[0].toUpper();
+
+  return methodname;
+}
+
+SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaMethod &method)
+  : _methodName(SignalProxy::ExtendedMetaObject::methodName(method)),
+    _returnType(QMetaType::type(method.typeName()))
+{
+  // determine argTypes
+  QList<QByteArray> paramTypes = method.parameterTypes();
+  QList<int> argTypes;
+  for(int i = 0; i < paramTypes.count(); i++) {
+    argTypes.append(QMetaType::type(paramTypes[i]));
+  }
+  _argTypes = argTypes;
+
+  // determine minArgCount
+  QString signature(method.signature());
+  _minArgCount = method.parameterTypes().count() - signature.count("=");
+
+  _receiverMode = (_methodName.startsWith("request"))
+    ? SignalProxy::Server
+    : SignalProxy::Client;
+}
+