QObject वर्ग के बच्चों के एक पेड़ को हटाने के आलसी कार्यान्वयन

परिचय

लेख में C ++ का उपयोग करते हुए C ++ में ट्री ट्रैवर्सल के आलसी कार्यान्वयन और Qt फ्रेमवर्क से QObject वर्ग के बच्चों के साथ काम करने के लिए इंटरफ़ेस को बेहतर बनाने के उदाहरण का उपयोग किया गया है। बाल तत्वों के साथ काम करने के लिए एक कस्टम दृश्य का निर्माण विस्तार से माना जाता है, और आलसी और शास्त्रीय कार्यान्वयन दिए जाते हैं। लेख के अंत में पूर्ण स्रोत कोड के साथ भंडार का एक लिंक है।

लेखक के बारे में

मैं Qt कंपनी के नार्वे कार्यालय में एक वरिष्ठ डेवलपर के रूप में काम करता हूँ। मैं हाल ही में Qt Core, विगेट्स और QtQuick एलिमेंट विकसित कर रहा हूं। मैं C ++ और कार्यात्मक प्रोग्रामिंग में थोड़ी दिलचस्पी रखता हूं। कभी-कभी मैं रिपोर्ट बनाता हूं और लेख लिखता हूं।

Qt क्या है

Qt ग्राफिकल यूजर इंटरफेस (GUI) बनाने के लिए एक क्रॉस-प्लेटफॉर्म फ्रेमवर्क है। GUI बनाने के लिए मॉड्यूल के अलावा, Qt में एप्लिकेशन सॉफ़्टवेयर विकसित करने के लिए कई मॉड्यूल शामिल हैं। फ्रेमवर्क मुख्य रूप से C ++ प्रोग्रामिंग भाषा में डिज़ाइन किया गया है, कुछ घटक QML और जावास्क्रिप्ट का उपयोग करते हैं।

QObject कक्षा

QObject वह वर्ग है जिसके चारों ओर Qt ऑब्जेक्ट मॉडल बनाया गया है। QObject से विरासत में मिली कक्षाएं स्लॉट सिग्नल मॉडल और ईवेंट लूप में उपयोग की जा सकती हैं। इसके अलावा, QObject आपको मेटा-ऑब्जेक्ट क्लास जानकारी तक पहुंचने और ऑब्जेक्ट्स को ट्री संरचनाओं में व्यवस्थित करने की अनुमति देता है।

QObject पेड़ की संरचना

ट्री संरचना का उपयोग करने का अर्थ है कि प्रत्येक QObject ऑब्जेक्ट में एक माता-पिता और शून्य या अधिक बच्चे हो सकते हैं। मूल वस्तु बाल वस्तुओं के जीवनकाल को नियंत्रित करती है। निम्नलिखित उदाहरण में, दो बच्चों को स्वचालित रूप से हटा दिया जाएगा:

 auto parent = std::make_unique<QObject>(); auto onDestroyed = [](auto obj){ qDebug("Object %p destroyed.", obj); }; QObject::connect(new QObject(parent.get()), &QObject::destroyed, onDestroyed); QObject::connect(new QObject(parent.get()), &QObject::destroyed, onDestroyed); //       

दुर्भाग्य से, अब तक Qt API का अधिकांश भाग केवल कच्चे पॉइंटर्स के साथ काम करता है। हम इस पर काम कर रहे हैं, और शायद जल्द ही स्थिति कम से कम आंशिक रूप से बेहतर के लिए बदल जाएगी।

QObject क्लास इंटरफ़ेस आपको सभी चाइल्ड ऑब्जेक्ट्स की एक सूची प्राप्त करने और कुछ मानदंडों द्वारा खोजने की अनुमति देता है। सभी बाल वस्तुओं की सूची प्राप्त करने के उदाहरण पर विचार करें:

 auto parent = std::make_unique<QObject>(); //  10   for (std::size_t i = 0; i < 10; ++i) { auto obj = new QObject(parent.get()); obj->setObjectName(QStringLiteral("Object %1").arg(i)); } const auto& children = parent->children(); qDebug() << children; // => (QObject(0x1f7ffa0, name = "Object 0"), ...) qDebug() << children.count(); // => 10 

