👨🏽‍💼 👨 🧘🏽 सी ++ में सीरियल 🛒 👂🏾 🔖

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

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

1. प्रारंभिक जानकारी

यह आलेख एक द्विआधारी डेटा प्रारूप का उपयोग करेगा, जिसकी संरचना क्रमबद्ध वस्तुओं के प्रकारों के आधार पर निर्धारित की जाती है। यह दृष्टिकोण हमें तृतीय-पक्ष पुस्तकालयों का उपयोग करने से बचाता है, केवल मानक C ++ पुस्तकालय द्वारा प्रदान किए गए उपकरणों तक ही सीमित करता है।

चूंकि क्रमांकन प्रक्रिया किसी वस्तु की स्थिति को बाइट्स की एक धारा में परिवर्तित करने में शामिल होती है, जो स्पष्ट रूप से लिखित संचालन के साथ होनी चाहिए, निम्न-स्तरीय विवरणों का वर्णन करते समय शब्द "क्रमांकन" के बजाय इसका उपयोग किया जाएगा। इसी तरह पढ़ने / deserialize के लिए।

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

2. समर्थित प्रकार

सबसे पहले, यह उन प्रकारों पर निर्णय लेने के लायक है जिन्हें हम समर्थन करने की योजना बनाते हैं - यह सीधे इस बात पर निर्भर करता है कि पुस्तकालय कैसे लागू किया जाएगा।

उदाहरण के लिए, यदि विकल्प सी ++ के मूलभूत प्रकारों तक सीमित है, तो एक फ़ंक्शन टेम्पलेट (जो पूर्णांक प्रकारों के मूल्यों के साथ काम करने के लिए कार्यों का एक परिवार है) और इसकी स्पष्ट विशेषज्ञता पर्याप्त होगी। प्राथमिक टेम्प्लेट (प्रकार std :: int32_t, std :: uint16_t, आदि के लिए प्रयुक्त):

template<typename T> auto write(std::ostream& os, T value) -> std::size_t { const auto pos = os.tellp(); os.write(reinterpret_cast<const char*>(&value), sizeof(value)); return static_cast<std::size_t>(os.tellp() - pos); }

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

बूल के लिए विशेषज्ञता:

 constexpr auto t_value = static_cast<std::uint8_t>('T'); constexpr auto f_value = static_cast<std::uint8_t>('F'); template<> auto write(std::ostream& os, bool value) -> std::size_t { const auto pos = os.tellp(); const auto tmp = (value) ? t_value : f_value; os.write(reinterpret_cast<const char*>(&tmp), sizeof(tmp)); return static_cast<std::size_t>(os.tellp() - pos); }

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

कंटेनर std :: string पर विचार करें: यह स्पष्ट है कि हम निर्दिष्ट प्रकार के ऑब्जेक्ट का पता नहीं लगा सकते हैं, इसे एक सूचक को चार करने के लिए डालें और इसे आउटपुट स्ट्रीम पर लिखें - इसका मतलब है कि हमें विशेषज्ञता की आवश्यकता है:

 template<> auto write(std::ostream& os, const std::string& value) -> std::size_t { const auto pos = os.tellp(); const auto len = static_cast<std::uint32_t>(value.size()); os.write(reinterpret_cast<const char*>(&len), sizeof(len)); if (len > 0) os.write(value.data(), len); return static_cast<std::size_t>(os.tellp() - pos); }

यहाँ बनाने के लिए दो महत्वपूर्ण बिंदु:

न केवल स्ट्रिंग की सामग्री आउटपुट स्ट्रीम पर लिखी जाती है, बल्कि इसका आकार भी।
Cast std :: string :: size_type to std :: uint32_t टाइप करें। इस मामले में, यह लक्ष्य प्रकार के आकार पर ध्यान देने योग्य नहीं है, लेकिन इस तथ्य से कि यह एक निश्चित लंबाई का है। इस तरह की कमी मामले में समस्याओं से बचने की अनुमति देगी, उदाहरण के लिए, अगर डेटा को मशीन के बीच नेटवर्क पर विभिन्न मशीन शब्द आकारों के साथ प्रेषित किया जाता है।

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

 template<typename T> auto write(std::ostream& os, const std::vector<T>& value) -> std::size_t { const auto pos = os.tellp(); const auto len = static_cast<std::uint16_t>(value.size()); os.write(reinterpret_cast<const char*>(&len), sizeof(len)); auto size = static_cast<std::size_t>(os.tellp() - pos); if (len > 0) { std::for_each(value.cbegin(), value.cend(), [&](const auto& e) { size += ::write(os, e); }); } return size; }

, तब std के साथ: मानचित्र - नहीं, क्योंकि std :: मानचित्र टेम्पलेट के लिए कम से कम दो मापदंडों की आवश्यकता होती है - कुंजी प्रकार और मान प्रकार। इस प्रकार, इस स्तर पर, हम फ़ंक्शन टेम्पलेट का उपयोग नहीं कर सकते हैं - हमें अधिक सार्वभौमिक समाधान की आवश्यकता है। इससे पहले कि हम यह पता लगाएं कि कंटेनर समर्थन कैसे जोड़ा जाए, आइए याद करें कि हमारे पास अभी भी कस्टम कक्षाएं हैं। जाहिर है, यहां तक कि वर्तमान समाधान का उपयोग करते हुए, प्रत्येक वर्ग के लिए लेखन कार्य को अधिभार देना बुद्धिमानी नहीं होगी, जिसे क्रमबद्धता की आवश्यकता होती है। सर्वोत्तम स्थिति में, हम कस्टम डेटा प्रकारों के साथ काम करने वाले लेखन पैटर्न की एक विशेषज्ञता चाहते हैं। लेकिन इसके लिए यह आवश्यक है कि कक्षाएं क्रमशः स्वतंत्र रूप से क्रमांकन को नियंत्रित करने की क्षमता रखती हैं, उनके पास एक इंटरफ़ेस होना चाहिए, जो उपयोगकर्ता को इस वर्ग की वस्तुओं को क्रमबद्ध करने और उन्हें हटाने की अनुमति देगा। जैसा कि यह थोड़ी देर बाद निकलता है, यह इंटरफ़ेस कस्टम कक्षाओं के साथ काम करते समय लिखने के टेम्पलेट के लिए एक "सामान्य भाजक" के रूप में काम करेगा। इसे परिभाषित करते हैं।

 class ISerializable { protected: ~ISerializable() = default; public: virtual auto serialize(std::ostream& os) const -> std::size_t = 0; virtual auto deserialize(std::istream& is) -> std::size_t = 0; virtual auto serialized_size() const noexcept -> std::size_t = 0; };

ISerializable से विरासत में मिला कोई भी वर्ग इससे सहमत है:

ओवरराइड को क्रमबद्ध करें - आउटपुट स्ट्रीम में स्टेट (डेटा सदस्य) लिखें।
ओवरराइड डिस्क्राइबलाइज़ करें - इनपुट स्ट्रीम से स्टेट (डेटा सदस्यों का इनिशियलाइज़ेशन) पढ़ें।
ओवरराइड serialized_size - ऑब्जेक्ट की वर्तमान स्थिति के लिए क्रमबद्ध डेटा के आकार की गणना करता है।

तो, राइट टू फंक्शन टेम्पलेट: सामान्य तौर पर, हम ISerializable class के लिए स्पेशलाइजेशन लागू कर सकते हैं, लेकिन हम इसका उपयोग नहीं कर सकते, एक नज़र डालें:

 template<> auto write(std::ostream& os, const ISerializable& value) -> std::size_t { return value.serialize(os); }

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

3. स्ट्रीम_लेखक

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

