}
SignalProxy::~SignalProxy() {
+ 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();
}
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);
return 0;
}
-SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta) {
+SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) {
if(!_extendedMetaObjects.contains(meta)) {
- _extendedMetaObjects[meta] = new ExtendedMetaObject(meta);
+ _extendedMetaObjects[meta] = new ExtendedMetaObject(meta, checkConflicts);
}
return _extendedMetaObjects[meta];
}
}
void SignalProxy::synchronize(SyncableObject *obj) {
- createExtendedMetaObject(obj);
+ createExtendedMetaObject(obj, true);
// attaching as slave to receive sync Calls
QByteArray className(obj->syncMetaObject()->className());
_syncSlave[className][obj->objectName()] = obj;
- disconnect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
- connect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *)));
if(proxyMode() == Server) {
- connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
obj->setInitialized();
emit objectInitialized(obj);
} else {
}
void SignalProxy::detachObject(QObject *obj) {
- stopSync(obj);
detachSignals(obj);
detachSlots(obj);
}
}
}
-void SignalProxy::stopSync(QObject *obj) {
+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();
}
classIter++;
}
+ obj->stopSynchronize(this);
}
void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) {
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) {
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 {
+ if(ioPeer->sentHeartBeats > 1)
+ 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();
}
}
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++) {
dispatchSignal(Sync, params);
}
+
+
void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) {
if(!reason.isEmpty())
qWarning() << qPrintable(reason);
// ==================================================
// ExtendedMetaObject
// ==================================================
-SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta)
+SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts)
: _meta(meta),
_updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
{
continue;
}
}
- qWarning() << "class" << meta->className() << "contains overloaded methods which is currently not supported!";
- qWarning() << " - " << _meta->method(i).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature();
+ 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;
if(receiverId != -1) {
receiveMap[i] = receiverId;
- qDebug() << requestSlot.signature() << _meta->method(receiverId).signature() << "---" << i << receiverId;
}
}
_receiveMap = receiveMap;