X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsyncableobject.cpp;h=825b97db32d62a2a787fe1a6e7b533f8581c5969;hp=426bc86cf28dd3d8f122a7e85285c6af44c5e87c;hb=673ded0d543cbdc2cf6e746b6bee7c1d21af8f90;hpb=f2e4609f070221a010eef8be98524c5ce88d228b diff --git a/src/common/syncableobject.cpp b/src/common/syncableobject.cpp index 426bc86c..825b97db 100644 --- a/src/common/syncableobject.cpp +++ b/src/common/syncableobject.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel IRC Team * + * Copyright (C) 2005-2020 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -15,127 +15,178 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ -#include +#include "syncableobject.h" #include - -#include "syncableobject.h" +#include #include "signalproxy.h" #include "util.h" -SyncableObject::SyncableObject(QObject *parent) - : QObject(parent), - _initialized(false), - _allowClientUpdates(false) +SyncableObject::SyncableObject(QObject* parent) + : SyncableObject(QString{}, parent) +{} + +SyncableObject::SyncableObject(const QString& objectName, QObject* parent) + : QObject(parent) { + _objectName = objectName; + setObjectName(objectName); + + connect(this, &QObject::objectNameChanged, this, [this](auto&& newName) { + for (auto&& proxy : _signalProxies) { + proxy->renameObject(this, newName, _objectName); + } + _objectName = newName; + }); } -SyncableObject::SyncableObject(const SyncableObject &other, QObject *parent) - : QObject(parent), - _initialized(other._initialized), - _allowClientUpdates(false) +SyncableObject::~SyncableObject() { + QList::iterator proxyIter = _signalProxies.begin(); + while (proxyIter != _signalProxies.end()) { + SignalProxy* proxy = (*proxyIter); + proxyIter = _signalProxies.erase(proxyIter); + proxy->stopSynchronize(this); + } } -bool SyncableObject::isInitialized() const { - return _initialized; +bool SyncableObject::isInitialized() const +{ + return _initialized; } -void SyncableObject::setInitialized() { - _initialized = true; - emit initDone(); +void SyncableObject::setInitialized() +{ + _initialized = true; + emit initDone(); } -QVariantMap SyncableObject::toVariantMap() { - QVariantMap properties; - - const QMetaObject* meta = metaObject(); - - // we collect data from properties - QMetaProperty prop; - QString propName; - for(int i = 0; i < meta->propertyCount(); i++) { - prop = meta->property(i); - propName = QString(prop.name()); - if(propName == "objectName") - continue; - properties[propName] = prop.read(this); - } - - // ...as well as methods, which have names starting with "init" - for(int i = 0; i < meta->methodCount(); i++) { - QMetaMethod method = meta->method(i); - QString methodname(::methodName(method)); - if(!methodname.startsWith("init") || methodname.startsWith("initSet") || methodname.startsWith("initDone")) - continue; - - QVariant::Type variantType = QVariant::nameToType(method.typeName()); - if(variantType == QVariant::Invalid && !QByteArray(method.typeName()).isEmpty()) { - qWarning() << "SyncableObject::toVariantMap(): cannot fetch init data for:" << this << method.signature() << "- Returntype is unknown to Qt's MetaSystem:" << QByteArray(method.typeName()); - continue; +QVariantMap SyncableObject::toVariantMap() +{ + QVariantMap properties; + + const QMetaObject* meta = metaObject(); + + // we collect data from properties + QMetaProperty prop; + QString propName; + for (int i = 0; i < meta->propertyCount(); i++) { + prop = meta->property(i); + propName = QString(prop.name()); + if (propName == "objectName") + continue; + properties[propName] = prop.read(this); } - QVariant value = QVariant(variantType); - QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value); - QMetaObject::invokeMethod(this, methodname.toAscii(), genericvalue); - - properties[SignalProxy::methodBaseName(method)] = value; - // qDebug() << ">>> SYNC:" << methodBaseName(method) << value; - } - // properties["Payload"] = QByteArray(10000000, 'a'); // for testing purposes - return properties; + // ...as well as methods, which have names starting with "init" + for (int i = 0; i < meta->methodCount(); i++) { + QMetaMethod method = meta->method(i); + QString methodname(SignalProxy::ExtendedMetaObject::methodName(method)); + if (!methodname.startsWith("init") || methodname.startsWith("initSet") || methodname.startsWith("initDone")) + continue; + + QVariant::Type variantType = QVariant::nameToType(method.typeName()); + if (variantType == QVariant::Invalid && !QByteArray(method.typeName()).isEmpty()) { + qWarning() << "SyncableObject::toVariantMap(): cannot fetch init data for:" << this << method.methodSignature() + << "- Returntype is unknown to Qt's MetaSystem:" << QByteArray(method.typeName()); + continue; + } + + QVariant value(variantType, (const void*)nullptr); + QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), value.data()); + QMetaObject::invokeMethod(this, methodname.toLatin1(), genericvalue); + + properties[SignalProxy::ExtendedMetaObject::methodBaseName(method)] = value; + } + return properties; } -void SyncableObject::fromVariantMap(const QVariantMap &properties) { - const QMetaObject *meta = metaObject(); +void SyncableObject::fromVariantMap(const QVariantMap& properties) +{ + const QMetaObject* meta = metaObject(); + + QVariantMap::const_iterator iterator = properties.constBegin(); + QString propName; + while (iterator != properties.constEnd()) { + propName = iterator.key(); + if (propName == "objectName") { + ++iterator; + continue; + } + + int propertyIndex = meta->indexOfProperty(propName.toLatin1()); + + if (propertyIndex == -1 || !meta->property(propertyIndex).isWritable()) + setInitValue(propName, iterator.value()); + else + setProperty(propName.toLatin1(), iterator.value()); + // qDebug() << "<<< SYNC:" << name << iterator.value(); + ++iterator; + } +} - QVariantMap::const_iterator iterator = properties.constBegin(); - QString propName; - while(iterator != properties.constEnd()) { - propName = iterator.key(); - if(propName == "objectName") { - iterator++; - continue; +bool SyncableObject::setInitValue(const QString& property, const QVariant& value) +{ + QString handlername = QString("initSet") + property; + handlername[7] = handlername[7].toUpper(); + + QString methodSignature = QString("%1(%2)").arg(handlername).arg(value.typeName()); + int methodIdx = metaObject()->indexOfMethod(methodSignature.toLatin1().constData()); + if (methodIdx < 0) { + QByteArray normedMethodName = QMetaObject::normalizedSignature(methodSignature.toLatin1().constData()); + methodIdx = metaObject()->indexOfMethod(normedMethodName.constData()); } - - int propertyIndex = meta->indexOfProperty(propName.toAscii()); - - if(propertyIndex == -1 || !meta->property(propertyIndex).isWritable()) - setInitValue(propName, iterator.value()); - else - setProperty(propName.toAscii(), iterator.value()); - // qDebug() << "<<< SYNC:" << name << iterator.value(); - iterator++; - } + if (methodIdx < 0) { + return false; + } + + QGenericArgument param(value.typeName(), value.constData()); + return QMetaObject::invokeMethod(this, handlername.toLatin1(), param); +} + +void SyncableObject::update(const QVariantMap& properties) +{ + fromVariantMap(properties); + SYNC(ARG(properties)) + emit updated(); } -bool SyncableObject::setInitValue(const QString &property, const QVariant &value) { - QString handlername = QString("initSet") + property; - handlername[7] = handlername[7].toUpper(); - QGenericArgument param(value.typeName(), value.constData()); - return QMetaObject::invokeMethod(this, handlername.toAscii(), param); +void SyncableObject::requestUpdate(const QVariantMap& properties) +{ + if (allowClientUpdates()) { + update(properties); + } + REQUEST(ARG(properties)) } -void SyncableObject::renameObject(const QString &newName) { - const QString oldName = objectName(); - if(oldName != newName) { - setObjectName(newName); - emit objectRenamed(newName, oldName); - } +void SyncableObject::sync_call__(SignalProxy::ProxyMode modeType, const char* funcname, ...) const +{ + // qDebug() << Q_FUNC_INFO << modeType << funcname; + foreach (SignalProxy* proxy, _signalProxies) { + va_list ap; + va_start(ap, funcname); + proxy->sync_call__(this, modeType, funcname, ap); + va_end(ap); + } } -void SyncableObject::update(const QVariantMap &properties) { - fromVariantMap(properties); - emit updated(properties); +void SyncableObject::synchronize(SignalProxy* proxy) +{ + if (_signalProxies.contains(proxy)) + return; + _signalProxies << proxy; } -void SyncableObject::requestUpdate(const QVariantMap &properties) { - if(allowClientUpdates()) { - update(properties); - } - emit updateRequested(properties); +void SyncableObject::stopSynchronize(SignalProxy* proxy) +{ + for (int i = 0; i < _signalProxies.count(); i++) { + if (_signalProxies[i] == proxy) { + _signalProxies.removeAt(i); + break; + } + } }