QObject::children मेथड, दिए गए ऑब्जेक्ट के सभी बच्चों की सूची देता है। हालाँकि, कुछ मानदंड द्वारा वस्तुओं के पूरे उपप्रकार के बीच एक खोज की आवश्यकता होती है:

 auto children = parent->findChildren<QObject>(QRegularExpression("0$")); qDebug() << children.count(); 

ऊपर दिए गए उदाहरण से पता चलता है कि QObject प्रकार के उन सभी बच्चों की सूची कैसे प्राप्त की QObject जिनका नाम 0. में समाप्त होता है। children विधि के विपरीत, findChildren विधि पेड़ को पुनरावृत्ति करता है, अर्थात यह वस्तुओं के संपूर्ण पदानुक्रम के माध्यम से खोज करता है। इस व्यवहार को Qt::FindDirectChildrenOnly को पास करके बदला जा सकता है।

बाल तत्वों के साथ काम करने के लिए इंटरफ़ेस का नुकसान

पहली नज़र में, ऐसा लग सकता है कि बच्चों के साथ काम करने के लिए इंटरफ़ेस अच्छी तरह से सोचा और लचीला है। हालांकि, वह खामियों के बिना नहीं है। आइए उनमें से कुछ पर विचार करें:

• निरर्थक इंटरफ़ेस
  दो अलग-अलग findChildren विधियां हैं (बहुत पहले तीन नहीं थे): एक आइटम और बच्चों के लिए findChild विधि। वे सभी आंशिक रूप से ओवरलैप करते हैं।
• इंटरफ़ेस को बदलना मुश्किल है
  Qt बाइनरी संगतता और एकल प्रमुख रिलीज़ में स्रोत कोड स्तर पर संगतता की गारंटी देता है। इसलिए, आप केवल एक विधि के हस्ताक्षर को बदल नहीं सकते हैं या नए तरीके नहीं जोड़ सकते हैं।
• इंटरफ़ेस का विस्तार करना मुश्किल है
  संगतता के उल्लंघन के अलावा, यह असंभव है, उदाहरण के लिए, एक निर्दिष्ट मानदंड के अनुसार बाल तत्वों की सूची प्राप्त करना। इस कार्यक्षमता को जोड़ने के लिए, आपको अगली रिलीज़ की प्रतीक्षा करनी होगी या कोई अन्य विधि बनानी होगी।
• सभी वस्तुओं की नकल करें
  अक्सर, आपको बस दिए गए मानदंड द्वारा फ़िल्टर किए गए सभी बाल तत्वों की सूची से गुजरना होगा। ऐसा करने के लिए, इन सभी तत्वों को इंगित करने वाले कंटेनर को वापस करना आवश्यक नहीं है।
• संभावित एसआरपी का उल्लंघन
  यह एक बल्कि विवादास्पद मुद्दा है, हालांकि, क्लास इंटरफ़ेस को बदलने की आवश्यकता है, कहते हैं, बच्चों को फंसाने के लिए एक विधि अजीब लगती है।

कुछ खामियों को ठीक करने के लिए रेंज-वी 3 का उपयोग करना

रेंज-वी 3 एक पुस्तकालय है जो तत्वों की श्रेणियों के साथ काम करने के लिए घटक प्रदान करता है। वास्तव में, यह शास्त्रीय पुनरावृत्तियों पर अमूर्तता की एक अतिरिक्त परत है, जो आपको संचालन की रचना करने और ऋणात्मक समायोजन का लाभ लेने की अनुमति देता है।

एक तीसरे पक्ष के पुस्तकालय का उपयोग किया जाता है क्योंकि लेखन के समय, इस कार्यक्षमता के लिए अंतर्निहित समर्थन के साथ लेखक को ज्ञात कोई संकलक नहीं हैं। शायद स्थिति जल्द ही बदल जाएगी।