इसके अलावा, हमें उपरोक्त सभी को ISerializable के बारे में ध्यान में रखना चाहिए - जाहिर है, हम type_traits का सहारा लिए बिना कई उत्तराधिकारी वर्गों के साथ समस्या को हल करने में सक्षम नहीं होंगे: C ++ 11 से शुरू होकर, std :: enable_ifit मानक पुस्तकालय में दिखाई दिया, जो आपको टेम्पलेट कक्षाओं को अनदेखा करने की अनुमति देता है। संकलन के दौरान कुछ शर्तें - और यह वही है जिसका हम लाभ उठाने जा रहे हैं।

स्ट्रीम_लेखक वर्ग टेम्पलेट :

 template<typename T, typename U = void> class stream_writer { public: static auto write(std::ostream& os, const T& value) -> std::size_t; };

लिखने की विधि की परिभाषा:

 template<typename T, typename U> auto stream_writer<T, U>::write(std::ostream& os, const T& value) -> std::size_t { const auto pos = os.tellp(); os.write(reinterpret_cast<const char*>(&value), sizeof(value)); return static_cast<std::size_t>(os.tellp() - pos); }

ISerializable के लिए विशेषज्ञता निम्नानुसार होगी:

 template<typename T> class stream_writer<T, only_if_serializable<T>> : public stream_io<T> { public: static auto write(std::ostream& os, const T& value) -> std::size_t; };

जहाँ only_if_serializable एक सहायक प्रकार है:

 template<typename T> using only_if_serializable = std::enable_if_t<std::is_base_of_v<ISerializable, T>>;

इस प्रकार, यदि टाइप T एक श्रेणी है जो ISerializable से लिया गया है, तो यह विशेषज्ञता क्रमशः प्रत्यावर्तन के लिए एक उम्मीदवार मानी जाएगी, यदि टाइप T ISerializable के समान श्रेणी पदानुक्रम में नहीं है, तो इसे संभावित उम्मीदवारों से बाहर रखा जाएगा।

यहाँ निम्नलिखित प्रश्न पूछना उचित होगा: यह कैसे काम करेगा? आखिरकार, प्राथमिक टेम्पलेट में विशिष्ट मापदंडों के समान मान होंगे जैसे कि इसकी विशेषज्ञता - <टी, शून्य>। विशेषज्ञता को वरीयता क्यों दी जाएगी, और क्या यह होगा? उत्तर: क्योंकि ऐसा व्यवहार मानक ( स्रोत ) द्वारा निर्धारित किया गया है:

(१.१) यदि वास्तव में एक मिलान विशेषज्ञता पाई जाती है, तो उस विशेषज्ञता से तात्कालिकता उत्पन्न होती है

एसटीडी के लिए विशेषज्ञता :: स्ट्रिंग अब इस तरह दिखेगा:

 template<typename T> class stream_writer<T, only_if_string<T>> { public: static auto write(std::ostream& os, const T& value) -> std::size_t; }; template<typename T> auto stream_writer<T, only_if_string<T>>::write(std::ostream& os, const T& value) -> std::size_t { const auto pos = os.tellp(); const auto len = static_cast<std::uint32_t>(value.size()); os.write(reinterpret_cast<const char*>(&len), sizeof(len)); if (len > 0) os.write(value.data(), len); return static_cast<std::size_t>(os.tellp() - pos); }

जहाँ only_if_string के रूप में घोषित किया गया है:

 template<typename T> using only_if_string = std::enable_if_t<std::is_same_v<T, std::string>>;

यह कंटेनरों में लौटने का समय है। इस स्थिति में, हम कुछ प्रकार U, या <U, V> द्वारा उपयोग किए जाने वाले कंटेनर प्रकार का उपयोग कर सकते हैं, जैसा कि std :: map के मामले में, सीधे stream_writer वर्ग के टेम्पलेट के पैरामीटर T के मान के रूप में होता है। इस प्रकार, हमारे इंटरफ़ेस में इंटरफ़ेस में कुछ भी नहीं बदलता है - यह वही है जिसके लिए हमने लक्ष्य किया था। हालांकि, सवाल यह उठता है कि स्ट्रीम_लेखक वर्ग के लिए टेम्पलेट का दूसरा पैरामीटर क्या होना चाहिए ताकि सब कुछ सही ढंग से काम करे? यह अगले अध्याय में है।

