बूस्ट प्रोग्राम विकल्प का उपयोग करके पार्स किए गए विकल्पों के अनुक्रम को कैसे निकाला जाता है?

Question

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

उदाहरण के लिए:

./bin/make_graph -c4,5,1 -w3,3 -c3,1,2 

जैसी ग्राफ़ बनाने चाहिए निम्नलिखित:

C -- W -- C 

लेकिन:

:

./bin/make_graph -c4,5,1 -c3,1,2 -w3,3 

निम्नलिखित जैसी ग्राफ़ बनाने चाहिए

boost :: program_options का उपयोग करके, मैं सटीक क्रम निकालने का तरीका निर्धारित करने में असमर्थ था क्योंकि यह value_type == वेक्टर < स्ट्रिंग> (मेरे मामले में) के साथ एक मानचित्र में एक ही स्ट्रिंग_की के विकल्पों को "composes" करता है।

मानचित्र पर पुनरावृत्ति करके, आदेश खो गया है। क्या पार्सिंग को डुप्लिकेट करने का कोई तरीका नहीं है, लेकिन हर बार एक विकल्प को पार्स किए जाने पर एक फ़ंक्शन (शायद कॉलबैक) कहा जाता है? मुझे इस दिशा में दस्तावेज़ीकरण नहीं मिला। कोई अन्य सुझाव?

आप समझा दिया है कि मैं इस अप नहीं बना रही हूँ, यहाँ क्या मैं अब तक है:

namespace bpo = boost::program_options; 
    std::vector<std::string> args_cat, args_grid, args_web; 
    bpo::options_description desc("Program options:"); 
    desc.add_options() 
      .operator()("help,h","Displays this help message.") 
      .operator()("caterpillar,c",bpo::value< std::vector<std::string> >(&args_cat)->default_value(std::vector<std::string>(1,"4,7,2"), "4,7,2"),"Caterpillar tree with 3 parameters") 
      .operator()("grid,g",bpo::value< std::vector<std::string> >(&args_grid)->default_value(std::vector<std::string>(1,"3,4"), "3,4"),"Rectangular grid with 2 parameters") 
      .operator()("web,w",bpo::value< std::vector<std::string> >(&args_web)->default_value(std::vector<std::string>(1,"3,4"), "3,4"),"Web with 2 parameters") 
      ; 
    bpo::variables_map ops; 
    bpo::store(bpo::parse_command_line(argc,argv,desc),ops); 
    bpo::notify(ops); 
    if((argc < 2) || (ops.count("help"))) { 
     std::cout << desc << std::endl; 
     return; 
    } 
    //TODO: remove the following scope block after testing 
    { 
     typedef bpo::variables_map::iterator OptionsIterator; 
     OptionsIterator it = ops.options.begin(), it_end = ops.options.end(); 
     while(it != it_end) { 
      std::cout << it->first << ": "; 
      BOOST_FOREACH(std::string value, it->second) { 
       std::cout << value << " "; 
      } 
      std::cout << std::endl; 
      ++it; 
     } 
     return; 
    } 

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

./bin/make_graph --component c,4,5,1 --component w,3,3 --component c,3,1,2 

लेकिन यह है कि (शायद भी बूस्ट कार्यक्रम विकल्प का उपयोग किए बिना) एक पार्सर/सत्यापनकर्ता अपने आप को लिखने की दिशा में आगे बढ़ रहा है:

./bin/make_graph --custom c,4,5,1,w,3,3,c,3,1,2 
./bin/make_graph c,4,5,1,w,3,3,c,3,1,2 

आप लोगों को कैसे सलाह देंगे कि मैं इसे एक सुरुचिपूर्ण तरीके से करता हूं?

अग्रिम धन्यवाद!

पीएस: मैंने इसे पोस्ट करने से पहले "[बूस्ट] + अनुक्रम प्रोग्राम विकल्प" और "[बूस्ट-प्रोग्राम-विकल्प] + ऑर्डर" (और उनके संस्करण) के लिए एसओ पर खोज की है, इसलिए अगर मैं इसे पहले से माफी माँगता हूं एक डुप्लिकेट बन जाता है।

Answer 1

इस बारे में कैसे:

./bin/make_graph c,4,5,1 c,3,1,2 w,3,3 

कहाँ "c,4,5,1", "c,3,1,2" और "w,3,3" (इस tutorial में सिर्फ --input-file की तरह) स्थितीय तर्क जो जमा हो जाती है (क्रम में) एक std::vector<std::string> में हैं। फिर प्रत्येक तर्क स्ट्रिंग से subtokens निकालने के लिए Boost.Tokenizer या boost::algorithm::split का उपयोग करें।

यदि ग्राफ जटिल हो सकते हैं, तो आपको ग्राफ़ पैरामीटर वाले इनपुट फ़ाइल को निर्दिष्ट करने के लिए उपयोगकर्ता को यह संभव बनाना चाहिए। Boost.Program_Options उपयोगकर्ता को config file पार्स कर सकते हैं जो कमांड लाइन विकल्पों के समान सिंटैक्स का उपयोग करता है।

Answer 2

प्रश्न पोस्ट करने के बाद से, मैंने कुछ खुदाई की और "हैक" किया जो मेरे ऊपर मौजूद मौजूदा उदाहरणों के साथ काम करता है।

bpo::parsed_options p_ops = bpo::parse_command_line(argc,argv,desc); 
typedef std::vector< bpo::basic_option<char> >::iterator OptionsIterator; 
OptionsIterator it = p_ops.options.begin(), it_end = p_ops.options.end(); 
while(it != it_end) { 
    std::cout << it->string_key << ": "; 
    BOOST_FOREACH(std::string value, it->value) { 
     std::cout << value << " "; 
    } 
    std::cout << std::endl; 
    ++it; 
} 

कारण मैं इसे हैक कहते हैं क्योंकि यह तारों के रूप में सभी तर्कों तक पहुँचता है, और एक बीपीओ की तरह बहुत से प्रकार को निकालने के लिए होता है :: variables_map .as<T>() सदस्य समारोह के साथ करता है। संपादित करें: यह सीधे विकल्प संरचना के सदस्य तक पहुंचता है।