Qt Meta System over Network. Часть 1 — свойства

У меня с завидной регулярностью появляется задача написания клиент-серверных приложений с использованием Qt. И я подумал – почему бы не упростить этот процесс? В самом деле, зачем каждый раз изобретать какой-то новый протокол, если можно использовать привычные сигналы и слоты? Что-то подобное уже есть, например D-Bus или QRemoteSignal, но мне они показались не очень удобными, да и некоторых возможностей в них нет.

Согласитесь, было бы очень удобно писать как-то так:
Компьютер 1:

// делаем доступным для изменения свойство xValue net.addProprety("value", "xValue", object); // добавляем сигнал net.addSignal("started", object, SIGNAL(started(int, QString)));  // добавляем функцию net.addFunction("start", object, "method_name"); 

Компьютер 2:

// устанавливаем значение свойства напрямую net.setProperty("value", 123); // подключаем к свойству какой-либо элемент управления, например QLineEdit net.bindProperty("value", lineEdit, "text"); // подключаемся к удалённому сигналу net.connect(SIGNAL(started(int, QString)), object, SLOT(onStarted(int, QString))); // вызываем функцию (блокирующий вызов) bool ok; QVariant ret = net.call("start", QVariantList() << "str1" << 1, &ok); // либо так (будет вызван слот после выполнения либо ошибки) net.call("start", QVariantList() << "str1" << 1, object, SLOT(startCalled(bool, QVariant))); 

net – это какой либо абстрактный интерфейс доступа к сети

Так же без труда можно написать методы, делающие доступными сразу целый список свойств или сигналов объекта. И это ещё не всё! Можно легко приделать ко всему этому Qt Quick. В общем, разобравшись с тем, как же всё-таки узнавать об изменении свойств, ловить сигналы, и выполнять любые слоты во время выполнения с любыми типами, можно сделать очень многое.
Начнём с наиболее простого – свойств.

1. Свойства

Сначала рассмотрим как изменять любые свойства динамически, и что более важно получать сигналы об их изменении вида: <имя свойства, новое значение>

Именно в имени свойства и заключается проблема — если подключать сигнал об изменении всех свойств к одному слоту, то мы не сможем узнать имя изменившегося свойства. Мы можем узнать только, кто отправил это изменение с помощью функции sender(), а вот имя свойства таким образом никак не узнать. Тут сразу приходит на ум создавать для каждого свойства объект какого-либо класса, который будет хранить имя свойства, принимать сигнал об его изменении, и генерировать новый сигнал, но уже с именем.

Метод «в лоб»

Class Property { public: Proprety(const QString &name) : m_name(name) {} public slots: void propertyChanged(const QVariant &newValue) { 	emit mapped(m_name, newValue); } signals: void mapped(const QString &propertyName, const QVariant &newValue); } 

Теперь если мы хотим узнавать об изменении свойств p1, p2 объекта object, мы можем написать следующий код:

PropertyMapper *m1 = new PropertyMapper("p1"); connect(object, SIGNAL(p1Changed(QVariant)), m1, SLOT(propertyChanged(QVariant));  PropertyMapper *m2 = new PropertyMapper("p2"); connect(object, SIGNAL(p2Changed(QVariant)), m2, SLOT(propertyChanged(QVariant)); 

Далее просто подключаемся к сигналу PropertyMapper::mapped и получаем сигналы с именем свойства и его новым значением. Но тут сразу видно очевидные проблемы: бесполезная трата памяти и ресурсов процессора, а так же, что наверное более важно, невозможность работать со свойствами других типов без создания дополнительных слотов под каждый тип, преобразований, и т.д. В общем есть гораздо более элегантный способ, решающий все эти проблемы разом.

Продвинутый метод

Для начала давайте разберемся, как происходит вызов слота, и как работает функция QObject::connect().
Вызов слота
Макрос Q_OBJECT добавленный в объявление класса приводит (помимо всего остального) к добавлению метода qt_metacall(). Именно через него и вызываются слоты, устанавливаются свойства. Причём все проверки на существование слота, приведение аргументов реализованы именно в ней. Стандартная реализация выглядит приблизительно так:

int Counter::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) {         switch (_id) {         case 0: valueChanged((*reinterpret_cast< int(*)>(_a[1]))); break;         case 1: setValue((*reinterpret_cast< int(*)>(_a[1]))); break;         }         _id -= 2;     }     return _id; } 

QObject::connect

Вкратце посмотрим на выполняемые этой функцией действия:
1) Преобразование имён сигналов и слотов в нормализованный вид, т.е. удаление лишних пробелов, и некоторые другие преобразования (подробнее QMetaObject::normalizedSignature())
2) Проверка соответствия типов
3) Вычисление индексов слотов и сигналов по их именам, при помощи object->metaObject()->indexOfSlot(indexOfSignal) ()
4) И самое интересное – соединение сигнала со слотом по индексам при помощи QMetaObject::connect().
Я думаю, многие уже догадались, что нужно сделать – написать свою реализацию qt_metacall и подключиться к сигналу об изменении свойства вручную. Приступим:

PropertyMapper.h

class PropertyMapper : public QObject // обратите внимание на отсутствие Q_OBJECT { public:     PropertyMapper(QObject *mapToObject, const char *mapToMethod, QObject *parent = 0);     int addProperty(const QString &propertyName, const char *mappingPropertyName,                      QObject *mappingObject, bool isQuickProperty);     void setMappedProperty(const QString &name, const QVariant &value);     QVariant mappedProperty(const QString &name) const;     int qt_metacall(QMetaObject::Call call, int id, void **arguments); private:     QObject *m_mapTo;     const char *m_toMethod;     QHash<QString, int> m_propertyIndices;     typedef struct {         QString name;         QVariant::Type type;         const char *mappingName;         QObject *mappingObject;         bool isQuickProperty; // need to call mappingObject->property to get value         QVariant lastValue;     } property_t;     QList<property_t> m_properties; }; 

Не буду расписывать для чего нужны все поля, сейчас всё станет понятным. Рассмотрим ключевые моменты по кусочкам (целиком можно скачать в конце статьи).

Добавление свойства с именем propertyName, при этом все действия будут происходить со свойством mappingPropertyName объекта mappingObject. Если мы хотим сделать данный фокус с Qt Quick свойством, необходимо установить isQuickProperty в true (дальше станет понятно как это сделано).

Для начала проверяем нет ли свойства с таким же именем. (m_propertyIndices содержит пары имя_свойства – индекс_свойства):

int PropertyMapper::addProperty(const QString &propertyName,                                  const char *mappingPropertyName,                                  QObject *mappingObject,                                  bool isQuickProperty) {     if (m_propertyIndices.contains(propertyName)) {         qWarning() << "can't create" << propertyName << "property, already exist!";         return -1;     } 

Получаем индекс свойства, и далее по индексу QMetaProperty:

    int propertyIdx =             mappingObject->metaObject()->indexOfProperty(mappingPropertyName);     QMetaProperty metaProperty = mappingObject->metaObject()->property(propertyIdx); 

Сохраняем информацию о добавленном свойстве:

    int id = m_properties.size();     m_propertyIndices[propertyName] = id;     m_properties.push_back({propertyName, metaProperty.type(),                             mappingPropertyName, mappingObject,                             isQuickProperty, QVariant()}); 

Теперь самое интересное – получаем индекс сигнала об изменении свойства, и подключаемся к нему, проверка типов не выполняется, т.к. мы сохраняем тип свойства (metaProperty.type()) и будем приводить к нему полученное значение свойства:

    int signalId = metaProperty.notifySignalIndex();     if (signalId < 0) {         qWarning() << "can't create" << propertyName << "(notify signal doesn't exist)";         return -1;     }      if (!QMetaObject::connect(mappingObject, signalId,                          this, id + metaObject()->methodCount())) {         qWarning() << "can't connect to notify signal:" << mappingPropertyName;         return -1;     }      return id; } 

И самое главное – qt_metacall():

int PropertyMapper::qt_metacall(QMetaObject::Call call, int id, void **arguments) { // Проверяем, что вызывается слот, так же, что он существует     id = QObject::qt_metacall(call, id, arguments);     if (id < 0 || call != QMetaObject::InvokeMetaMethod)         return id;     Q_ASSERT(id < m_properties.size()); 

Получаем сохранённую ранее информацию о свойстве:

    property_t &p = m_properties[id]; 

Фокус с quick свойством: т.к. сигнал об изменении quick свойства имеет вид smthChanged() т.е. без собственно значения, получаем его вручную. А далее просто вызываем указанный при создании объекта класса метод (мы не можем сгенерировать сигнал, т.к. не добавили макрос Q_OBJECT, конечно можно сделать и без него, но зачем всё усложнять без необходимости…):

    QVariant value;     if (p.isQuickProperty) {         value = p.mappingObject->property(p.mappingName);     } else {         const void *data = arguments[1];         value = QVariant(p.type, data);     }      if (value != p.lastValue) {         p.lastValue = value;         QMetaObject::invokeMethod(m_mapTo, m_toMethod,                                   Q_ARG(QString, p.name),                                   Q_ARG(QVariant, value));     }      return -1; } 

Так же мы храним последнее значение свойства, этого можно не делать, только если у нас один клиент и один сервер, а вот если участников много, то изменение свойства извне может привести к лавинному эффекту (а именно к многократной установке это свойства в одно и тоже значение).

Небольшой пример использования:

Reciever reciever; PropertyMapper mapper(&reciever, "mapped");  Tester tester; mapper.addProperty("value_m", "value", &tester); mapper.addProperty("name_m", "name", &tester);  tester.setName("Button1"); tester.setValue(123); 

Tester — всего лишь содержит два свойства, а Reciever следующий метод:

Q_INVOKABLE void mapped(const QString &propertyName, const QVariant &newValue) {     qDebug() << propertyName << newValue; } 

Запускаем:

«name_m» QVariant(QString, «Button1»)
«value_m» QVariant(int, 123)

На сегодня всё:)

Класс целиком