XML के लिए C ++ में DSL

हमारे पास क्या है?

शुरू करने के लिए, मैं आपको उस परियोजना के बारे में थोड़ा बताऊंगा जिसमें मैं काम करता हूं और वहां सब कुछ कैसे लिखा जाता है। शायद हम में से कुछ नहीं तो ...

परियोजना एक सीआरएम प्रणाली है जिसे विशेष रूप से एक व्यावसायिक क्षेत्र के ग्राहकों के लिए विकसित किया गया है। यह परियोजना लगभग 6 वर्ष पुरानी है और विकास दल में 10 लोग शामिल हैं। भाषा: C ++ और PL / SQL।

हमारा सिस्टम प्लेन ओल्ड एक्सएमएल का उपयोग करता है, बस ऐसा हुआ। और अधिकांश भाग के लिए उपयोग किए गए XML के लिए कोई स्कीमा नहीं हैं। मैं क्या कह सकता हूं, अगर यूनिट परीक्षण केवल दूसरे वर्ष के लिए यहां टीका लगाया जाता है और प्रबंधक अभी भी उन्हें लिखने में लगने वाले समय के लिए पश्चाताप करता है। चलो ...

रास्ते के साथ, सभी सुधार तब दिखाई देते हैं जब वर्तमान स्थिति कष्टप्रद और असहनीय होती है। अब वही हुआ।

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

मानक अभ्यास

फ़ंक्शन में XML दस्तावेज़ बनाने के लिए कोड का एक उदाहरण इस प्रकार है:

::std::string request = clearCreateNode("book", createNode("author", "", "name='Freddy' surname='Smith'") + createNode("author", "", "name='Bill' surname='Joe'") + clearCreateNode("quote", "This is the best unknown book I've ever quoted!" + createNode("author", "", "name='Mr. Bob'")), "isbn='123456789' name='Some book' year='2011'"); 

मानक अभ्यास। stream क्यों नहीं? - क्योंकि तत्वों का एक घोंसला है। हालाँकि, stream पहली चीज़ है जो दिमाग में आती है, और एक अनिवार्य दृष्टिकोण के लिए, "बाईं ओर सही वस्तु को खिलाने" से कुछ अलग करना संभव नहीं है।

ठीक है, हम इसका उपयोग करते थे। आप अल्पविराम को सहन कर सकते हैं, लेकिन मैं प्रत्येक टैग को फ़ंक्शन नाम clearNode या clearCreateNode पुनरावृत्ति के लिए बर्दाश्त नहीं कर सकता। और इससे कोई फर्क नहीं पड़ता कि नाम कितना छोटा हो सकता है, भले ही "T" पागलपन हो। यह किसी के साथ बातचीत में, प्रत्येक टिप्पणी से पहले: "मैं कहता हूं," और प्रत्येक वाक्य से पहले, "वाक्य:", और शब्द से पहले, "शब्द:" और इतने पर दोहराता हूं। क्या यह पागलपन है?

क्या समस्या है

कोई कहेगा कि XML खुद बेमानी है - यह अच्छा है कि कम से कम कोड को टैग बंद करने की आवश्यकता नहीं है ...

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

उदाहरण के लिए, ऑब्जेक्ट पास्कल में ऐसा निर्माण होता है:

 with (Object) begin a := 1; b := "foobar"; end; 

हालाँकि, यह अच्छा है जब आप कह सकते हैं: "अब हम ऑब्जेक्ट के साथ काम कर रहे हैं, इसलिए इसकी 'एक' संपत्ति को 1 पर सेट करें, और 'बी' संपत्ति को 'फोब्बर' करने के लिए।"

"वसा की एक बूंद नहीं!"

XML पर वापस लौटना, यह है कि XML दस्तावेज़ इस तरह से DSL में कैसा दिखता है, उदाहरण के लिए, लिस्प में:

 ((book :isbn "123456789" :name "Some book" :year "2011") ((author :name "Freddy" :surname "Smith")) ((author :name "Bill" :surname "Joe")) (quote "This is the best unknown book I've ever quoted!" (author :name "Mr. Bob"))) 

यदि आप कोष्ठक पर ध्यान नहीं देते हैं, तो कोई "वसा की एक बूंद नहीं है!" अगर आप XML में <,>, /, = वर्णों पर ध्यान नहीं देते हैं और समापन टैग के अतिरेक को छोड़ देते हैं, तो आपको वही संदेश मिलेगा।

 <book isbn='123456789' name='Some book' year='2011'><author name='Freddy' surname='Smith'/><author name='Bill' surname='Joe'/><quote>This is the best unknown book I&apos;ve ever quoted!<author name='Mr. Bob'/></quote></book> 

या सुंदर प्रिंट के साथ:

 <book isbn='123456789' name='Some book' year='2011'> <author name='Freddy' surname='Smith'/> <author name='Bill' surname='Joe'/> <quote>This is the best unknown book I&apos;ve ever quoted! <author name='Mr. Bob'/> </quote> </book> 

क्या C ++ में अर्थ के समान कुछ प्राप्त करना संभव है?

परिणाम

सामान्य तौर पर, यहां वही होता है जो अंततः हुआ:

  const xml::Tag book ("book"); const xml::Tag author ("author"); const xml::Tag quote ("quote"); xml::Element request = xml::Element() (book ("isbn", "123456789") ("name", "Some book") ("year", "2011"), xml::Element() (author ("name", "Freddy") ("surname", "Smith")) (author ("name", "Bill") ("surname", "Joe")) (quote, xml::Element() ("This is the best unknown book I've ever quoted!") (author ("name", "Mr. Bob")))); 

