नेटवर्क पर Qt मेटा सिस्टम। भाग 1 - गुण

मेरे पास क्लाइंट-सर्वर अनुप्रयोगों को लिखने का कार्य है जो Qt का उपयोग करते हैं। और मैंने सोचा - क्यों न इस प्रक्रिया को सरल बनाया जाए? वास्तव में, हर बार एक नए प्रोटोकॉल का आविष्कार क्यों करें यदि आप परिचित संकेतों और स्लॉट का उपयोग कर सकते हैं? कुछ ऐसा ही पहले से मौजूद है, उदाहरण के लिए, डी-बस या क्यूमोटाइसिग्नल, लेकिन वे मेरे लिए बहुत सुविधाजनक नहीं हैं, और वे कुछ विशेषताएं नहीं हैं।

सहमत हूँ, इस तरह से कुछ लिखना बहुत सुविधाजनक होगा:
कंप्यूटर 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))); 

नेट किसी भी सार नेटवर्क एक्सेस इंटरफ़ेस है

उन विधियों को लिखना भी आसान है जो किसी वस्तु के गुणों या संकेतों की पूरी सूची तुरंत उपलब्ध कराते हैं। और यह सब नहीं है! आप इस सब के लिए आसानी से Qt Quick संलग्न कर सकते हैं। सामान्य तौर पर, यह पता लगाना कि अभी भी गुणों को बदलने के बारे में कैसे पता चलता है, संकेतों को पकड़ना, और किसी भी प्रकार के साथ रनटाइम पर किसी भी स्लॉट को निष्पादित करना, आप बहुत कुछ कर सकते हैं।
आइए सबसे सरल - गुणों के साथ शुरू करें।

1. गुण

पहले हम देखेंगे कि किसी भी गुण को गतिशील रूप से कैसे बदला जाए, और इससे भी महत्वपूर्ण बात यह है कि उनके परिवर्तन के बारे में संकेत प्राप्त करने के लिए: <संपत्ति का नाम, नया मूल्य>

यह संपत्ति के नाम पर है कि समस्या निहित है - यदि हम सभी गुणों को एक स्लॉट में बदलने के बारे में एक संकेत को जोड़ते हैं, तो हम परिवर्तित संपत्ति के नाम का पता नहीं लगा पाएंगे। हम केवल यह पता लगा सकते हैं कि प्रेषक () फ़ंक्शन का उपयोग करके यह परिवर्तन किसने पोस्ट किया है, लेकिन संपत्ति का नाम इस तरह से नहीं मिल सकता है। फिर यह तुरंत प्रत्येक संपत्ति के लिए एक वर्ग की एक वस्तु बनाने के लिए दिमाग में आता है जो संपत्ति के नाम को संग्रहीत करेगा, इसके परिवर्तन के बारे में एक संकेत प्राप्त करेगा, और एक नया संकेत उत्पन्न करेगा, लेकिन एक नाम के साथ।

माथे की विधि

 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 में परिवर्तन के बारे में जानना चाहते हैं, तो हम निम्नलिखित कोड लिख सकते हैं:

 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 :: मैप किया गया और संपत्ति के नाम और उसके नए मूल्य के साथ सिग्नल प्राप्त करें। लेकिन यहां आप तुरंत स्पष्ट समस्याएं देख सकते हैं: स्मृति और प्रोसेसर संसाधनों की बर्बादी, साथ ही, शायद अधिक महत्वपूर्ण बात, प्रत्येक प्रकार, परिवर्तनों आदि के लिए अतिरिक्त स्लॉट बनाए बिना अन्य प्रकार के गुणों के साथ काम करने की अक्षमता। सामान्य तौर पर, बहुत अधिक सुरुचिपूर्ण तरीका है जो एक ही बार में इन सभी समस्याओं को हल करता है।

उन्नत विधि

सबसे पहले, आइए देखें कि स्लॉट कैसे कहा जाता है, और QObject :: कनेक्ट () फ़ंक्शन कैसे काम करता है।
स्लॉट कॉल
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 :: कनेक्ट

इस फ़ंक्शन द्वारा की गई क्रियाओं को संक्षेप में देखें:
1) संकेतों और स्लॉट्स के नामों का एक सामान्यीकृत रूप में रूपांतरण, अर्थात्। अतिरिक्त स्थान, और कुछ अन्य रूपांतरणों को हटाना (अधिक जानकारी QMetaObject :: normalizedSignature ())
2) प्रकार की जाँच
3) ऑब्जेक्ट्स-> मेटाऑब्जेक्ट () -> इंडेक्सऑफस्लोट (इंडेक्सऑफसिग्नल) () का उपयोग करके उनके नाम से स्लॉट्स और सिग्नल के इंडेक्स की गणना।
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; }; 

मैं पेंट नहीं करूंगा कि सभी क्षेत्रों की आवश्यकता क्यों है, अब सब कुछ स्पष्ट हो जाएगा। टुकड़ों में प्रमुख बिंदुओं पर विचार करें (लेख के अंत में पूरा डाउनलोड किया जा सकता है)।

प्रॉपर्टी नाम के साथ एक संपत्ति जोड़ना, और सभी क्रियाएं मैपिंगप्रोपरिनाम की मैपिंगऑब्जेक्ट ऑब्जेक्ट के साथ होगी। अगर हम Qt क्विक प्रॉपर्टी के साथ इसे फोकस करना चाहते हैं, तो isQuickProperty को सही पर सेट करना आवश्यक है (बाद में यह स्पष्ट हो जाएगा कि यह कैसे किया जाता है)।

पहले, जांचें कि क्या उसी नाम से कोई संपत्ति है। (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]; 

त्वरित संपत्ति के साथ ध्यान केंद्रित करें: त्वरित संपत्ति को बदलने के लिए संकेत का रूप बदल दिया गया है () वास्तविक मूल्य के बिना, हम इसे मैन्युअल रूप से प्राप्त करते हैं। और फिर हम केवल क्लास ऑब्जेक्ट बनाते समय निर्दिष्ट विधि कहते हैं (हम एक संकेत उत्पन्न नहीं कर सकते हैं, क्योंकि हमने 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); 

परीक्षक - केवल दो गुण होते हैं, और निम्न विधि को पुनः प्राप्त करें:

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

हम लॉन्च करते हैं:

"Name_m" QVariant (QString, "Button1")
"Value_m" QVariant (int, 123)

आज के लिए बस इतना ही :)

पूरी कक्षा