Boost के program_options

Question

के साथ जटिल विकल्प हैंडल करें मेरे पास एक ऐसा प्रोग्राम है जो विभिन्न बहु-स्तर मॉडल का उपयोग करके आलेख उत्पन्न करता है। प्रत्येक मल्टी लेवल मॉडल में एक छोटे बीज ग्राफ़ (कहें, 50 नोड्स) की एक पीढ़ी होती है जिसे कई मॉडलों से बनाया जा सकता है (उदाहरण के लिए - प्रत्येक संभावित किनारे के लिए, इसे संभावना पी के साथ शामिल करना चुनें)।

बीज ग्राफ़ पीढ़ी के बाद, ग्राफ को मॉडल के दूसरे सेट में से एक का उपयोग करके बड़े आकार में (1000 नोड्स कहें) में विस्तारित किया जाता है।

दो चरणों में से प्रत्येक मॉडल में विभिन्न पैरामीटर की आवश्यकता होती है।

मॉडल के नामों के अनुसार, मैं प्रोग्राम_प्शन को विभिन्न संभावित मानकों को पार्स करना चाहता हूं।

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

./graph_generator --seed=SA 0.1 --expansion=A 0.2 
./graph_generator --seed=SB 0.1 3 --expansion=A 0.2 
./graph_generator --seed=SA 0.1 --expansion=B 10 20 
./graph_generator --seed=SB 0.1 3 --expansion=B 10 20 

और पैरामीटर सही ढंग से पार्स किए गए हैं। क्या यह भी संभव है?

Answer 1

एक custom validator और boost::program_options::value::multitoken का उपयोग करके आप वांछित परिणाम प्राप्त कर सकते हैं:

#include <iostream> 
#include <boost/lexical_cast.hpp> 
#include <boost/optional.hpp> 
#include <boost/program_options.hpp> 

// Holds parameters for seed/expansion model 
struct Model 
{ 
    std::string type; 
    boost::optional<float> param1; 
    boost::optional<float> param2; 
}; 

// Called by program_options to parse a set of Model arguments 
void validate(boost::any& v, const std::vector<std::string>& values, 
       Model*, int) 
{ 
    Model model; 
    // Extract tokens from values string vector and populate Model struct. 
    if (values.size() == 0) 
    { 
     throw boost::program_options::validation_error(
      "Invalid model specification"); 
    } 
    model.type = values.at(0); // Should validate for A/B 
    if (values.size() >= 2) 
     model.param1 = boost::lexical_cast<float>(values.at(1)); 
    if (values.size() >= 3) 
     model.param2 = boost::lexical_cast<float>(values.at(2)); 

    v = model; 
} 

int main(int argc, char* argv[]) 
{ 
    Model seedModel, expansionModel; 

    namespace po = boost::program_options; 
    po::options_description options("Generic options"); 
    options.add_options() 
     ("seed", 
      po::value<Model>(&seedModel)->multitoken(), 
      "seed graph model") 
     ("expansion", 
      po::value<Model>(&expansionModel)->multitoken(), 
      "expansion model") 
     ; 

    po::variables_map vm; 
    po::store(po::parse_command_line(argc, argv, options), vm); 
    po::notify(vm); 

    std::cout << "Seed type: " << seedModel.type << "\n"; 
    if (seedModel.param1) 
     std::cout << "Seed param1: " << *(seedModel.param1) << "\n"; 
    if (seedModel.param2) 
     std::cout << "Seed param2: " << *(seedModel.param2) << "\n"; 

    std::cout << "Expansion type: " << expansionModel.type << "\n"; 
    if (expansionModel.param1) 
     std::cout << "Expansion param1: " << *(expansionModel.param1) << "\n"; 
    if (expansionModel.param2) 
     std::cout << "Expansion param2: " << *(expansionModel.param2) << "\n"; 

    return 0; 
} 

validate समारोह शायद और अधिक कठोरता की जरूरत है, लेकिन आप विचार मिलता है।

यह मेरे लिए संकलित और काम करता है।