दिलचस्प पोस्ट
कमांड लाइन पर इनपुट छुपाएं एक MongoDB डेटाबेस में छवियों को स्टोर करें पायथन 3 में फ़िल्टर, मानचित्र, और कम करने के तरीके मूल वस्तु को बदलने के लिए मैं एक एक्सटेंशन विधि कैसे प्राप्त करूं? क्या एचटीएमएल 5 मार्गों का उपयोग करते समय काजल 2 के राउटर का टूटना है? मैं 30 दिन के लिए एक परीक्षण संस्करण के रूप में अपना उत्पाद कैसे बना सकता हूं? त्रुटि: java.util.zip.ZipException: डुप्लिकेट प्रविष्टि एचडीएफएस त्रुटि: केवल 1 के स्थान पर, 0 नोड्स को दोहराया जा सकता है मैं Microsoft Azure मेमोरी में एक लीज्ड ब्लॉब को कैसे हटा सकता / सकती हूं? पायथन में स्ट्रिंग फ़ॉर्मेटिंग पेज ExecJS :: ProgramError पृष्ठों # होम में रेल? क्या मैक पर "वॉच" या "इनॉटिफाइवेट" जैसी कोई आज्ञा है? C ++ कंसोल एप्लिकेशन को तुरंत से बाहर निकलने से कैसे रोकें? रेल 4 में सीएसएस में छवियों का संदर्भ कैसे करें कॉरस: प्रवेश-नियंत्रण-अनुमति-मूल में वाइल्डकार्ड का उपयोग नहीं किया जा सकता है, जब क्रेडेंशियल्स ध्वज सच है

आत्मा क्यूई के एकल-सदस्यीय संरचना के साथ विशेषता प्रसार का मुद्दा

मेरे पास आत्मा क्यूई के साथ एक संकलन समस्या है जहां यह शिकायत करती है कि value_type पहचानकर्ता का सदस्य नहीं है किसी कारण के लिए, क्यूई की विशेषता प्रणाली पहचानकर्ता को एक कंटेनर प्रकार मानती है, और इसे मान प्रकार की गणना करने का प्रयास करती है।

यह इस प्रश्न के समान एक समान मुद्दा है, हालांकि, मेरा मानना ​​है कि कारण एकल सदस्य संरचना है और इस बग से संबंधित हो सकता है।

#include <string> #include <boost/spirit/include/qi.hpp> #include <boost/fusion/include/adapt_struct.hpp> using namespace boost::spirit::qi; struct identifier { std::wstring name; }; struct problem { identifier _1; identifier _2; identifier _3; }; BOOST_FUSION_ADAPT_STRUCT( identifier, (std::wstring, name) ) BOOST_FUSION_ADAPT_STRUCT( problem, (identifier, _1) (identifier, _2) (identifier, _3) ) int main(int argc, char* argv[]) { rule<std::wstring::const_iterator, identifier()> gr_identifier = eps >> raw[lexeme[(alpha | '_') >> *(alnum | '_')]]; // Ok, compiles /*rule<std::wstring::const_iterator, problem()> gr_problem = gr_identifier >> gr_identifier >> '(' >> gr_identifier >> ')';*/ // Fails rule<std::wstring::const_iterator, problem()> gr_problem = gr_identifier >> gr_identifier >> '(' > gr_identifier > ')'; std::wstring input = L"foo goo(hoo)"; /*bool dummy = phrase_parse( input.begin(), input.end(), gr_problem, space);*/ return EXIT_SUCCESS; } 

दिलचस्प, यह केवल तब होता है जब उम्मीद पार्सर का उपयोग किया जाता है (उदाहरण में परिभाषा 2 देखें)। परिभाषा 1, केवल अनुक्रम पार्सर का उपयोग करके, ठीक से संकलित (और निष्पादित)।

क्या किसी को भी इसका सही समाधान पता है?

कृपया लाइव उदाहरण भी देखें

वेब के समाधान से एकत्रित समाधान "आत्मा क्यूई के एकल-सदस्यीय संरचना के साथ विशेषता प्रसार का मुद्दा"

यह आत्मा में काफी कुख्यात बढ़त का मामला है समस्या यह है कि आत्मा में सिंगल-एलिमेंट फ्यूजन कैरेक्टन्स की विशेष केस हैंडलिंग कुछ पृथक्करण को तोड़ देती है

सामान्य रूप से कम-तुच्छ होने के लिए उजागर-विशेषता वाले पक्ष को अनुकूलित करना होता है:

 rule<It, single_member_struct()> r = eps >> XXX; // the `eps` is there to break the spell 

हालांकि, यहां काम नहीं करेगा, क्योंकि आपके (a > XXX > b) उप- vector1<decltype(member_type)> परिणाम दूसरे vector1<decltype(member_type)> और इस समय, कोई भी स्मार्ट vector1<decltype(member_type)> या eps -िंग आपको बचाएगा नहीं। [1]

लंबी कहानी कम करने के लिए, मेरे पास तीन कामकाज हैं:


1. # KEEP_STRING_WORKAROUND को परिभाषित करें

इसे कोलिरू पर लाइव देखें

जिसमें आप केवल gr_identifier को std::wstring लौटने की अनुमति देंगे [2] :

 rule<It, std::string()> gr_identifier = (alpha | '_') >> *(alnum | '_'); 

