RhodeCode

  // Bundle -gr* options into a group

  ap.optionGroup("gr", "gra")

    .optionGroup("gr", "grb")

    .optionGroup("gr", "grc");

  // Set the group mandatory

  ap.mandatoryGroup("gr");

  // Set the options of the group exclusive (only one option can be given)

  ap.onlyOneGroup("gr");

  // Add non-parsed arguments (e.g. input files)

  ap.other("infile", "The input file.")

    .other("...");

  // Perform the parsing process

  // (in case of any error it terminates the program)

  // Check each option if it has been given and print its value

  std::cout << "Parameters of '" << ap.commandName() << "':\n";

  std::cout << "  Value of -n: " << i << std::endl;

  if(ap.given("val")) std::cout << "  Value of -val: " << d << std::endl;

  if(ap.given("val2")) {

    d = ap["val2"];

    std::cout << "  Value of -val2: " << d << std::endl;

  }

  if(ap.given("name")) std::cout << "  Value of -name: " << s << std::endl;

  if(ap.given("f")) std::cout << "  -f is given\n";

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#include <lemon/arg_parser.h>

namespace lemon {

  void ArgParser::_showHelp(void *p)

  {

    (static_cast<ArgParser*>(p))->showHelp();

  }

  ArgParser::ArgParser(int argc, const char * const *argv)

    funcOption("-help","Print a short help message",_showHelp,this);

    synonym("help","-help");

    synonym("h","-help");

  }

  ArgParser::~ArgParser()

  {

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

      if(i->second.self_delete)

        switch(i->second.type) {

        case BOOL:

          delete i->second.bool_p;

        pos+=cstr.str().size();

      }

    std::cerr << std::endl;

  }

  void ArgParser::showHelp() const

  {

    shortHelp();

    std::cerr << "Where:\n";

    for(std::vector<OtherArg>::const_iterator i=_others_help.begin();

        i!=_others_help.end();++i) showHelp(i);

    for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);

  }

  void ArgParser::unknownOpt(std::string arg) const

  {

    std::cerr << "\nUnknown option: " << arg << "\n";

    std::cerr << "\nType '" << _command_name <<

      " --help' to obtain a short summary on the usage.\n\n";

  }

  void ArgParser::requiresValue(std::string arg, OptType t) const

  {

    std::cerr << "Argument '" << arg << "' requires a";

    switch(t) {

    case STRING:

      std::cerr << " string";

      break;

    case INTEGER:

      std::cerr << "n integer";

      break;

          if(i->second.only_one&&set>1) {

            std::cerr << _command_name <<

              ": At most one of the following arguments can be given.\n";

            ok=false;

            for(GroupData::Opts::const_iterator o=i->second.opts.begin();

                o!=i->second.opts.end();++o)

              showHelp(_opts.find(*o));

          }

        }

    if(!ok) {

      std::cerr << "\nType '" << _command_name <<

        " --help' to obtain a short summary on the usage.\n\n";

    }

  }

  ArgParser &ArgParser::parse()

  {

    for(int ar=1; ar<_argc; ++ar) {

      std::string arg(_argv[ar]);

      if (arg[0] != '-' || arg.size() == 1) {

        _file_args.push_back(arg);

      }

      else {

        Opts::iterator i = _opts.find(arg.substr(1));

#include <string>

#include <iostream>

#include <sstream>

#include <algorithm>

#include <lemon/assert.h>

///\ingroup misc

///\file

///\brief A tool to parse command line arguments.

namespace lemon {

  ///Command line arguments parser

  ///\ingroup misc

  ///Command line arguments parser.

  ///

  ///For a complete example see the \ref arg_parser_demo.cc demo file.

  class ArgParser {

    static void _showHelp(void *p);

  protected:

    int _argc;

    struct OtherArg

    {

      std::string name;

      std::string help;

      OtherArg(std::string n, std::string h) :name(n), help(h) {}

    };

    std::vector<OtherArg> _others_help;

    std::vector<std::string> _file_args;

    std::string _command_name;

  private:

    //Bind a function to an option.

    //\param name The name of the option. The leading '-' must be omitted.

    //\param help A help string.

    //\retval func The function to be called when the option is given. It

    //  must be of type "void f(void *)"

    //\param data Data to be passed to \c func

    ArgParser &funcOption(const std::string &name,

                    const std::string &help,

                    void (*func)(void *),void *data);

  public:

    ///Constructor

    ArgParser(int argc, const char * const *argv);

    ~ArgParser();

    ///\name Options

    ///

    ///@{

    ///\sa RefType

    RefType operator[](const std::string &n) const

    {

      return RefType(*this, n);

    }

    ///Give back the non-option type arguments.

    ///Give back a reference to a vector consisting of the program arguments

    ///not starting with a '-' character.

    const std::vector<std::string> &files() const { return _file_args; }

  };

}

#endif // LEMON_ARG_PARSER_H