Boost.Spirit, या सूची फिल्टर करने के लिए "आध्यात्मिकता" जोड़ें

अच्छे दिन, सहकर्मियों। मैं अभी भी एक ISPystem डेवलपर हूं, और मेरा नाम अभी भी दिमित्री स्मिरनोव है। कुछ समय के लिए (बल्कि लंबे समय के लिए) मैं अगले प्रकाशन के विषय पर फैसला नहीं कर सकता, क्योंकि बूस्ट.सियो के साथ काम करने के पिछले महीनों में बहुत सारी सामग्री जमा हो गई है। और उस पल में भी जब ऐसा लगता था कि एक सिक्का उछालना आसान था, एक कार्य ने सब कुछ बदल दिया। एक उपकरण विकसित करना आवश्यक था, जो दृश्यपटल को अनुरोधित सूचियों में डेटा को फ़िल्टर करने की अनुमति देता है। बैकएंड से ही सूची एक साधारण json_array है। Kat में आपका स्वागत है, हाल के दिनों के सभी उतार-चढ़ाव हैं।

त्याग

मुझे तुरंत कहना होगा कि पिछली बार लेखक ने "महसूस किया" कुछ साल पहले संदर्भ-मुक्त व्याकरण जैसा था। तब ऐसा लगता था कि कुछ प्रकार के बजाय स्लेड और अनावश्यक उपकरण हैं, लेकिन मैंने समस्या बयान के दिन Boost.Spirit पुस्तकालय के बारे में सीखा।

कार्य

जैसे कोई क्वेरी चालू करने की आवश्यकता है:

(string_field CP value AND int_field NOT LT 150) OR bool_field EQ true 

कुछ संरचना में जो कि json ऑब्जेक्ट की जाँच करेगा और रिपोर्ट करेगा कि यह आवश्यकताओं को पूरा करता है या नहीं।

पहला कदम

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

एक फ़नकार सही होगा, जो सीधे सामने से अनुरोध से बनाया जाएगा। चूंकि प्रोजेक्ट नोहमन :: json का उपयोग करता है, इसलिए डिजाइन काफी सुरुचिपूर्ण होगा:

 filter = "(string_field CP value AND int_field NOT LT 150) OR bool_field EQ true"; json.erase(std::remove_if(json.begin(), json.end(), std::not_fn(JsonFilter{filter})), json.end()); 

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

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

परिचित

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

आइए उदाहरण में प्रस्तुत व्याकरण को देखें:

 class ArithmeticGrammar1 : public qi::grammar<std::string::const_iterator, ASTNodePtr(), qi::space_type> { public: using Iterator = std::string::const_iterator; ArithmeticGrammar1() : ArithmeticGrammar1::base_type(start) { start = (product >> '+' >> start) [qi::_val = phx::new_<OperatorNode<'+'>> (qi::_1, qi::_2)] | product[qi::_val = qi::_1]; product = (factor >> '*' >> product) [qi::_val = phx::new_<OperatorNode<'*'>> (qi::_1, qi::_2)] | factor[qi::_val = qi::_1]; factor = group[qi::_val = qi::_1] | qi::int_[qi::_val = phx::new_<ConstantNode>(qi::_1)]; group %= '(' >> start >> ')'; } qi::rule<Iterator, ASTNodePtr(), qi::space_type> start, group, product, factor; }; 