4. अवधारणाओं

पहले, मैं उपयोग की गई अवधारणाओं का एक संक्षिप्त विवरण दूंगा, और उसके बाद ही मैं अद्यतन उदाहरण दिखाऊंगा।

 template<typename T> concept String = std::is_same_v<T, std::string>;

ईमानदारी से, इस अवधारणा को धोखाधड़ी के लिए परिभाषित किया गया था, जिसे हम अगली पंक्ति में देखेंगे:

 template<typename T> concept Container = !String<T> && requires (T a) { typename T::value_type; typename T::reference; typename T::const_reference; typename T::iterator; typename T::const_iterator; typename T::size_type; { a.begin() } -> typename T::iterator; { a.end() } -> typename T::iterator; { a.cbegin() } -> typename T::const_iterator; { a.cend() } -> typename T::const_iterator; { a.clear() } -> void; };

कंटेनर में वे आवश्यकताएं होती हैं जो हम वास्तव में यह सुनिश्चित करने के लिए टाइप करते हैं कि यह कंटेनर प्रकारों में से एक है। यह बिल्कुल आवश्यकताओं का एक सेट है जिसे हमें stream_writer को लागू करते समय आवश्यकता होगी, मानक में निश्चित रूप से बहुत अधिक आवश्यकताएं हैं।

 template<typename T> concept SequenceContainer = Container<T> && requires (T a, typename T::size_type count) { { a.resize(count) } -> void; };

अनुक्रमिक कंटेनरों के लिए अवधारणा: एसटीडी :: वेक्टर, एसटीडी :: सूची, आदि।

 template<typename T> concept AssociativeContainer = Container<T> && requires (T a) { typename T::key_type; };

सहयोगी कंटेनरों के लिए संकल्पना: std :: map, std :: set, std :: unordered_map, आदि।

