RhodeCode

/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

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

 *

 */

///\ingroup demos

///\file

///\brief Argument parser demo

///

/// This example shows how the argument parser can be used.

///

/// \include arg_parser_demo.cc

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

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

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

    .synonym("vals","val")

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

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

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

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

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

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

    .optionGroup("gr","gra")

    .optionGroup("gr","grb")

    .optionGroup("gr","grc")

    .mandatoryGroup("gr")

    .onlyOneGroup("gr")

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

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

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

}

/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

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

    exit(1);

  }

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

                                                     _command_name(argv[0]) {

    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,

			       int value, bool obl)

  {

    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,

			       double value, bool obl)

  {

    ParData p;

    p.double_p=new double(value);

    p.self_delete=true;

    p.help=help;

    p.type=DOUBLE;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

			       const std::string &help,

			       bool value, bool obl)

  {

    ParData p;

    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)

  {

    ParData p;

    p.string_p=new std::string(value);

    p.self_delete=true;

    p.help=help;

    p.type=STRING;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

			       const std::string &help,

			       int &ref, bool obl)

  {

    ParData p;

    p.int_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=INTEGER;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

                                  const std::string &help,

                                  double &ref, bool obl)

  {

    ParData p;

    p.double_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=DOUBLE;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

                                  const std::string &help,

                                  bool &ref, bool obl)

  {

    ParData p;

    p.bool_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=BOOL;

    p.mandatory=obl;

    _opts[name]=p;

    ref = false;

    return *this;

  }

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

			       const std::string &help,

			       std::string &ref, bool obl)

  {

    ParData p;

    p.string_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=STRING;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

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

			       const std::string &help,

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

  {

    ParData p;

    p.func_p.p=func;

    p.func_p.data=data;

    p.self_delete=false;

    p.help=help;

    p.type=FUNC;

    p.mandatory=false;

    _opts[name]=p;

    return *this;

  }

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

				    const std::string &opt)

  {

    Opts::iterator i = _opts.find(opt);

    LEMON_ASSERT(i!=_opts.end(), "Unknown option: '"+opt+"'");

    LEMON_ASSERT(!(i->second.ingroup), 

                 "Option already in option group: '"+opt+"'");

    GroupData &g=_groups[group];

    g.opts.push_back(opt);

    i->second.ingroup=true;

    return *this;

  }

  ArgParser &ArgParser::onlyOneGroup(const std::string &group)

  {

    GroupData &g=_groups[group];

    g.only_one=true;

    return *this;

  }

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

				const std::string &opt)

  {

    Opts::iterator o = _opts.find(opt);

    Opts::iterator s = _opts.find(syn);

    LEMON_ASSERT(o!=_opts.end(), "Unknown option: '"+opt+"'");

    LEMON_ASSERT(s==_opts.end(), "Option already used: '"+syn+"'");

    ParData p;

    p.help=opt;

    p.mandatory=false;

    p.syn=true;

    _opts[syn]=p;

    o->second.has_syn=true;

    return *this;

  }

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

  {

    GroupData &g=_groups[group];

    g.mandatory=true;

    return *this;

  }

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

			      const std::string &help)

  {

    _others_help.push_back(OtherArg(name,help));

    return *this;

  }

  void ArgParser::show(std::ostream &os,Opts::iterator i)

  {

    os << "-" << i->first;

    if(i->second.has_syn)

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

	if(j->second.syn&&j->second.help==i->first)

	  os << "|-" << j->first;

    switch(i->second.type) {

    case STRING:

      os << " str";

      break;

    case INTEGER:

      os << " int";

      break;

    case DOUBLE:

      os << " num";

      break;

    default:

      break;

    }

  }

  void ArgParser::show(std::ostream &os,Groups::iterator i)

  {

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

    while(o!=i->second.opts.end()) {

      show(os,_opts.find(*o));

      ++o;

      if(o!=i->second.opts.end()) os<<'|';

    }

  }

  void ArgParser::showHelp(Opts::iterator i)

  {

    if(i->second.help.size()==0||i->second.syn) return;

    std::cerr << "  ";

    show(std::cerr,i);

    std::cerr << std::endl;

    std::cerr << "     " << i->second.help << std::endl;

  }

  void ArgParser::showHelp(std::vector<ArgParser::OtherArg>::iterator i)

  {

    if(i->help.size()==0) return;

    std::cerr << "  " << i->name << std::endl

	      << "     " << i->help << std::endl;

  }

  void ArgParser::shortHelp()

  {

    const unsigned int LINE_LEN=77;

    const std::string indent("    ");

    std::cerr << "Usage:\n  " << _command_name;

    int pos=_command_name.size()+2;

    for(Groups::iterator g=_groups.begin();g!=_groups.end();++g) {

      std::ostringstream cstr;

      cstr << ' ';

      if(!g->second.mandatory) cstr << '[';

      show(cstr,g);

      if(!g->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(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

      if(!i->second.ingroup&&!i->second.syn) {

	std::ostringstream cstr;

	cstr << ' ';

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

	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>::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()

  {

    shortHelp();

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

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

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

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

    exit(1);

  }

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

  {

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

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

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

    exit(1);

  }

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

  {

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

  {

    bool ok=true;

    for(Opts::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::iterator i=_groups.begin();i!=_groups.end();++i)

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

	{

	  int set=0;

	  for(GroupData::Opts::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::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::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";

      exit(1);

    }

  }

  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;

	    default:

	      break;

	    }

	    if(p.type!=STRING&&(!vals||!vals.eof()))

	      requiresValue(arg, p.type);

	  }

	  p.set = true;

	}

      }

    }

    checkMandatories();

    return *this;

  }  

}

