impulso :: program_options argumento "polimórfica"

Question

me gustaría usar boost :: program_options para crear un archivo ejecutable que se puede llamar de la siguiente manera:

./example --nmax=0,10 # nmax is chosen randomly between 0 and 10 
./example --nmax=9  # nmax is set to 9 
./example    # nmax is set to the default value of 10 

¿Cuál es la mejor manera de lograr esto, en un tipo de manera segura, con un código mínimo?

Answer 1

estoy publicando este código aquí, esperando que sea de utilidad a alguien. Es la versión "templada" de la respuesta de Sam Miller.

#ifndef RANDOMCONSTANT_HH 
#define RANDOMCONSTANT_HH 

#include <boost/random.hpp> 

boost::random::mt19937 g_randomConstantPrng(static_cast<unsigned int>(std::time(NULL) + getpid())); 

template<typename T> 
class RandomConstant 
{ 
public: 
    RandomConstant() { /* nothing */ } 
    RandomConstant(T value) : _value(value) { /* nothing */ } 
    RandomConstant(int low, int high) 
    { 
     boost::random::uniform_int_distribution<> dist(low, high); 
     _value = dist(g_randomConstantPrng); 
    } 
    RandomConstant(double low, double high) 
    { 
     boost::random::uniform_real_distribution<> dist(low, high); 
     _value = dist(g_randomConstantPrng); 
    } 
    T value() const { return _value; } 

private: 
    T _value; 
}; 


template<typename T> 
std::ostream& 
operator<<(std::ostream& os, const RandomConstant<T>& foo) 
{ 
    os << foo.value(); 
    return os; 
} 

template<typename T> 
std::istream& 
operator>>(std::istream &is, RandomConstant<T> &foo) 
{ 
    std::string line; 
    std::getline(is, line); 
    if (!is) return is; 

    const std::string::size_type comma = line.find_first_of(','); 
    if (comma != std::string::npos) 
    { 
     const T low = boost::lexical_cast<T>(line.substr(0, comma)); 
     const T high = boost::lexical_cast<T>(line.substr(comma + 1)); 
     foo = RandomConstant<T>(low, high); 
    } 
    else 
    { 
     foo = RandomConstant<T>(boost::lexical_cast<T>(line)); 
    } 

    return is; 
} 

#endif /* RANDOMCONSTANT_HH */ 

utiliza como sigue:

namespace po = boost::program_options; 
po::options_description desc; 
desc.add_options() 
    ("help", "show help") 
    ("intValue", po::value<RandomConstant<int>>()->default_value(3), "description 1") 
    ("doubleValue", po::value<RandomConstant<double>>()->default_value(1.5), "description 2") 
; 

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

if (vm.count("help")) { 
    std::cerr << desc << std::endl; 
    return EXIT_FAILURE; 
} 

int intValue = vm["intValue"].as<RandomConstant<int>>().value(); 
double doubleValue = vm["doubleValue"].as<RandomConstant<double>>().value(); 

Answer 2

La biblioteca no ofrece tipos de argumentos "polimórficos" como usted sugiere. Cada argumento tiene exactamente un tipo. Si desea que tenga diferentes valores basados ​​en la sintaxis del argumento, debe agregar esa funcionalidad usted mismo.

La manera más fácil es hacer lo que el comentario de Kerrek sugiere y usar una cadena, y luego analizarlo después. Realmente no requiere mucho código.

Otra forma es utilizar un custom validator. Componga un tipo especial dedicado a este formato de argumento y luego escriba una función validate que convierta los valores de cadena en valores de su tipo personalizado. Lanza una excepción si la validación falla; la biblioteca Program_Options lo tratará como una falla de validación de cualquiera de los tipos incorporados. Escribí an example validator in response to another question.

El código que va a escribir para esto es más o menos el mismo código que escribiría para analizar la cadena después de analizar la línea de comandos; solo se trata de si lo compilará en el tipo de argumento, o simplemente lo procesará después.

Answer 3

I would like to use boost::program_options to create an executable which can be called as follows:

la biblioteca program_options es muy flexible, esto puede hacerse fácilmente con el apoyo de la escritura de su propia clase con los operadores de inserción y extracción de corriente.

#include <iostream> 
#include <limits> 
#include <stdlib.h> 

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


class Max 
{ 
public: 
    Max() : 
     _max(std::numeric_limits<int>::max()) 
    { 

    } 

    Max(
      int max 
     ) : 
     _max(max) 
    { 

    } 

    Max(
      int low, 
      int high 
     ) 
    { 
     int value = rand(); 
     value %= (high - low); 
     value += low; 
     _max = value; 
    } 

    int value() const { return _max; } 

private:  
    int _max; 
}; 

std::ostream& 
operator<<(
     std::ostream& os, 
     const Max& foo 
     ) 
{ 
    os << foo.value(); 
    return os; 
} 

std::istream& 
operator>>(
     std::istream& is, 
     Max& foo 
     ) 
{ 
    std::string line; 
    std::getline(is, line); 
    if (!is) return is; 

    const std::string::size_type comma = line.find_first_of(','); 
    try { 
     if (comma != std::string::npos) { 
      const int low = boost::lexical_cast<int>(line.substr(0, comma)); 
      const int high = boost::lexical_cast<int>(line.substr(comma + 1)); 
      foo = Max(low, high); 
     } else { 
      foo = Max(boost::lexical_cast<int>(line)); 
     } 
    } catch (const boost::bad_lexical_cast& e) { 
     std::cerr << "garbage when convering Max value '" << line << "'" << std::endl; 

     is.setstate(std::ios::failbit); 
    } 

    return is; 
} 

int 
main(int argc, char** argv) 
{ 
    namespace po = boost::program_options; 

    Max nmax; 

    po::options_description options; 
    options.add_options() 
     ("nmax", po::value(&nmax)->default_value(10), "random number range, or value") 
     ("help,h", po::bool_switch(), "help text") 
     ; 

    po::variables_map vm; 
    try { 
     po::command_line_parser cmd_line(argc, argv); 
     cmd_line.options(options); 
     po::store(cmd_line.run(), vm); 
     po::notify(vm); 
    } catch (const boost::program_options::error& e) { 
     std::cerr << e.what() << std::endl; 
     exit(EXIT_FAILURE); 
    } 

    if (vm["help"].as<bool>()) { 
     std::cout << argv[0] << " [OPTIONS]" << std::endl; 
     std::cout << std::endl; 
     std::cout << "OPTIONS:" << std::endl; 
     std::cout << options << std::endl; 
     exit(EXIT_SUCCESS); 
    } 

    std::cout << "random value: " << nmax.value() << std::endl; 
} 

sesión de ejemplo

samm:stackoverflow samm$ ./a.out 
random value: 10 
samm:stackoverflow samm$ ./a.out --nmax 55 
random value: 55 
samm:stackoverflow samm$ ./a.out --nmax 10,25 
random value: 17 
samm:stackoverflow samm$ 

Answer 4

es probable que pueda utilizar la modalidad Multi

po::options_description desc("Allowed options"); 
desc.add_options() 
    ("nmax", po::value< std::vector<float> >()->multitoken()->default_value(10), "description") 
; 

... 

float value; 
if (vm.count["nmax"] == 2) 
    value = random value ... 
else 
    value = vm["nmax"].as< std::vector<float> >()[0];