अब, निरंतर कंटेनरों के लिए विशेषज्ञता निर्धारित करने के लिए, जो हमारे लिए करने के लिए शेष है वह प्रकार टी पर प्रतिबंध लगाता है:

 template<typename T> requires SequenceContainer<T> class stream_writer<T, void> { public: static auto write(std::ostream& os, const T& value) -> std::size_t; }; template<typename T> requires SequenceContainer<T> auto stream_writer<T, void>::write(std::ostream& os, const T& value) -> std::size_t { const auto pos = os.tellp(); // to support std::forward_list we have to use std::distance() const auto len = static_cast<std::uint16_t>( std::distance(value.cbegin(), value.cend())); os.write(reinterpret_cast<const char*>(&len), sizeof(len)); auto size = static_cast<std::size_t>(os.tellp() - pos); if (len > 0) { using value_t = typename stream_writer::value_type; std::for_each(value.cbegin(), value.cend(), [&](const auto& item) { size += stream_writer<value_t>::write(os, item); }); } return size; }

समर्थित कंटेनर:

एसटीडी :: वेक्टर
std :: deque
एसटीडी :: सूची
std :: फॉरवर्ड_लिस्ट

इसी तरह सहयोगी कंटेनरों के लिए:

 template<typename T> requires AssociativeContainer<T> class stream_writer<T, void> : public stream_io<T> { public: static auto write(std::ostream& os, const T& value) -> std::size_t; }; template<typename T> requires AssociativeContainer<T> auto stream_writer<T, void>::write(std::ostream& os, const T& value) -> std::size_t { const auto pos = os.tellp(); const auto len = static_cast<typename stream_writer::size_type>(value.size()); os.write(reinterpret_cast<const char*>(&len), sizeof(len)); auto size = static_cast<std::size_t>(os.tellp() - pos); if (len > 0) { using value_t = typename stream_writer::value_type; std::for_each(value.cbegin(), value.cend(), [&](const auto& item) { size += stream_writer<value_t>::write(os, item); }); } return size; }

समर्थित कंटेनर:

एसटीडी :: नक्शा
std :: unordered_map
एसटीडी :: सेट
std :: unordered_set

नक्शे के मामले में, एक छोटी सी बारीकियों है, यह stream_reader के कार्यान्वयन की चिंता करता है। Std :: map <K, T> के लिए value_type क्रमशः st है :: pair <const K, T>, क्रमशः, जब हम इनपुट स्ट्रीम से रीडिंग करते समय एक सूचक को const K को पॉइंटर में डालने का प्रयास करते हैं, तो हमें एक संकलन त्रुटि मिलती है। हम इस समस्या को निम्नानुसार हल कर सकते हैं: हम जानते हैं कि साहचर्य कंटेनरों के लिए value_type या तो एक प्रकार K या std :: pair <const K, V> है, फिर हम छोटे टेम्पलेट सहायक वर्ग लिख सकते हैं, जिन्हें value_type और अंदर से मानकीकृत किया जाएगा। उस प्रकार का निर्धारण करें जिसकी हमें आवश्यकता है

एसटीडी :: सेट के लिए, सब कुछ अपरिवर्तित रहता है:

 template<typename U, typename V = void> struct converter { using type = U; };

Std :: map के लिए - कास्ट निकालें:

 template<typename U> struct converter<U, only_if_pair<U>> { using type = std::pair<std::remove_const_t<typename U::first_type>, typename U::second_type>; };

साहचर्य कंटेनरों के लिए पढ़ने की परिभाषा:

 template<typename T> requires AssociativeContainer<T> auto stream_reader<T, void>::read(std::istream& is, T& value) -> std::size_t { const auto pos = is.tellg(); typename stream_reader::size_type len = 0; is.read(reinterpret_cast<char*>(&len), sizeof(len)); auto size = static_cast<std::size_t>(is.tellg() - pos); if (len > 0) { for (auto i = 0U; i < len; ++i) { using value_t = typename converter<typename stream_reader::value_type>::type; value_t v {}; size += stream_reader<value_t>::read(is, v); value.insert(std::move(v)); } } return size; }

5. सहायक कार्य

एक उदाहरण पर विचार करें:

 class User : public ISerializable { public: User(std::string_view username, std::string_view password) : m_username(username) , m_password(password) {} SERIALIZABLE_INTERFACE protected: std::string m_username {}; std::string m_password {}; };

इस वर्ग के लिए क्रमबद्ध विधि (std :: ostream &) की परिभाषा इस तरह दिखनी चाहिए:

 auto User::serialize(std::ostream& os) const -> std::size_t { auto size = 0U; size += stream_writer<std::string>::write(os, m_username); size += stream_writer<std::string>::write(os, m_password); return size; }

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

 template<typename T> auto write(std::ostream& os, const T& value) -> std::size_t { return stream_writer<T>::write(os, value); }

अब परिभाषा इस प्रकार है:

 auto User::serialize(std::ostream& os) const -> std::size_t { auto size = 0U; size += ::write(os, m_username); size += ::write(os, m_password); return size; }

अंतिम अध्याय में कुछ और सहायक कार्यों की आवश्यकता होगी:

 template<typename T> auto write_recursive(std::ostream& os, const T& value) -> std::size_t { return ::write(os, value); } template<typename T, typename... Ts> auto write_recursive(std::ostream& os, const T& value, const Ts&... values) { auto size = write_recursive(os, value); return size + write_recursive(os, values...); } template<typename... Ts> auto write_all(std::ostream& os, const Ts&... values) -> std::size_t { return write_recursive(os, values...); }

Write_all फ़ंक्शन आपको सभी वस्तुओं को एक साथ क्रमबद्ध करने के लिए सूचीबद्ध करने की अनुमति देता है, जबकि write_recursive आउटपुट स्ट्रीम पर लिखने का सही क्रम सुनिश्चित करता है। यदि गणना का क्रम गुना-अभिव्यक्तियों के लिए परिभाषित किया गया (बशर्ते कि हम बाइनरी + ऑपरेटर का उपयोग करते हैं), हम उनका उपयोग कर सकते हैं। विशेष रूप से, फ़ंक्शन size_of_all में (इसका पहले उल्लेख नहीं किया गया था, इसका उपयोग क्रमबद्ध डेटा के आकार की गणना करने के लिए किया जाता है), यह गुना-अभिव्यक्ति है जो इनपुट-आउटपुट संचालन की अनुपस्थिति के कारण उपयोग किया जाता है।

6. कोड जनरेशन

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

एक वर्ग का एक उदाहरण जिसके लिए कोड तैयार किया जाएगा:

 class __attribute__((annotate("serializable"))) User : public ISerializable { public: User(std::string_view username, std::string_view password) : m_username(username) , m_password(password) {} User() = default; virtual ~User() = default; SERIALIZABLE_INTERFACE protected: __attribute__((annotate("serializable"))) std::string m_username {}; __attribute__((annotate("serializable"))) std::string m_password {}; };

विशेषताएँ GNU शैली में लिखी जाती हैं क्योंकि libclang C ++ 20 से विशेषता प्रारूप को पहचानने से इंकार करता है, और यह गैर-एनोटेट विशेषताओं का भी समर्थन नहीं करता है। स्रोत निर्देशिका ट्रैवर्सल:

 for (const auto& file : fs::recursive_directory_iterator(argv[1])) { if (file.is_regular_file() && file.path().extension() == ".hpp") { processTranslationUnit(file, dst); } }

ProcessTranslationUnit फ़ंक्शन की परिभाषा:

 auto processTranslationUnit(const fs::path& path, const fs::path& targetDir) -> void { const auto pathname = path.string(); arg::Context context { false, false }; auto translationUnit = arg::TranslationUnit::parse(context, pathname.c_str(), CXTranslationUnit_None); arg::ClassExtractor extractor; extractor.extract(translationUnit.cursor()); const auto& classes = extractor.classes(); for (const auto& [name, c] : classes) { SerializableDefGenerator::processClass(c, path, targetDir.string()); } }

इस फ़ंक्शन में, केवल ClassExtractor हमारे लिए ब्याज की है - एएसटी के गठन के लिए बाकी सब कुछ आवश्यक है। अर्क समारोह की परिभाषा इस प्रकार है:

   void ClassExtractor::extract(const CXCursor& cursor) { clang_visitChildren(cursor, [](CXCursor c, CXCursor, CXClientData data) { if (clang_getCursorKind(c) == CXCursorKind::CXCursor_ClassDecl) { /*   */ /* -    - */ /* -     */ } return CXChildVisit_Continue; } , this); }

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

और अंत में, processClass फ़ंक्शन में, प्रत्येक पाए गए वर्ग के क्रमांकन विशेषताओं की उपस्थिति की जाँच की जाती है, और यदि कोई है, तो एक फ़ाइल आवश्यक कार्यों की परिभाषा के साथ उत्पन्न होती है। रिपॉजिटरी विशिष्ट उदाहरण प्रदान करती है: जहां नाम स्थान का नाम / नाम प्राप्त करना है (यह जानकारी सीधे कक्षा में संग्रहीत की जाती है) और हेडर फ़ाइल का पथ।

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

और एक और छोटी टिप्पणी - मैं एक तैयार पुस्तकालय प्रदान नहीं करता हूं, मैं केवल यह बताता हूं कि इसे कैसे लिखना है।

UPD0 : लिबासैंग के बजाय cppast का उपयोग किया जा सकता है। उपलब्ध कराई गई लिंक के लिए मास्टर्सपलाइन के लिए धन्यवाद।

1. github.com/isnullxbh/dsl
2. github.com/isnullxbh/Agenta