RhodeCode

 */

///\ingroup demos

///\file

///\brief Argument parser demo

///

///

#include <lemon/arg_parser.h>

using namespace lemon;

int main(int argc, const char **argv)

{

  ArgParser ap(argc,argv);

  int i;

  std::string s;

  double d;

  bool b,sil;

  bool g1,g2,g3;

    .synonym("vals","val")

    .refOption("nohelp", "", sil)

    .optionGroup("gr","gra")

    .optionGroup("gr","grb")

    .optionGroup("gr","grc")

    .mandatoryGroup("gr")

    .onlyOneGroup("gr")

    .other("...");

  ap.parse();

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

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

  if(ap.given("val")) std::cout << "  Value of -val: " << 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: " << sil << std::endl;

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

    ParData p;

    p.int_p=new int(value);

    p.self_delete=true;

    p.help=help;

    p.type=INTEGER;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

			       const std::string &help,

    p.bool_p=new bool(value);

    p.self_delete=true;

    p.help=help;

    p.type=BOOL;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

			       const std::string &help,

			       std::string value, bool obl)

#include <sstream>

#include <algorithm>

#include <lemon/error.h>

///\ingroup misc

///\file

namespace lemon {

  ///Command line arguments parser

  ///\ingroup misc

  ///

  class ArgParser {

    static void _showHelp(void *p);

  protected:

    int _argc;

    ///\retval value The value of the argument will be written to this variable.

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

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

		      const std::string &help,

		      std::string value="", bool obl=false);

    ///Using this functions, the value of the option will be directly written

    ///into a variable once the option appears in the command line.

    ///@{

    ///Add a new integer type option with a storage reference

    ///@{

    ///Boundle some options into a group

    /// You can group some option by calling this function repeatedly for each

    ArgParser &optionGroup(const std::string &group,

			   const std::string &opt);

    ///Make the members of a group exclusive

    ///If you call this function for a group, than at most one of them can be

    ///Using this function, at least one of the members of \c group

    ///must be given.

    ArgParser &mandatoryGroup(const std::string &group);

    ///Create synonym to an option

    ///option \c opt.

    ArgParser &synonym(const std::string &syn,

			   const std::string &opt);

    ///@}

    ///Give help string for non-parsed arguments.

    ///With this function you can give help string for non-parsed arguments.

    ///\c help gives a more detailed description.

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

		     const std::string &help="");

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

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

    ///Give back the command name (the 0th argument)

    const std::string &commandName() { return _command_name; }

    }

    ///Magic type for operator[]

    ///This is the type of the return value of ArgParser::operator[]().

    class RefType 

    {

      ArgParser &_parser;

      std::string _name;

    public:

      ///\e

      }

    };

    ///Give back the value of an option

    ///\sa RefType

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

    {

      return RefType(*this, n);

    }