RhodeCode

  double d = 1.0;

  bool b, nh;

  bool g1, g2, g3;

  // Add a mandatory integer option with storage reference

  ap.refOption("n", "An integer input.", i, true);

  // Add a double option with storage reference (the default value is 1.0)

  ap.refOption("val", "A double input.", d);

  // Add a double option without storage reference (the default value is 3.14)

  ap.doubleOption("val2", "A double input.", 3.14);

  // Set synonym for -val option

  ap.synonym("vals", "val");

  // Add a string option

  ap.refOption("name", "A string input.", s);

  // Add bool options

  ap.refOption("f", "A switch.", b)

    .refOption("nohelp", "", nh)

    .refOption("gra", "Choice A", g1)

    .refOption("grb", "Choice B", g2)

    .refOption("grc", "Choice C", g3);

  // 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";

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

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

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

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

  switch(ap.files().size()) {

  case 0:

    std::cout << "  No file argument was given.\n";

    break;

  case 1:

    std::cout << "  1 file argument was given. It is:\n";

    break;

  default:

    std::cout << "  "

              << ap.files().size() << " file arguments were given. They are:\n";

  }

  for(unsigned int i=0;i<ap.files().size();++i)

    std::cout << "    '" << ap.files()[i] << "'\n";

  return 0;

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * 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;

          break;

        case STRING:

          delete i->second.string_p;

          break;

        case DOUBLE:

          delete i->second.double_p;

          break;

        case INTEGER:

          delete i->second.int_p;

          break;

        case UNKNOWN:

          break;

        case FUNC:

          break;

        }

  }

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

                               const std::string &help,

        show(cstr,i);

        if(!i->second.mandatory) cstr << ']';

        if(pos+cstr.str().size()>LINE_LEN) {

          std::cerr << std::endl << indent;

          pos=indent.size();

        }

        std::cerr << cstr.str();

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

      }

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

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

      {

        std::ostringstream cstr;

        cstr << ' ' << i->name;

        if(pos+cstr.str().size()>LINE_LEN) {

          std::cerr << std::endl << indent;

          pos=indent.size();

        }

        std::cerr << cstr.str();

        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;

    case DOUBLE:

      std::cerr << " floating point";

      break;

    default:

      break;

    }

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

    showHelp();

  }

  void ArgParser::checkMandatories() const

  {

    bool ok=true;

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

      if(i->second.mandatory&&!i->second.set)

        {

          if(ok)

            std::cerr << _command_name

                      << ": The following mandatory arguments are missing.\n";

          ok=false;

          showHelp(i);

        }

    for(Groups::const_iterator i=_groups.begin();i!=_groups.end();++i)

      if(i->second.mandatory||i->second.only_one)

        {

          int set=0;

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

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

            if(_opts.find(*o)->second.set) ++set;

          if(i->second.mandatory&&!set) {

            std::cerr << _command_name <<

              ": At least one of the following arguments is mandatory.\n";

            ok=false;

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

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

              showHelp(_opts.find(*o));

          }

          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));

        if(i==_opts.end()) unknownOpt(arg);

        else {

          if(i->second.syn) i=_opts.find(i->second.help);

          ParData &p(i->second);

          if (p.type==BOOL) *p.bool_p=true;

          else if (p.type==FUNC) p.func_p.p(p.func_p.data);

          else if(++ar==_argc) requiresValue(arg, p.type);

          else {

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

            std::istringstream vals(val);

            switch(p.type) {

            case STRING:

              *p.string_p=val;

              break;

            case INTEGER:

              vals >> *p.int_p;

              break;

            case DOUBLE:

              vals >> *p.double_p;

              break;

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * 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.

 *

 */

#ifndef LEMON_ARG_PARSER_H

#define LEMON_ARG_PARSER_H

#include <vector>

#include <map>

#include <list>

#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;

    const char * const *_argv;

    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };

    class ParData {

    public:

      union {

        bool *bool_p;

        int *int_p;

        double *double_p;

        std::string *string_p;

        struct {

          void (*p)(void *);

          void *data;

        } func_p;

      };

      std::string help;

      bool mandatory;

      OptType type;

      ParData() : mandatory(false), type(UNKNOWN), set(false), ingroup(false),

                  has_syn(false), syn(false), self_delete(false) {}

    };

    typedef std::map<std::string,ParData> Opts;

    Opts _opts;

    class GroupData

    {

    public:

      typedef std::list<std::string> Opts;

      Opts opts;

      bool only_one;

      bool mandatory;

      GroupData() :only_one(false), mandatory(false) {}

    };

    typedef std::map<std::string,GroupData> Groups;

    Groups _groups;

    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

    ///

    ///@{

    ///Add a new integer type option

    ///Add a new integer type option.

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

    ///\param help A help string.

    ///\param value A default value for the option.

    ///\param obl Indicate if the option is mandatory.

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

                    const std::string &help,

                    int value=0, bool obl=false);

    ///Add a new floating point type option

    ///Add a new floating point type option.

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

    ///\param help A help string.

    ///\param value A default value for the option.

    ///\param obl Indicate if the option is mandatory.

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

                      const std::string &help,

                     std::string()+"'"+_name+"' is a floating point option");

        return i->second.type==ArgParser::DOUBLE ?

          *(i->second.double_p) : *(i->second.int_p);

      }

      ///\e

      operator int()

      {

        Opts::const_iterator i = _parser._opts.find(_name);

        LEMON_ASSERT(i!=_parser._opts.end(),

                     std::string()+"Unkown option: '"+_name+"'");

        LEMON_ASSERT(i->second.type==ArgParser::INTEGER,

                     std::string()+"'"+_name+"' is an integer option");

        return *(i->second.int_p);

      }

    };

    ///Give back the value of an option

    ///Give back the value of an option.

    ///\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