/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

 * 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

#define LEMON_ARG_PARSER

#include <vector>

#include <map>

#include <list>

#include <string>

#include <iostream>

#include <sstream>

#include <algorithm>

#include <lemon/error.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 **_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;

      bool set;

      bool ingroup;

      bool has_syn;

      bool syn;

      bool self_delete;

      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:

    ///\e

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

    ~ArgParser();

    ///Add a new integer type option

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

    ///\param help A help string.

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

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

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

    ///\param help A help string.

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

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

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

		      const std::string &help,

		      double value=0, bool obl=false);

    ///Add a new bool type option

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

    ///\param help A help string.

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

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

    ////\note A mandatory bool obtion is of very little use.)

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

		      const std::string &help,

		      bool value=false, bool obl=false);

    ///Add a new string type option

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

    ///\param help A help string.

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

    ///\name Options with external storage

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

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

    ///\param help A help string.

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

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

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

		    const std::string &help,

		    int &ref, bool obl=false);

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

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

    ///\param help A help string.

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

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

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

		      const std::string &help,

		      double &ref, bool obl=false);

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

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

    ///\param help A help string.

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

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

    ////\note A mandatory bool obtion is of very little use.)

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

		      const std::string &help,

		      bool &ref, bool obl=false);

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

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

    ///\param help A help string.

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

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

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

		      const std::string &help,

		      std::string &ref, bool obl=false);

    ///@}

    ///\name Option Groups and Synonyms

    ///

    ///@{

    ///Boundle some options into a group

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

    /// option to be grouped with the same groupname.

    ///\param group The group name.

    ///\param opt The option name.

    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

    ///given at the same time

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

    ///Make a group mandatory

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

    ///With this function you can create a synonym \c syn of the

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

    ///The parameter \c name will be printed in the short usage line, while

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

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

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

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

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

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

    void show(std::ostream &os,Opts::iterator i);

    void show(std::ostream &os,Groups::iterator i);

    void showHelp(Opts::iterator i);

    void showHelp(std::vector<OtherArg>::iterator i);

    void shortHelp();

    void showHelp();

    void unknownOpt(std::string arg);

    void requiresValue(std::string arg, OptType t);

    void checkMandatories();

    ///Start the parsing process

    ArgParser &parse();

    /// Synonym for parse()

    ArgParser &run() 

    {

      return parse();

    }

    ///Check if an opion has been given to the command.

    bool given(std::string op) 

    {

      Opts::iterator i = _opts.find(op);

      return i!=_opts.end()?i->second.set:false;

    }

    ///Magic type for operator[]

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

    ///It automatically converts to \c int, \c double, \c bool or

    ///\c std::string if the type of the option matches, otherwise it

    ///throws an exception (i.e. it performs runtime type checking).

    class RefType 

    {

      ArgParser &_parser;

      std::string _name;

    public:

      ///\e

      RefType(ArgParser &p,const std::string &n) :_parser(p),_name(n) {}

      ///\e

      operator bool() 

      {

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

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

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

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

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

	return *(i->second.bool_p);

      }

      ///\e

      operator std::string()

      {

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

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

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

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

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

	return *(i->second.string_p);

      }

      ///\e

      operator double() 

      {

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

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

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

	LEMON_ASSERT(i->second.type!=ArgParser::DOUBLE &&

		     i->second.type!=ArgParser::INTEGER,

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

    {

      return RefType(*this, n);

    }    

  };

}

#endif // LEMON_MAIN_PARAMS

^test/[a-z_]*$

^demo/.*_demo$

noinst_PROGRAMS += \

        demo/arg_parser_demo

demo_arg_parser_demo_SOURCES = demo/arg_parser_demo.cc

        lemon/arg_parser.cc \

        lemon/arg_parser.h \