व्याकरण को आधार qi :: व्याकरण से विरासत में मिला है। ASTNodePtr () एक स्पष्ट, लेकिन व्याकरण की वस्तु में अपेक्षित परिणाम की वस्तु को पारित करने के लिए बहुत सुविधाजनक तरीका नहीं है।

 class ASTNode { public: virtual double evaluate() = 0; virtual ~ASTNode() {} }; using ASTNodePtr = ASTNode*; template <char Operator> class OperatorNode : public ASTNode { public: OperatorNode(const ASTNodePtr &left, const ASTNodePtr &right) : left(left) , right(right) {} double evaluate() { if (Operator == '+') return left->evaluate() + right->evaluate(); else if (Operator == '*') return left->evaluate() * right->evaluate(); } ~OperatorNode() { delete left; delete right; } private: ASTNodePtr left, right; //  }; class ConstantNode : public ASTNode { public: ConstantNode(double value) : value(value) {} double evaluate() { return value; } private: double value; }; 

Boost.Phoenix लाइब्रेरी का उपयोग करते हुए, आप पार्सिंग के दौरान एक या कई गैर-टर्मिनलों से एक तैयार एएसटी नोड बना सकते हैं और सीधे परिणाम लिख सकते हैं। आइए देखें कि कैलकुलेटर में क्या है:

 start = (product >> '+' >> start)[qi::_val = phx::new_<OperatorNode<'+'>> (qi::_1, qi::_2)] | product[qi::_val = qi::_1]; 

start - वाक्य को पार्स करना शुरू करें। प्रारंभिक बिंदु। इसे उत्पाद के योग और प्रारंभ, या केवल उत्पाद के माध्यम से व्यक्त किया जा सकता है।

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

हम आगे देखते हैं। मान लीजिए कि हम दूसरे विकल्प पर आते हैं, तो प्रारंभ एक राशि नहीं है, बल्कि एक उत्पाद है। उसे कैसे व्यक्त किया जाता है?

 product = (factor >> '*' >> product) [qi::_val = phx::new_<OperatorNode<'*'>> (qi::_1, qi::_2)] | factor[qi::_val = qi::_1]; 

पिछली तस्वीर को न्यूनतम अंतर के साथ दोहराया गया है। फिर से हम किसी प्रकार की अभिव्यक्ति को पूरा करते हैं, फिर से हम परिणाम में OperatorNode ऑब्जेक्ट लिखते हैं, या बस किसी प्रकार का कारक। आइए इसे देखें।

 factor = group[qi::_val = qi::_1] | qi::int_[qi::_val = phx::new_<ConstantNode>(qi::_1)]; 

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

 factor1 = ConstantNode(1) //   ,    factor2 = ConstantNode(3) product = OperatorNode<'*'>(factor1, factor2) start = product 

प्रत्येक नोड, ऊपर से शुरू होता है (सबसे कम वाले को छोड़कर, जो अनिवार्य रूप से यहां पूर्णांक हैं), बाद के नोड्स के माध्यम से व्यक्त किया जाता है। और मूल तत्व पर मूल्यांकन () विधि का एकमात्र कॉल पूरी समस्या को हल करता है, अद्भुत!

तब qi :: space_type आपकी आंख को पकड़ता है - यह तर्क पार्स करते समय नजरअंदाज किए गए तत्वों की एक सूची है। यह अभी भी मुझ पर एक चाल खेलेंगे :-)।

यहां उल्लेखनीय बात यह है कि उत्पाद (*) के माध्यम से नॉनटर्मिनल स्टार्ट (बस युक्त +) को व्यक्त करके इसके अलावा गुणा को प्राथमिकता देने का तरीका है। मेरे व्याकरण संस्करण में, क्योंकि यह तय किया गया था कि और पर हावी होगा या, मैं बस सही स्थानों में आवश्यक तार्किक ऑपरेटरों को प्रतिस्थापित करता हूं। यदि गणितीय ऑपरेटरों को लिखने में गलती करना मुश्किल है, तो पाठ तार्किक तार्किक एक पूरी तरह से अलग कहानी है। संभावित समस्याओं के कम से कम भाग को हल करने की इच्छा है, उदाहरण के लिए, रजिस्टर। इसके लिए, आत्मा में एक अंतर्निहित प्रकार qi :: no_case है

इसके अलावा, संख्याओं के बजाय, मुझे फ़ील्ड्स के नामों की आवश्यकता होगी, इसलिए हम बिल्ट-इन qi :: int_ स्पिरिट के बजाय संबंधित नॉनटर्मिनल जोड़ते हैं :

 field = qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9"); 

और हम यहाँ इस तरह की एक सरल अभिव्यक्ति प्राप्त करते हैं (अब तक कोई शब्दार्थ संचालन नहीं):

 start = product >> qi::no_case["OR"] >> start | product; product = factor >> qi::no_case["AND"] >> product | factor; factor = group | field; group %= '(' >> start >> ')'; 