यह प्रभावशाली रूप से जादू विशेषता परिवर्तन को केवल पदचिन्हित करता है, जो identifier में फ्यूजन अनुकूलन का उपयोग करता है, और इस तरह वर्तनी को तोड़ता है:

 rule<It, problem(), qi::space_type> gr_problem = gr_identifier >> gr_identifier >> ('(' > gr_identifier > ')') ; 

बस काम करता है मुझे लगता है कि यह संभवतः कम से कम दखलपूर्ण समाधान है


2. # DUMMY_WORKAROUND को परिभाषित करें

इसे कोलिरू पर लाइव देखें

जिसके माध्यम से आप मेगिक्स को अनजिनक्स कर सकते हैं … identifier संरचना को एक एकल तत्व संलयन अनुक्रम में रूपांतरित नहीं किया जाता है। हाँ। इसमें एक डमी फील्ड जोड़ने के एविल हैक ™ शामिल है। भ्रम को कम करने के लिए, इसे ' qi::unused_type बनाने की सुविधा देता है:

 struct identifier { std::string name; qi::unused_type dummy; }; BOOST_FUSION_ADAPT_STRUCT( identifier, (std::string, name) (qi::unused_type, dummy) ) 

और अब:

 rule<It, identifier()> gr_identifier = (alpha | '_') >> *(alnum | '_') >> attr(42); // that's hacky 

काम करता है


3. # परिभाषित करें NO_ADAPT_WORKAROUND

इसे कोलिरू पर लाइव देखें

अंतिम समाधान सबसे स्पष्ट हो सकता है: संरचना को पहली जगह में संलयन अनुक्रम के रूप में न लगाएं, और लाभ:

 struct identifier { std::string name; identifier() = default; explicit identifier(std::string name) : name(std::move(name)) {} }; 

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

अभी व,

 rule<It, identifier()> gr_identifier = as_string [ (alpha | '_') >> *(alnum | '_') ]; // cleaner... but no fusion 

काम करता है। यदि आपको अन्य उद्देश्यों के लिए प्रकार की फ्यूजन की आवश्यकता नहीं है तो यह अधिक सहज हो सकता है

नोट: इस संस्करण को संकलन-समय में सबसे अधिक कुशल हो सकता है

सारांश

मैं आपके कोड के लिए सोचता हूं, 2 पूरी तरह व्यवहार्य वर्कअराउंड (# 1 और # 3), और एक कम-तारकीय (डमी फील्ड वाला एक) है, लेकिन मैंने इसे दस्तावेजी प्रयोजनों के लिए शामिल किया था

पूर्ण कोड

आगामी संदर्भ के लिए

 #define BOOST_SPIRIT_DEBUG #include <string> #include <boost/spirit/include/qi.hpp> #include <boost/fusion/include/adapt_struct.hpp> namespace qi = boost::spirit::qi; ////////////////////////////////////////// // Select workaround to demonstrate #define KEEP_STRING_WORKAROUND // #define DUMMY_WORKAROUND™ // #define NO_ADAPT_WORKAROUND ////////////////////////////////////////// #if defined(KEEP_STRING_WORKAROUND) struct identifier { std::string name; }; BOOST_FUSION_ADAPT_STRUCT( identifier, (std::string, name) ) #elif defined(DUMMY_WORKAROUND) struct identifier { std::string name; qi::unused_type dummy; }; BOOST_FUSION_ADAPT_STRUCT( identifier, (std::string, name) (qi::unused_type, dummy) ) #elif defined(NO_ADAPT_WORKAROUND) struct identifier { std::string name; identifier() = default; explicit identifier(std::string name) : name(std::move(name)) {} }; #endif struct problem { identifier _1; identifier _2; identifier _3; }; BOOST_FUSION_ADAPT_STRUCT( problem, (identifier, _1) (identifier, _2) (identifier, _3) ) ////////////////////////////////////////// // For BOOST_SPIRIT_DEBUG only: static inline std::ostream& operator<<(std::ostream& os, identifier const& id) { return os << id.name; } ////////////////////////////////////////// int main() { using namespace qi; typedef std::string::const_iterator It; #if defined(KEEP_STRING_WORKAROUND) rule<It, std::string()> gr_identifier = (alpha | '_') >> *(alnum | '_'); #elif defined(DUMMY_WORKAROUND) rule<It, identifier()> gr_identifier = (alpha | '_') >> *(alnum | '_') >> attr(42); // that's hacky #elif defined(NO_ADAPT_WORKAROUND) rule<It, identifier()> gr_identifier = as_string [ (alpha | '_') >> *(alnum | '_') ]; // cleaner... but no fusion #endif rule<It, problem(), qi::space_type> gr_problem = gr_identifier >> gr_identifier >> ('(' > gr_identifier > ')') ; std::string input = "foo goo(hoo)"; BOOST_SPIRIT_DEBUG_NODES((gr_problem)(gr_identifier)); It f(begin(input)), l(end(input)); bool dummy = phrase_parse(f, l, gr_problem, qi::space); return dummy? 0 : 255; } 

[1] मेरा विश्वास करो, मैंने कोशिश की, यहां तक ​​कि qi::unused_type "नकली" विशेषताओं को डालने और / या attr_cast<> या सहायक नियमों का इस्तेमाल करने के दौरान attr_cast<>

[2] डेमो प्रयोजनों के लिए, मैंने std::string प्रयोग किया क्योंकि मेरा मानना ​​है कि यह BOOST_SPIRIT_DEBUG के साथ बेहतर मिश्रण है