lemon-1.1: comparison lemon/arg

equal deleted inserted replaced

-:110b85270adf
+:fe448abed4f5
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* 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).
 *
 ///\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;
+bool *bool_p;
-	int *int_p;
+int *int_p;
-	double *double_p;
+double *double_p;
-	std::string *string_p;
+std::string *string_p;
-	struct {
+struct {
-	  void (*p)(void *);
+void (*p)(void *);
-	  void *data;
+void *data;
-	} func_p;
+} 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) {}
+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,
+const std::string &help,
-		    void (*func)(void *),void *data);
+void (*func)(void *),void *data);
 public:
 ///Constructor
 ArgParser(int argc, const char **argv);
 ///\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,
+const std::string &help,
-		    int value=0, bool obl=false);
+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,
+const std::string &help,
-		      double value=0, bool obl=false);
+double value=0, bool obl=false);
 ///Add a new bool type option
 ///Add a new bool 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.
 ///\note A mandatory bool obtion is of very little use.
 ArgParser &boolOption(const std::string &name,
-		      const std::string &help,
+const std::string &help,
-		      bool value=false, bool obl=false);
+bool value=false, bool obl=false);
 ///Add a new string type option
 ///Add a new string 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 &stringOption(const std::string &name,
-		      const std::string &help,
+const std::string &help,
-		      std::string value="", bool obl=false);
+std::string value="", bool obl=false);
 ///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="");
+const std::string &help="");
 ///@}
 ///\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.
 ///\param name The name of the option. The leading '-' must be omitted.
 ///\param help A help string.
 ///\param obl Indicate if the option is mandatory.
 ///\retval ref The value of the argument will be written to this variable.
 ArgParser &refOption(const std::string &name,
-		    const std::string &help,
+const std::string &help,
-		    int &ref, bool obl=false);
+int &ref, bool obl=false);
 ///Add a new floating type option with a storage reference
 ///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.
 ///\param obl Indicate if the option is mandatory.
 ///\retval ref The value of the argument will be written to this variable.
 ArgParser &refOption(const std::string &name,
-		      const std::string &help,
+const std::string &help,
-		      double &ref, bool obl=false);
+double &ref, bool obl=false);
 ///Add a new bool type option with a storage reference
 ///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.
 ///\param obl Indicate if the option is mandatory.
 ///\retval ref The value of the argument will be written to this variable.
 ///\note A mandatory bool obtion is of very little use.
 ArgParser &refOption(const std::string &name,
-		      const std::string &help,
+const std::string &help,
-		      bool &ref, bool obl=false);
+bool &ref, bool obl=false);
 ///Add a new string type option with a storage reference
 ///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.
 ///\param obl Indicate if the option is mandatory.
 ///\retval ref The value of the argument will be written to this variable.
 ArgParser &refOption(const std::string &name,
-		      const std::string &help,
+const std::string &help,
-		      std::string &ref, bool obl=false);
+std::string &ref, bool obl=false);
 ///@}
 ///\name Option Groups and Synonyms
 ///
 ///@{
 ///Bundle 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);
+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);
+const std::string &opt);
 ///@}
 void show(std::ostream &os,Opts::iterator i);
 void show(std::ostream &os,Groups::iterator i);
 void showHelp(Opts::iterator i);
 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();
 }
 ///Give back the command name (the 0th argument)
 const std::string &commandName() { return _command_name; }
 ///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);
+Opts::iterator i = _parser._opts.find(_name);
-	LEMON_ASSERT(i!=_parser._opts.end(),
+LEMON_ASSERT(i!=_parser._opts.end(),
-		     std::string()+"Unkown option: '"+_name+"'");
+std::string()+"Unkown option: '"+_name+"'");
-	LEMON_ASSERT(i->second.type==ArgParser::BOOL,
+LEMON_ASSERT(i->second.type==ArgParser::BOOL,
-		     std::string()+"'"+_name+"' is a bool option");
+std::string()+"'"+_name+"' is a bool option");
-	return *(i->second.bool_p);
+return *(i->second.bool_p);
 }
 ///\e
 operator std::string()
 {
-	Opts::iterator i = _parser._opts.find(_name);
+Opts::iterator i = _parser._opts.find(_name);
-	LEMON_ASSERT(i!=_parser._opts.end(),
+LEMON_ASSERT(i!=_parser._opts.end(),
-		     std::string()+"Unkown option: '"+_name+"'");
+std::string()+"Unkown option: '"+_name+"'");
-	LEMON_ASSERT(i->second.type==ArgParser::STRING,
+LEMON_ASSERT(i->second.type==ArgParser::STRING,
-		     std::string()+"'"+_name+"' is a string option");
+std::string()+"'"+_name+"' is a string option");
-	return *(i->second.string_p);
+return *(i->second.string_p);
 }
 ///\e
 operator double()
 {
-	Opts::iterator i = _parser._opts.find(_name);
+Opts::iterator i = _parser._opts.find(_name);
-	LEMON_ASSERT(i!=_parser._opts.end(),
+LEMON_ASSERT(i!=_parser._opts.end(),
-		     std::string()+"Unkown option: '"+_name+"'");
+std::string()+"Unkown option: '"+_name+"'");
-	LEMON_ASSERT(i->second.type==ArgParser::DOUBLE ||
+LEMON_ASSERT(i->second.type==ArgParser::DOUBLE ||
-		     i->second.type==ArgParser::INTEGER,
+i->second.type==ArgParser::INTEGER,
-		     std::string()+"'"+_name+"' is a floating point option");
+std::string()+"'"+_name+"' is a floating point option");
-	return i->second.type==ArgParser::DOUBLE ?
+return i->second.type==ArgParser::DOUBLE ?
-	  *(i->second.double_p) : *(i->second.int_p);
+*(i->second.double_p) : *(i->second.int_p);
 }
 ///\e
 operator int()
 {
-	Opts::iterator i = _parser._opts.find(_name);
+Opts::iterator i = _parser._opts.find(_name);
-	LEMON_ASSERT(i!=_parser._opts.end(),
+LEMON_ASSERT(i!=_parser._opts.end(),
-		     std::string()+"Unkown option: '"+_name+"'");
+std::string()+"Unkown option: '"+_name+"'");
-	LEMON_ASSERT(i->second.type==ArgParser::INTEGER,
+LEMON_ASSERT(i->second.type==ArgParser::INTEGER,
-		     std::string()+"'"+_name+"' is an integer option");
+std::string()+"'"+_name+"' is an integer option");
-	return *(i->second.int_p);
+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);
 }
 ///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; }
 };
 }
 #endif // LEMON_ARG_PARSER

changeset 211	542dd614cbb4
parent 204	77d56a21c3ab
child 214	60eecd3fe37a