अब सब कुछ सरलतम वाक्य "फ़ील्ड और फ़ील्ड 2" को पार्स करने के लिए तैयार है। हम शुरू करते हैं और ... कुछ भी नहीं काम करता है।

समस्या एक अप्रत्याशित स्थान पर थी: क्यूई :: space_type केवल रिक्त स्थान की उपेक्षा नहीं करता है, यह उन्हें पार्स करने से पहले वाक्य से हटा देता है, और प्रारंभिक फ़िल्टर अभिव्यक्ति फॉर्म में पहले से ही पार्सिंग में आता है:

 "fieldAndfield2" \\        ,    "(5 * 5) + 11 " \\  "(5*5)+11" 

यह सिर्फ एक सिंगल फील्ड है। तदनुसार, आपको कुछ स्किपर की आवश्यकता है:

 skipper = +qi::lit(' '); //    . ,    ,   ,  ,  C++ . start = product >> skipper >> qi::no_case["OR"] >> skipper >> start | product; ... 

खेतों का विश्लेषण करने के बाद, भावों से मूल्यों को प्राप्त करना और यह समझना संभव है कि मूल्य के खिलाफ क्षेत्र को कैसे मान्य किया जाना चाहिए। सभी तुलना विकल्पों को निम्नलिखित कार्यों के माध्यम से व्यक्त किया जा सकता है:

 enum class Operator { EQ, //  LT, //  GT, //  CP //  (  ) }; unary = qi::no_case["NOT"]; // ,          

और मूल्यों को इस तरह के एक गैर में व्यक्त किया जाता है:

 value = qi::double_ | qi::int_ | qi::bool_ | string; string = qi::lit("'") >> +qi::char_("a-zA-Z0-9_. ") >> qi::lit("'"); 

अब समस्याओं के लिए कि मूल्य प्राप्त करने का ऐसा तरीका लाता है। आत्मा इसे बढ़ावा के रूप में लौटाएगी :: संस्करण <int, double, bool, std :: string> , और जब कुछ डेटा के साथ इसकी तुलना करने का समय आता है, तो वांछित प्रकार के मूल्य को प्राप्त करने के लिए कुछ ट्रिक्स की आवश्यकता होगी। यहाँ मेरे पास क्या विकल्प है:

 using ValueType = boost::variant<int, double, bool, std::string>; struct ValueGetter : public boost::static_visitor<Json> { template <typename Type> Json operator()(const Type &value) const { return value; } }; 

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

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

 class AbstractMatcher { public: AbstractMatcher() = default; virtual ~AbstractMatcher() = default; virtual bool evaluate(const Json &object) = 0; //       }; using MatcherPtr = std::shared_ptr<AbstractMatcher>; 

इसके अलावा तार्किक नोड्स मुख्य फिल्टर नोड्स हैं:

 enum class Logic { AND, OR }; template <Logic Operator> class LogicNode final : public AbstractMatcher { public: LogicNode(MatcherPtr &left, MatcherPtr &right) : m_left(std::move(left)) , m_right(std::move(right)) { switch (Operator) { case Logic::AND: m_evaluator = &LogicNode::And; break; case Logic::OR: m_evaluator = &LogicNode::Or; } } bool evaluate(const Json &object) final { return std::invoke(m_evaluator, this, object); } private: MatcherPtr m_left; MatcherPtr m_right; using EvaluateType = bool(LogicNode::*)(const Json &); EvaluateType m_evaluator = nullptr; bool And(const Json &object) { return m_left->evaluate(object) && m_right->evaluate(object); } bool Or(const Json &object) { return m_left->evaluate(object) || m_right->evaluate(object); } }; 

और अंत में, नीचे नोड

 class ObjectNode final : public AbstractMatcher { public: ObjectNode(std::string field, const ValueType &value, boost::optional<std::string> &unary, Operator oper) : m_field(std::move(field)) , m_json_value(boost::apply_visitor(ValueGetter(), value)) , m_reject(unary.has_value()) { switch (oper) { case Operator::EQ: m_evaluator = &ObjectNode::Equal; break; case Operator::LT: m_evaluator = &ObjectNode::LesserThan; break; case Operator::GT: m_evaluator = &ObjectNode::GreaterThan; break; case Operator::CP: m_evaluator = &ObjectNode::Substr; break; } } bool evaluate(const Json &object) final { const auto &value = object.at(m_field); const bool result = std::invoke(m_evaluator, this, value); return m_reject ? !result : result; } private: using EvaluateType = bool(ObjectNode::*)(const Json &); const std::string m_field; const Json m_json_value; const bool m_reject; EvaluateType m_evaluator = nullptr; bool Equal(const Json &json) { return json == m_json_value; } bool LesserThan(const Json &json) { return json < m_json_value; } bool GreaterThan(const Json &json) { return json > m_json_value; } bool Substr(const Json &json) { return Str(json).find(Str(m_json_value)) != std::string::npos; } }; 

यह केवल इसे एक साथ रखने के लिए ही रहता है:

 struct JsonFilterGrammar : qi::grammar<std::string::const_iterator, MatcherPtr()> { JsonFilterGrammar() : JsonFilterGrammar::base_type(expression) { skipper = +qi::lit(' '); unary = qi::no_case["NOT"]; compare.add ("eq", Operator::EQ) ("lt", Operator::LT) ("gt", Operator::GT) ("cp", Operator::CP); expression = (product >> skipper >> qi::no_case["OR"] >> skipper >> expression) [qi::_val = make_shared_<LogicNode<Logic::OR>>()(qi::_1, qi::_2)] | product[qi::_val = qi::_1]; product = (term >> skipper >> qi::no_case["AND"] >> skipper >> product) [qi::_val = make_shared_<LogicNode<Logic::AND>>()(qi::_1, qi::_2)]| term[qi::_val = qi::_1]; term = group[qi::_val = qi::_1] | (field >> -(skipper >> unary)>> skipper >> qi::no_case[compare] >> skipper >> value) [qi::_val = make_shared_<ObjectNode>()(qi::_1, qi::_4, qi::_2, qi::_3)]; field = qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9"); value = qi::double_ | qi::int_ | qi::bool_ | string; string = qi::lit("'") >> +qi::char_("a-zA-Z0-9_. \u20BD€$¥-") >> qi::lit("'"); group %= '(' >> expression >> ')'; } qi::rule<Iterator> skipper; qi::rule<Iterator, MatcherPtr()> product, term, expression, group; qi::rule<Iterator, std::string()> field, unary, string; qi::rule<Iterator, ValueType()> value; qi::symbols<char, Operator> compare; //      enum }; 

वह सब है। अब समाप्त फिल्टर प्राप्त करना काफी सरल ऑपरेशन बन गया है:

 MatcherPtr matcher; std::string filter = "int not LT 15"; JsonFilterGrammar grammar; qi::parse(filter.begin(), filter.end(), grammar, matcher); //     matcher   . 

मैं व्याकरण को एक फ़नकार में लपेटने की प्रक्रिया को छोड़ दूंगा (मुझे नहीं लगता कि यह किसी के लिए दिलचस्प होगा)। हम सरलतम उदाहरण का उपयोग करके बेहतर तरीके से टूल पर विचार करेंगे:

 std::string filter = "int not LT 15"; Json json{ {{"int", 10}}, {{"int", 11}}, {{"int", 20}}, {{"int", 30}}, {{"int", 9}} }; std::cout << json.dump() << std::endl; json.erase(std::remove_if(json.begin(), json.end(), std::not_fn(JsonFilter{filter})), json.end()); std::cout << json.dump() << std::endl; 

यहाँ उत्पादन है:

 [{"int":10},{"int":11},{"int":20},{"int":30},{"int":9}] [{"int":20},{"int":30}] 

मुझे आशा है, प्रिय पाठकों, आप आत्मा के मूल तत्व को जानने के साथ-साथ मुझे भी जानने में रुचि रखते थे। तब मैं रहता हूं। जल्द मिलते हैं।