Pode aumentar o programa_options separados por vírgula valores de argumento separados
-
28-09-2019 - |
Pergunta
Se minha linha de comando for:
> prog --mylist=a,b,c
Pode aumentar o programa_options ser configurado para ver três valores de argumento distintos para o mylist
argumento? Eu configurei o programa_Options como:
namespace po = boost::program_options;
po::options_description opts("blah")
opts.add_options()
("mylist", std::vector<std::string>>()->multitoken, "description");
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, opts), vm);
po::notify(vm);
Quando eu verifico o valor do mylist
argumento, vejo um valor como a,b,c
. Eu gostaria de ver três valores distintos, divididos em vírgula. Isso funciona bem se eu especificar a linha de comando como:
> prog --mylist=a b c
ou
> prog --mylist=a --mylist=b --mylist=c
Existe uma maneira de configurar o programa_Options para que ele veja a,b,c
Como três valores que devem ser inseridos no vetor, em vez de um?
Estou usando o Boost 1.41, G ++ 4.5.0 20100520 e ativei as extensões experimentais C ++ 0x.
EDITAR:
A solução aceita funciona, mas acaba sendo mais complicada, IMO, do que apenas itera através de um vetor e dividindo os valores manualmente. No final, peguei a sugestão de James McNellis e a implementei dessa maneira. Sua solução não foi enviada como uma resposta, no entanto, então eu aceitei a outra solução correta da Hkaiser. Ambos funcionaram, mas a tokenização manual é mais clara.
Solução
Você pode registrar um validador personalizado para sua opção:
namespace po = boost::program_options;
struct mylist_option
{
// values specified with --mylist will be stored here
vector<std::string> values;
// Function which validates additional tokens from command line.
static void
validate(boost::any &v, std::vector<std::string> const &tokens)
{
if (v.empty())
v = boost::any(mylist_option());
mylist_option *p = boost::any_cast<mylist_option>(&v);
BOOST_ASSERT(p);
boost::char_separator<char> sep(",");
BOOST_FOREACH(std::string const& t, tokens)
{
if (t.find(",")) {
// tokenize values and push them back onto p->values
boost::tokenizer<boost::char_separator<char> > tok(t, sep);
std::copy(tok.begin(), tok.end(),
std::back_inserter(p->values));
}
else {
// store value as is
p->values.push_back(t);
}
}
}
};
que então pode ser usado como:
opts.add_options()
("mylist", po::value<mylist_option>()->multitoken(), "description");
e:
if (vm.count("mylist"))
{
// vm["mylist"].as<mylist_option>().values will hold the value specified
// using --mylist
}
Outras dicas
Eu não tentei fazê -lo, mas você poderia usar a mesma abordagem que no exemplo de alicer program_options
, para escrever seu próprio analisador que você pode fornecer como analisador extra. Há um pouco de informação aqui com um pequeno exemplo. Então você pode combinar isso com a sugestão de James de usar o Boost :: Tokenizer, ou apenas seguir sua sugestão.
Aqui está o que estou usando agora:
template<typename T, int N> class mytype;
template<typename T, int N> std::istream& operator>> (std::istream& is, mytype<T,N>& rhs);
template<typename T, int N> std::ostream& operator<< (std::ostream& os, const mytype<T,N>& rhs);
template < typename T, int N >
struct mytype
{
T values[N];
friend std::istream& operator>> <>(std::istream &is, mytype<T,N> &val);
friend std::ostream& operator<< <>(std::ostream &os, const mytype<T,N> &val);
};
template<typename T, int N>
inline std::istream& operator>>(std::istream &is, mytype<T,N> &val)
{
for( int i = 0; i < N; ++i )
{
if( i )
if (is.peek() == ',')
is.ignore();
is >> val.values[i];
}
return is;
}
template<typename T, int N>
inline std::ostream& operator<<(std::ostream &os, const mytype<T,N> &val)
{
for( int i = 0; i < N; ++i )
{
if( i ) os << ',';
os << val.values[i];
}
return os;
}
int main(int argc, char *argv[])
{
namespace po = boost::program_options;
typedef mytype<int,2> mytype; // let's test with 2 int
mytype my;
try
{
po::options_description desc("the desc");
desc.add_options()
("mylist", po::value< mytype >(&my), "mylist desc")
;
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
po::notify(vm);
if (vm.count("mylist"))
{
const mytype ret = vm["mylist"].as<mytype >();
std::cerr << "mylist: " << ret << " or: " << my << std::endl;
}
}
catch(std::exception& e)
{
std::cout << e.what() << "\n";
}
return 0;
}