QObject इस दृष्टिकोण का उपयोग करने से हमें कक्षा से बाल तत्वों के पेड़ को QObject के संचालन को अलग करने और किसी दिए गए मानदंड के अनुसार वस्तुओं की खोज के लिए एक लचीला इंटरफ़ेस बनाने की अनुमति मिलेगी, जिसे आसानी से संशोधित किया जा सकता है।

रंग-वी 3 उदाहरण

शुरू करने के लिए, पुस्तकालय का उपयोग करने का एक सरल उदाहरण पर विचार करें। उदाहरण के लिए आगे बढ़ने से पहले, हम नेमस्पेस के लिए छोटा नोटेशन पेश करते हैं:

 namespace r = ranges; namespace v = r::views; namespace a = r::actions; 

अब एक कार्यक्रम के एक उदाहरण पर विचार करें जो रिवर्स क्रम में अंतराल [1, 10) में सभी विषम संख्याओं के क्यूब्स को प्रिंट करता है:

 auto is_odd = [](int n) { return n % 2 != 0; }; auto pow3 = [](int n) { return std::pow(n, 3); }; //  [729,343,125,27,1] std::cout << (v::ints(1, 10) | v::filter(is_odd) | v::transform(pow3) | v::reverse); 

यह ध्यान दिया जाना चाहिए कि सभी गणना आलसी होती हैं, अर्थात। अस्थायी डेटा सेट बनाए या कॉपी नहीं किए जाते हैं। इसके ऊपर का कार्यक्रम आउटपुट के प्रारूपण के अपवाद के बराबर है:

 //  729 343 125 27 1 for (int i = 9; i > 0; --i) { if (i % 2 != 0) { std::cout << std::pow(i, 3) << " "; } } 

जैसा कि आप ऊपर दिए गए उदाहरण से देख सकते हैं, पुस्तकालय आपको विभिन्न कार्यों को सुंदर ढंग से बनाने की अनुमति देता है। रेंज-v3 रिपॉजिटरी के tests और examples निर्देशिकाओं में अधिक उपयोग के उदाहरण मिल सकते हैं।

बच्चों के अनुक्रम का प्रतिनिधित्व करने के लिए कक्षा

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

