I want to implement a command-line like interface inside my program. So I receive strings that follow the normal command-line syntax (e.g. "-G foo -dp bar --help"). As I don't want to implement the parser again, I would like to use Boost.
The question is: How can I pass a string to Boost program options instead of a combination of argCount and argValues. Do I need to first transform the text into a number (argCount) and a char* array (argValues) to do it? And if yes... is there an easy way to do this?
Thanks in advance.
One approach is to tokenize std::string
into a std::vector<std::string>
, then pass the result to Boost.ProgramOption's command_line_parser
. The Boost.ProgramOption's documentation briefly covers this approach. Additionally, I use a similar approach in part of this answer.
Here is a minimal complete example:
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <boost/bind.hpp>
#include <boost/program_options.hpp>
#include <boost/tokenizer.hpp>
// copy_if was left out of the C++03 standard, so mimic the C++11
// behavior to support all predicate types. The alternative is to
// use remove_copy_if, but it only works for adaptable functors.
template <typename InputIterator,
typename OutputIterator,
typename Predicate>
OutputIterator
copy_if(InputIterator first,
InputIterator last,
OutputIterator result,
Predicate pred)
{
while(first != last)
{
if(pred(*first))
*result++ = *first;
++first;
}
return result;
}
/// @brief Tokenize a string. The tokens will be separated by each non-quoted
/// space or equal character. Empty tokens are removed.
///
/// @param input The string to tokenize.
///
/// @return Vector of tokens.
std::vector<std::string> tokenize(const std::string& input)
{
typedef boost::escaped_list_separator<char> separator_type;
separator_type separator("\\", // The escape characters.
"= ", // The separator characters.
"\"\'"); // The quote characters.
// Tokenize the intput.
boost::tokenizer<separator_type> tokens(input, separator);
// Copy non-empty tokens from the tokenizer into the result.
std::vector<std::string> result;
copy_if(tokens.begin(), tokens.end(), std::back_inserter(result),
!boost::bind(&std::string::empty, _1));
return result;
}
int main()
{
// Variables that will store parsed values.
std::string address;
unsigned int port;
// Setup options.
namespace po = boost::program_options;
po::options_description desc("Options");
desc.add_options()
("address", po::value<std::string>(&address))
("port", po::value<unsigned int>(&port))
;
// Mock up input.
std::string input = "--address 127.0.0.1 --port 12345";
// Parse mocked up input.
po::variables_map vm;
po::store(po::command_line_parser(tokenize(input))
.options(desc).run(), vm);
po::notify(vm);
// Output.
std::cout << "address = " << address << "\n"
"port = " << port << std::endl;
}
Which produces the following output:
address = 127.0.0.1
port = 12345
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With