Arguments obligatoires et Facultatifs à l'Aide de Bibliothèque Boost Options du Programme

Je suis en utilisant le Programme Boost Options de la Bibliothèque pour analyser les arguments de ligne de commande.

J'ai les exigences suivantes:

Une fois "aide" est fourni, toutes les autres options sont facultatives;
Une fois "aide" n'est pas fourni, toutes les options sont nécessaires.

Comment je peux faire face à cela? Voici mon code de la manipulation, et j'ai trouvé que c'est très redondant, et je pense qu'il doit être facile à faire, non?

#include <boost/program_options.hpp>
#include <iostream>
#include <sstream>
namespace po = boost::program_options;
bool process_command_line(int argc, char** argv,
std::string& host,
std::string& port,
std::string& configDir)
{
int iport;
try
{
po::options_description desc("Program Usage", 1024, 512);
desc.add_options()
("help",     "produce help message")
("host,h",   po::value<std::string>(&host),      "set the host server")
("port,p",   po::value<int>(&iport),             "set the server port")
("config,c", po::value<std::string>(&configDir), "set the config path")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help"))
{
std::cout << desc << "\n";
return false;
}
//There must be an easy way to handle the relationship between the
//option "help" and "host"-"port"-"config"
if (vm.count("host"))
{
std::cout << "host:   " << vm["host"].as<std::string>() << "\n";
}
else
{
std::cout << "\"host\" is required!" << "\n";
return false;
}
if (vm.count("port"))
{
std::cout << "port:   " << vm["port"].as<int>() << "\n";
}
else
{
std::cout << "\"port\" is required!" << "\n";
return false;
}
if (vm.count("config"))
{
std::cout << "config: " << vm["config"].as<std::string>() << "\n";
}
else
{
std::cout << "\"config\" is required!" << "\n";
return false;
}
}
catch(std::exception& e)
{
std::cerr << "Error: " << e.what() << "\n";
return false;
}
catch(...)
{
std::cerr << "Unknown error!" << "\n";
return false;
}
std::stringstream ss;
ss << iport;
port = ss.str();
return true;
}
int main(int argc, char** argv)
{
std::string host;
std::string port;
std::string configDir;
bool result = process_command_line(argc, argv, host, port, configDir);
if (!result)
return 1;
//Do the main routine here
}

InformationsquelleAutor Peter Lee | 2011-03-22

boost boost-program-options c++optional required

96

J'ai rencontrer ce genre de problème moi-même. La clé d'une solution est que la fonction po::store remplit la variables_map tout po::notify soulève toutes les erreurs, de sorte vm peut être utilisé avant toute notification envoyée.

Donc, comme par Tim, réglez chaque option obligatoire, comme souhaité, mais de l'exécuter po::notify(vm) après vous avez fait affaire avec l'aide de l'option. De cette façon, il sera à la sortie, sans aucune exception levée. Maintenant, avec les options nécessaires, une option manquante entraînera une required_option exception levée et à l'aide de son get_option_name méthode, vous pouvez réduire votre code d'erreur relativement simple catch bloc.

Comme une note complémentaire, votre option variables sont définies directement via le po::value< -type- >( &var_name ) mécanisme, de sorte que vous n'avez pas accès par vm["opt_name"].as< -type- >().
- merci pour votre réponse. Je pense qu'il fonctionne comme prévu. J'ai également posté le programme complet ci-dessous pour les gens qui ont besoin d'un bon exemple.
- heureux de l'entendre.
- Excellente solution! La documentation officielle devrait faire comprendre avec un exemple.
- Cette réponse, c'est génial. J'en ai fait mon MO pour le traitement des options d'aide à stimuler en règle générale maintenant.
InformationsquelleAutor rcollyer

Ici est le programme complet comme par rcollyer et Tim, dont les crédits vont à:

#include <boost/program_options.hpp>
#include <iostream>
#include <sstream>
namespace po = boost::program_options;
bool process_command_line(int argc, char** argv,
std::string& host,
std::string& port,
std::string& configDir)
{
int iport;
try
{
po::options_description desc("Program Usage", 1024, 512);
desc.add_options()
("help",     "produce help message")
("host,h",   po::value<std::string>(&host)->required(),      "set the host server")
("port,p",   po::value<int>(&iport)->required(),             "set the server port")
("config,c", po::value<std::string>(&configDir)->required(), "set the config path")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
if (vm.count("help"))
{
std::cout << desc << "\n";
return false;
}
//There must be an easy way to handle the relationship between the
//option "help" and "host"-"port"-"config"
//Yes, the magic is putting the po::notify after "help" option check
po::notify(vm);
}
catch(std::exception& e)
{
std::cerr << "Error: " << e.what() << "\n";
return false;
}
catch(...)
{
std::cerr << "Unknown error!" << "\n";
return false;
}
std::stringstream ss;
ss << iport;
port = ss.str();
return true;
}
int main(int argc, char** argv)
{
std::string host;
std::string port;
std::string configDir;
bool result = process_command_line(argc, argv, host, port, configDir);
if (!result)
return 1;
//else
std::cout << "host:\t"   << host      << "\n";
std::cout << "port:\t"   << port      << "\n";
std::cout << "config:\t" << configDir << "\n";
//Do the main routine here
}
/* Sample output:
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe --help
Program Usage:
--help                produce help message
-h [ --host ] arg     set the host server
-p [ --port ] arg     set the server port
-c [ --config ] arg   set the config path
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe
Error: missing required option config
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe --host localhost
Error: missing required option config
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe --config .
Error: missing required option host
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe --config . --help
Program Usage:
--help                produce help message
-h [ --host ] arg     set the host server
-p [ --port ] arg     set the server port
-c [ --config ] arg   set the config path
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe --host 127.0.0.1 --port 31528 --config .
host:   127.0.0.1
port:   31528
config: .
C:\Documents and Settings\plee\My Documents\Visual Studio 2010\Projects\VCLearning\Debug>boost.exe -h 127.0.0.1 -p 31528 -c .
host:   127.0.0.1
port:   31528
config: .
*/

Vous devez attraper boost::program_options::required_option de sorte que vous pouvez gérer l'absence d'une option obligatoire directement au lieu de l'avoir attrapé par std::exception.
Le Port doit être de type non signé.
Vous devez attraper boost::program_options::erreur de ce seulement.

InformationsquelleAutor Peter Lee

12

Vous pouvez spécifier qu'une option est requise assez facilement [Un], par exemple,:
```
..., value<string>()->required(), ...
```
mais autant que je sache, il n'y a pas moyen de représenter les relations entre les différentes options pour la program_options de la bibliothèque.

Une possibilité consiste à analyser la ligne de commande plusieurs fois avec différentes option définit, ensuite, si vous avez déjà vérifié pour "aide" vous pouvez analyser avec les trois autres options que celles requises. Je ne suis pas sûr que je serais considéré une amélioration par rapport à ce que vous avez, si.
- oui, u r droit que je pourrais mettre ->required(), mais l'utilisateur ne peut pas obtenir les informations d'aide par --help (sans fournir toutes les autres options), parce que d'autres options sont nécessaires.
- Vous recherchez seulement aider la première fois, les autres options ne serait même pas dans la liste. Puis, s'ils ne passent pas dans l'aide de l'option, c'est alors seulement que vous exécutez l'analyse de nouveau, cette fois en passant dans les trois autres options, obligatoire, et pas de l'aide. Cette approche nécessiterait probablement une troisième série d'options, avec tous les combinés, à utiliser pour l'impression de l'utilisation de l'information. Je suis sûr que ça marcherait, mais rcollyer l'approche est plus propre.
InformationsquelleAutor Tim Sylvester

    std::string conn_mngr_id;
std::string conn_mngr_channel;
int32_t priority;
int32_t timeout;
boost::program_options::options_description p_opts_desc("Program options");
boost::program_options::variables_map p_opts_vm;
try {
p_opts_desc.add_options()
("help,h", "produce help message")
("id,i", boost::program_options::value<std::string>(&conn_mngr_id)->required(), "Id used to connect to ConnectionManager")
("channel,c", boost::program_options::value<std::string>(&conn_mngr_channel)->required(), "Channel to attach with ConnectionManager")
("priority,p", boost::program_options::value<int>(&priority)->default_value(1), "Channel to attach with ConnectionManager")
("timeout,t", boost::program_options::value<int>(&timeout)->default_value(15000), "Channel to attach with ConnectionManager")
;
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, p_opts_desc), p_opts_vm);
boost::program_options::notify(p_opts_vm);
if (p_opts_vm.count("help")) {
std::cout << p_opts_desc << std::endl;
return 1;
}
} catch (const boost::program_options::required_option & e) {
if (p_opts_vm.count("help")) {
std::cout << p_opts_desc << std::endl;
return 1;
} else {
throw e;
}
}

C'est certainement une alternative intéressante. Mais, il vous oblige à répéter l'aide de la manipulation de code, et bien que petite, j'avais tendance à l'éviter.

InformationsquelleAutor Edgard Lima

Vous devez vous connecter pour publier un commentaire.