QObject बाल तत्वों के साथ काम करने के लिए इस तरह की एक कक्षा बनाने के लिए, इसे सहायक वर्ग की ranges::view_facade से विरासत में प्राप्त किया जाना चाहिए ranges::view_facade

 namespace qt::detail { template <class T = QObject> class children_view : public r::view_facade<children_view<T>> { //   friend r::range_access; //   ,       T *obj; //    (  ) Qt::FindChildOptions opts; //  --    cursor begin_cursor() { return cursor(obj, opts); } public: //  }; } // namespace qt::detail 

यह ध्यान देने योग्य है कि वर्ग स्वचालित रूप से end_cursor विधि को परिभाषित करता है, जो अनुक्रम के अंत का संकेत देता है। यदि आवश्यक हो, तो इस विधि को ओवरराइड किया जा सकता है।

अगला, हम कर्सर वर्ग को ही परिभाषित करते हैं। इसे children_view क्लास के अंदर और उसके बाहर भी किया जा सकता है:

 struct cursor { // ,      std::shared_ptr<ObjectVector> children; //    std::size_t current_index = 0; //       decltype(auto) read() const { return (*children)[current_index]; } //     void next() { ++current_index; } //     auto equal(ranges::default_sentinel_t) const { return current_index == children->size(); } //  }; 

ऊपर परिभाषित कर्सर सिंगल-पास है। इसका मतलब है कि अनुक्रम को केवल एक दिशा में और केवल एक बार स्थानांतरित करने की अनुमति है। इस कार्यान्वयन के लिए, यह आवश्यक नहीं है, क्योंकि हम सभी बाल वस्तुओं का एक क्रम संग्रहीत करते हैं और जितनी बार चाहें उतनी बार किसी भी दिशा में उनके माध्यम से जा सकते हैं। यह दर्शाने के लिए कि आप कई बार किसी क्रम से जा सकते हैं, आपको निम्न विधि को कर्सर वर्ग में लागू करना होगा:

 auto equal(const cursor &that) const { return current_index == that.current_index; } 

अब आपको यह सुनिश्चित करने के लिए जोड़ना होगा कि बनाए गए दृश्य को संरचना में शामिल किया जा सकता है। ऐसा करने के लिए, सहायक फ़ंक्शन ranges::make_pipeable उपयोग करें ranges::make_pipeable :

 namespace qt { constexpr auto children = r::make_pipeable([](auto &&o) { return detail::children_view(o); }); constexpr auto find_children(Qt::FindChildOptions opts = Qt::FindChildrenRecursively) { return r::make_pipeable([opts](auto &&o) { return detail::children_view(o, opts); }); } } // namespace qt 

अब आप इस कोड को लिख सकते हैं:

 for (auto &&c : root | qt::children) { //     () } for (auto &&c : root | qt::find_children(Qt::FindDirectChildrenOnly)) { //     } 

मौजूदा QObject कक्षा कार्यशीलता को लागू करना

प्रस्तुति वर्ग को लागू करने के बाद, आप आसानी से बच्चों के साथ काम करने के लिए सभी कार्यक्षमता को लागू कर सकते हैं। ऐसा करने के लिए, आपको तीन कार्यों को लागू करने की आवश्यकता है:

 namespace qt { template <class T> const auto with_type = v::filter([](auto &&o) { using ObjType = std::remove_cv_t<std::remove_pointer_t<T>>; return ObjType::staticMetaObject.cast(o); }) | v::transform([](auto &&o){ return static_cast<T>(o); }); auto by_name(const QString &name) { return v::filter([name](auto &&obj) { return obj->objectName() == name; }); } auto by_re(const QRegularExpression &re) { return v::filter([re](auto &&obj) { return re.match(obj->objectName()).hasMatch(); }); } } // namespace qt 

उपयोग के उदाहरण के रूप में, निम्नलिखित कोड पर विचार करें:

 for (auto &&c : root | qt::children | qt::with_type<Foo*>) { //       Foo } 

इंटरमीडिएट के निष्कर्ष

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

वास्तव में, यह कार्यान्वयन इंटरफ़ेस के लगभग सभी सूचीबद्ध नुकसानों को पहले ही समाप्त कर देता है, सिवाय इसके कि हमें अभी भी सभी बच्चों को कंटेनर में कॉपी करना है। इस समस्या को हल करने का एक तरीका कॉरटाइन का उपयोग करना है।

कोरटाइन का उपयोग करके ऑब्जेक्ट ट्री ट्रैवर्सल का आलसी कार्यान्वयन

Coroutines (coroutines) आपको फ़ंक्शन को रोकने और बाद में इसे फिर से शुरू करने की अनुमति देता है। आप इस तकनीक को किसी प्रकार की परिमित राज्य मशीन के रूप में मान सकते हैं।

लेखन के समय, मानक पुस्तकालय में कोरटाइन के आरामदायक उपयोग के लिए आवश्यक कई महत्वपूर्ण तत्वों का अभाव है। इसलिए, एक तृतीय-पक्ष कैप्पोरो लाइब्रेरी का उपयोग करने का प्रस्ताव है, जो एक या दूसरे रूप में मानक में प्रवेश करने की संभावना है।

शुरू करने के लिए, हम उन कार्यों को लिखेंगे जो अगले बच्चे की मांग पर वापस आएंगे:

 namespace qt::detail { cppcoro::recursive_generator<QObject*> takeChildRecursivelyImpl( const QObjectList &children, Qt::FindChildOptions opts) { for (QObject *c : children) { if (opts == Qt::FindChildrenRecursively) { co_yield takeChildRecursivelyImpl(c->children(), opts); } co_yield c; } } cppcoro::recursive_generator<QObject*> takeChildRecursively( QObject *root, Qt::FindChildOptions opts = Qt::FindChildrenRecursively) { if (root) { co_yield takeChildRecursivelyImpl(root->children(), opts); } } } // namespace qt::detail 

co_yield निर्देश कॉलिंग कोड का मान लौटाता है और coroutine को रोक देता है।

अब इस कोड को children_view क्लास में एकीकृत करें। निम्न कोड केवल उन तत्वों को दिखाता है जो बदल गए हैं:

 //   children_view //   Data{obj, takeChildRecursively(obj, opts)} struct Data { T *obj; cppcoro::recursive_generator<QObject*> gen; }; std::shared_ptr<Data> m_data; // ... cursor begin_cursor() { return cursor(m_data->gen.begin()); } 

कर्सर को भी संशोधित किया जाना चाहिए:

 template <class T> struct children_view<T>::cursor { cppcoro::recursive_generator<QObject*>::iterator it; decltype(auto) read() const { return *it; } void next() { ++it; } auto equal(ranges::default_sentinel_t) const { return it == cppcoro::recursive_generator<QObject*>::iterator(nullptr); } explicit cursor(cppcoro::recursive_generator<QObject*>::iterator it): it(it) {} cursor() = default; }; 

यहाँ कर्सर केवल एक नियमित इटरेटर के आसपास एक आवरण के रूप में कार्य करता है। अतिरिक्त परिवर्तनों के बिना, बाकी कोड का उपयोग किया जा सकता है।

आलसी पेड़ के खतरे चलते हैं

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

इसका मतलब है कि कुछ मामलों में सभी तत्वों को एक कंटेनर में कॉपी करना उपयोगी है। ऐसा करने के लिए, आप निम्न सहायक फ़ंक्शन का उपयोग कर सकते हैं:

 auto children = ranges::to<std::vector>(root | qt::children); 

कड़ाई से बोलते हुए, इस मामले में कोरटाइन का उपयोग करने की आवश्यकता नहीं है और आप पहले पुनरावृत्ति से दृश्य का उपयोग कर सकते हैं।

क्या यह Qt में होगा

शायद, लेकिन अगली रिलीज में नहीं। इसके कई कारण हैं:

• अगली बड़ी रिलीज, क्यूटी 6, को आधिकारिक तौर पर C ++ 17 की आवश्यकता होगी और समर्थन करेगी, लेकिन अधिक नहीं।
• तीसरे पक्ष के पुस्तकालयों के बिना इसे लागू करने का कोई तरीका नहीं है।
• मौजूदा कोड आधार को अनुकूलित करना अपेक्षाकृत कठिन होगा।
  सबसे अधिक संभावना है, वे क्यूटी 7 रिलीज के हिस्से के रूप में इस मुद्दे पर लौट आएंगे।

निष्कर्ष

बाल तत्वों के पेड़ का पता लगाने का प्रस्तावित कार्यान्वयन नई कार्यक्षमता को जोड़ना आसान बनाता है। ऑपरेशनों के पृथक्करण के कारण, क्लीनर कोड लिखना और क्लास इंटरफ़ेस से अनावश्यक तत्वों को हटाना प्राप्त होता है।

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

हालांकि, वर्णित दृष्टिकोण में कुछ नुकसान हैं। उनमें से, कई डेवलपर्स के लिए असामान्य सिंटैक्स नोट कर सकते हैं, कार्यान्वयन और आलस्य की सापेक्ष जटिलता, जो कुछ मामलों में खतरनाक हो सकती है।

इसके साथ ही

स्रोत कोड

परियोजना के कार्यान्वयन और चर्चा में उनके योगदान के लिए मीशा श्वेतकिन ( ट्रिला ) को विशेष धन्यवाद।