या परियोजना में पुन: उपयोग के लिए टैग की एक सूची के चयन के साथ:

 namespace library { namespace books { const xml::Tag book ("book"); const xml::Tag author ("author"); const xml::Tag quote ("quote"); } } 

और फिर:

  namespace bks = ::library::books; xml::Element request = xml::Element() (bks::book ("isbn", "123456789") ("name", "Some book") ("year", "2011"), xml::Element() (bks::author ("name", "Freddy") ("surname", "Smith")) (bks::author ("name", "Bill") ("surname", "Joe")) (bks::quote, xml::Element() ("This is the best unknown book I've ever quoted!") (bks::author ("name", "Mr. Bob")))); 

पूरी तरह से अतिरेक से छुटकारा पाना संभव नहीं था (फिर भी, आपको अनुलग्नक बिंदु पर xml::Element() निर्दिष्ट करना होगा)। लेकिन वहाँ प्रगति है: प्रत्येक टैग के लिए यह दोहराना आवश्यक नहीं है कि यह एक TEG है, और आप निर्माणाधीन पूरे दस्तावेज़ के लिए विश्लेषिकी एकत्र कर सकते हैं और सुंदर प्रिंट या कुछ और जैसा कुछ कर सकते हैं, क्योंकि हम पहले से ही एक वस्तु के साथ काम कर रहे हैं, अधिक सटीक रूप से, एक पेड़ आम जड़।

निष्कर्ष

हम ऐसे DSL के इंटरफ़ेस को अलग कर सकते हैं, जिसमें निम्न शामिल हैं:

• Element वर्ग के शब्दार्थ संचालक:

  template <class T> void addContent(const T & content); void addEmptyTag(const Tag & tag); template <class T> void addTag(const Tag & tag, const T & content); void addTagElement(const Tag & tag, const Element & element); 

• Element क्लास के DSL ऑपरेटर:

  template <class T> inline Element & operator () (const T & content) { addContent(content); return *this; } inline Element & operator () (const Tag & tag) { addEmptyTag(tag); return *this; } template <class T> inline Element & operator () (const Tag & tag, const T & content) { addTag(tag, content); return *this; } template <> inline Element & operator () (const Tag & tag, const Element & element) { addTagElement(tag, element); return *this; } 

• नाम टैग और विशेषताओं के घोंसले के शिकार की कमी के कारण Tag वर्ग का इंटरफ़ेस, जो अलग करने के लिए इतना दिलचस्प नहीं है।

और अब यह केवल XML में DSL में लिखे कोड के संकलन के लिए विभिन्न कार्यान्वयन का आविष्कार करने के लिए बना हुआ है। यहाँ एक उदाहरण प्रयोगशाला विकल्प है:

  template <class T> void addContent(const T & content) { ::std::ostringstream oss; oss << content; buf += http_encode(oss.str()); } void addEmptyTag(const Tag & tag) { buf += createNode(tag.name, "", tag.args); } template <class T> void addTag(const Tag & tag, const T & content) { ::std::ostringstream oss; oss << content; buf += createNode(tag.name, oss.str(), tag.args); } void addTagElement(const Tag & tag, const Element & element) { buf += clearCreateNode(tag.name, element.str(), tag.args); } 

पूर्णता के लिए, मैं कक्षा कोड दे दूंगा

 class Tag { public: // DSL : template <class K> Tag & operator () (const K & attr_name) { ::std::ostringstream oss; oss << " " << attr_name; args += oss.str(); return *this; } template <class K, class T> Tag & operator () (const K & attr_name, const T & value) { ::std::ostringstream oss; oss << " " << attr_name << "='" << value << "'"; args += oss.str(); return *this; } //   DSL : template <class K> Tag operator () (const K & attr_name) const { Tag copy(*this); return copy (attr_name); } template <class K, class T> Tag operator () (const K & attr_name, const T & value) const { Tag copy(*this); return copy (attr_name, value); } //   : template <class T> Tag(const T & name) : name(name) {} Tag(const Tag & ref) : name(ref.name), args(ref.args) {} ::std::string name; ::std::string args; }; 

... और इस DSL पर कोड में एक सरल XML दस्तावेज़ का अनुवाद करने के लिए एक XSLT उदाहरण:

 <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:fn="http://www.w3.org/2005/xpath-functions"> <xsl:output method="text" version="1.0" encoding="windows-1251" indent="no"/> <xsl:template match="/"> <xsl:apply-templates/> ; </xsl:template> <xsl:template match="text()">"<xsl:value-of select="."/>"</xsl:template> <xsl:template match="attribute::*"> ("<xsl:value-of select="name()"/>", "<xsl:value-of select="."/>")</xsl:template> <xsl:template match="*"><xsl:if test="child::node()">xml::Element()</xsl:if> (<xsl:value-of select="name()"/><xsl:apply-templates select="attribute::*"/><xsl:if test="child::node()">, <xsl:apply-templates/></xsl:if>)</xsl:template> </xsl:stylesheet> 

नतीजतन, हम कह सकते हैं कि यह सी ++ के लिए थोड़ा खून से डीएसएल लिखने के लिए निकला। अब अगला आइटम C ++ में SQL कोड का समावेश होगा ...

बिताए गए समय के लिए धन्यवाद, मुझे आशा है कि आपको विषय पसंद आया।