}
QMultiHash<int, QByteArray>::const_iterator funcIter = sigNames.constFind(_id);
while(funcIter != sigNames.constEnd() && funcIter.key() == _id) {
- proxy->dispatchSignal((int)SignalProxy::RpcCall, QVariantList() << funcIter.value() << params);
+ proxy->dispatchSignal(SignalProxy::RpcCall, QVariantList() << funcIter.value() << params);
funcIter++;
}
params.prepend(signature);
params.prepend(caller->objectName());
params.prepend(caller->metaObject()->className());
- proxy->dispatchSignal((int)SignalProxy::Sync, params);
+ proxy->dispatchSignal(SignalProxy::Sync, params);
}
}
_id -= QObject::staticMetaObject.methodCount();
QList<QObject*> senders = _relayHash.keys();
foreach(QObject* sender, senders)
detachObject(sender);
+
+ // close peer connections
+ foreach(QIODevice *device, _peerByteCount.keys()) {
+ device->close();
+ delete device;
+ }
}
void SignalProxy::setProxyMode(ProxyMode mode) {
return true;
}
-void SignalProxy::removePeerBySender() {
- // OK we're brutal here... but since it's a private slot we know what we've got connected to it...
- QIODevice *ioDev = (QIODevice *)(sender());
- removePeer(ioDev);
- qDebug() << "Client disconnected.";
-}
-
-void SignalProxy::objectRenamed(QString oldname, QString newname) {
- const QMetaObject *meta = sender()->metaObject();
- const QByteArray className(meta->className());
- objectRenamed(className, oldname, newname);
-
- if(proxyMode() == Client)
- return;
-
- QVariantList params;
- params << className << oldname << newname;
- dispatchSignal("__objectRenamed__", params);
-}
-
-void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) {
- if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname)
- _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
-}
-
-
void SignalProxy::removePeer(QIODevice* iodev) {
if(_peerByteCount.isEmpty()) {
- qWarning() << "SignalProxy: No peers in use!";
+ qWarning() << "SignalProxy::removePeer(): No peers in use!";
return;
}
qWarning() << "SignalProxy: unknown QIODevice" << iodev;
return;
}
-
- // take a last gasp
- while(true) {
- QVariant var;
- if(readDataFromDevice(iodev, _peerByteCount[iodev], var))
- receivePeerSignal(iodev, var);
- else
- break;
- }
+
_peerByteCount.remove(iodev);
disconnect(iodev, 0, this, 0);
emit disconnected();
}
+void SignalProxy::removePeerBySender() {
+ // OK we're brutal here... but since it's a private slot we know what we've got connected to it...
+ QIODevice *ioDev = (QIODevice *)(sender());
+ removePeer(ioDev);
+ qDebug() << "Client disconnected.";
+}
+
+void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) {
+ const QMetaObject *meta = sender()->metaObject();
+ const QByteArray className(meta->className());
+ objectRenamed(className, newname, oldname);
+
+ if(proxyMode() == Client)
+ return;
+
+ QVariantList params;
+ params << "__objectRenamed__" << className << newname << oldname;
+ dispatchSignal(RpcCall, params);
+}
+
+void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname) {
+ if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) {
+ SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
+ requestInit(obj);
+ }
+}
+
void SignalProxy::setArgTypes(QObject* obj, int methodId) {
const QMetaObject *meta = obj->metaObject();
QList<QByteArray> p = meta->method(methodId).parameterTypes();
_syncSlave[className][obj->objectName()] = obj;
if(proxyMode() == Server) {
- if(obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
- connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
-
+ connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
setInitialized(obj);
} else {
requestInit(obj);
QVariantList params;
params << obj->metaObject()->className()
<< obj->objectName();
- dispatchSignal((int)InitRequest, params);
+ dispatchSignal(InitRequest, params);
}
void SignalProxy::detachSender() {
}
}
-void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList ¶ms) {
+void SignalProxy::dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList ¶ms) {
QVariantList packedFunc;
- packedFunc << identifier;
+ packedFunc << (qint16)requestType;
packedFunc << params;
writeDataToDevice(receiver, QVariant(packedFunc));
}
-void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList ¶ms) {
+void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) {
// yes I know we have a little code duplication here... it's for the sake of performance
QVariantList packedFunc;
- packedFunc << identifier;
+ packedFunc << (qint16)requestType;
packedFunc << params;
foreach(QIODevice* dev, _peerByteCount.keys())
writeDataToDevice(dev, QVariant(packedFunc));
void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) {
QVariantList params(packedFunc.toList());
+ if(params.isEmpty()) {
+ qWarning() << "SignalProxy::receivePeerSignal(): received incompatible Data:" << packedFunc;
+ return;
+ }
+
int callType = params.takeFirst().value<int>();
switch(callType) {
case HeartBeat:
return;
default:
- qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << callType;
+ qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << callType << params;
return;
}
}
<< obj->objectName()
<< initData(obj);
- dispatchSignal(sender, (int)InitData, params_);
+ dispatchSignal(sender, InitData, params_);
}
void SignalProxy::handleInitData(QIODevice *sender, const QVariantList ¶ms) {
}
void SignalProxy::sendHeartBeat() {
- dispatchSignal((int)SignalProxy::HeartBeat, QVariantList());
+ dispatchSignal(SignalProxy::HeartBeat, QVariantList());
}
void SignalProxy::dumpProxyStats() {