Mercuriallemon-0.x / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
lemon/arg_parser.h
changeset 2403 b8f65d8528e1
parent 2391 14a343be7a5a
child 2406 0ffc78641b34
equal deleted inserted replaced
1:be8f36cd21fb 2:bf56561b4f26 
    68       OptType type;
 
    68       OptType type;
 
    69       bool set;
 
    69       bool set;
 
    70       bool ingroup;
 
    70       bool ingroup;
 
    71       bool has_syn;
 
    71       bool has_syn;
 
    72       bool syn;
 
    72       bool syn;
 
    73 	     
    73       bool self_delete;
 
    74       ParData() : mandatory(false), type(UNKNOWN), set(false), ingroup(false),
 
    74       ParData() : mandatory(false), type(UNKNOWN), set(false), ingroup(false),
 
    75 		  has_syn(false), syn(false) {}
 
    75 		  has_syn(false), syn(false), self_delete(false) {}
 
    76     };
 
    76     };
 
    77 
    77 
    78     typedef std::map<std::string,ParData> Opts;
 
    78     typedef std::map<std::string,ParData> Opts;
 
    79     Opts _opts;
 
    79     Opts _opts;
 
    80 
    80 
   106   public:
 
   106   public:
 
   107 
   107 
   108     ///\e
 
   108     ///\e
 
   109     ArgParser(int argc, char **argv);
 
   109     ArgParser(int argc, char **argv);
 
   110 
   110 
       
   111     ~ArgParser();
 
       
   112 
   111     ///Add a new integer type option
 
   113     ///Add a new integer type option
 
   112 
   114 
   113     ///\param name The name of the option. The leading '-' must be omitted.
 
   115     ///\param name The name of the option. The leading '-' must be omitted.
 
   114     ///\param help A help string.
 
   116     ///\param help A help string.
 
   115     ///\retval value The value of the argument will be written to this variable.
 
   117     ///\retval value The value of the argument will be written to this variable.
 
   116     ///\param obl Indicate if the option is mandatory.
 
   118     ///\param obl Indicate if the option is mandatory.
 
   117     ArgParser &option(const std::string &name,
 
   119     ArgParser &intOption(const std::string &name,
 
       
   120 		    const std::string &help,
 
       
   121 		    int value=0, bool obl=false);
 
       
   122 
       
   123     ///Add a new floating type option
 
       
   124 
       
   125     ///\param name The name of the option. The leading '-' must be omitted.
 
       
   126     ///\param help A help string.
 
       
   127     ///\retval value The value of the argument will be written to this variable.
 
       
   128     ///\param obl Indicate if the option is mandatory.
 
       
   129     ArgParser &doubleOption(const std::string &name,
 
       
   130 		      const std::string &help,
 
       
   131 		      double value=0, bool obl=false);
 
       
   132 
       
   133     ///Add a new bool type option
 
       
   134 
       
   135     ///\param name The name of the option. The leading '-' must be omitted.
 
       
   136     ///\param help A help string.
 
       
   137     ///\retval value The value of the argument will be written to this variable.
 
       
   138     ///\param obl Indicate if the option is mandatory.
 
       
   139     ////\note A mandatory bool obtion is of very little use.)
 
       
   140     ArgParser &boolOption(const std::string &name,
 
       
   141 		      const std::string &help,
 
       
   142 		      bool value=false, bool obl=false);
 
       
   143 
       
   144     ///Add a new string type option
 
       
   145 
       
   146     ///\param name The name of the option. The leading '-' must be omitted.
 
       
   147     ///\param help A help string.
 
       
   148     ///\retval value The value of the argument will be written to this variable.
 
       
   149     ///\param obl Indicate if the option is mandatory.
 
       
   150     ArgParser &stringOption(const std::string &name,
 
       
   151 		      const std::string &help,
 
       
   152 		      std::string value="", bool obl=false);
 
       
   153     
       
   154 
       
   155 
       
   156 
       
   157     ///Add a new integer type option
 
       
   158 
       
   159     ///\param name The name of the option. The leading '-' must be omitted.
 
       
   160     ///\param help A help string.
 
       
   161     ///\retval value The value of the argument will be written to this variable.
 
       
   162     ///\param obl Indicate if the option is mandatory.
 
       
   163     ArgParser &refOption(const std::string &name,
 
   118 		    const std::string &help,
 
   164 		    const std::string &help,
 
   119 		    int &value, bool obl=false);
 
   165 		    int &value, bool obl=false);
 
   120 
   166 
   121     ///Add a new floating type option
 
   167     ///Add a new floating type option
 
   122 
   168 
   123     ///\param name The name of the option. The leading '-' must be omitted.
 
   169     ///\param name The name of the option. The leading '-' must be omitted.
 
   124     ///\param help A help string.
 
   170     ///\param help A help string.
 
   125     ///\retval value The value of the argument will be written to this variable.
 
   171     ///\retval value The value of the argument will be written to this variable.
 
   126     ///\param obl Indicate if the option is mandatory.
 
   172     ///\param obl Indicate if the option is mandatory.
 
   127     ArgParser &option(const std::string &name,
 
   173     ArgParser &refOption(const std::string &name,
 
   128 		      const std::string &help,
 
   174 		      const std::string &help,
 
   129 		      double &value, bool obl=false);
 
   175 		      double &value, bool obl=false);
 
   130 
   176 
   131     ///Add a new bool type option
 
   177     ///Add a new bool type option
 
   132 
   178 
   133     ///\param name The name of the option. The leading '-' must be omitted.
 
   179     ///\param name The name of the option. The leading '-' must be omitted.
 
   134     ///\param help A help string.
 
   180     ///\param help A help string.
 
   135     ///\retval value The value of the argument will be written to this variable.
 
   181     ///\retval value The value of the argument will be written to this variable.
 
   136     ///\param obl Indicate if the option is mandatory.
 
   182     ///\param obl Indicate if the option is mandatory.
 
   137     ////\note A mandatory bool obtion is of very little use.)
 
   183     ////\note A mandatory bool obtion is of very little use.)
 
   138     ArgParser &option(const std::string &name,
 
   184     ArgParser &refOption(const std::string &name,
 
   139 		      const std::string &help,
 
   185 		      const std::string &help,
 
   140 		      bool &value, bool obl=false);
 
   186 		      bool &value, bool obl=false);
 
   141 
   187 
   142     ///Add a new string type option
 
   188     ///Add a new string type option
 
   143 
   189 
   144     ///\param name The name of the option. The leading '-' must be omitted.
 
   190     ///\param name The name of the option. The leading '-' must be omitted.
 
   145     ///\param help A help string.
 
   191     ///\param help A help string.
 
   146     ///\retval value The value of the argument will be written to this variable.
 
   192     ///\retval value The value of the argument will be written to this variable.
 
   147     ///\param obl Indicate if the option is mandatory.
 
   193     ///\param obl Indicate if the option is mandatory.
 
   148     ArgParser &option(const std::string &name,
 
   194     ArgParser &refOption(const std::string &name,
 
   149 		      const std::string &help,
 
   195 		      const std::string &help,
 
   150 		      std::string &value, bool obl=false);
 
   196 		      std::string &value, bool obl=false);
 
   151     
   197     
   152     ///Bind a function to an option.
 
   198     ///Bind a function to an option.
 
   153 
   199 
   154     ///\param name The name of the option. The leading '-' must be omitted.
 
   200     ///\param name The name of the option. The leading '-' must be omitted.
 
   155     ///\param help A help string.
 
   201     ///\param help A help string.
 
   156     ///\retval func The function to be called when the option is given. It
 
   202     ///\retval func The function to be called when the option is given. It
 
   157     ///  must be of type "void f(void *)"
 
   203     ///  must be of type "void f(void *)"
 
   158     ///\param data Data to be passed to \c func
 
   204     ///\param data Data to be passed to \c func
 
   159     ArgParser &option(const std::string &name,
 
   205     ArgParser &refOption(const std::string &name,
 
   160 		    const std::string &help,
 
   206 		    const std::string &help,
 
   161 		    void (*func)(void *),void *data);
 
   207 		    void (*func)(void *),void *data);
 
   162 
   208 
   163     ///Boundle some options into a group
 
   209     ///Boundle some options into a group
 
   164 
   210 
   230     bool given(std::string op) 
   276     bool given(std::string op) 
   231     {
 
   277     {
 
   232       Opts::iterator i = _opts.find(op);
 
   278       Opts::iterator i = _opts.find(op);
 
   233       return i!=_opts.end()?i->second.set:false;
 
   279       return i!=_opts.end()?i->second.set:false;
 
   234     }
 
   280     }
 
   235     
   281 
       
   282 
       
   283     class RefType 
       
   284     {
 
       
   285       ArgParser &_parser;
 
       
   286       std::string _name;
 
       
   287     public:
 
       
   288       RefType(ArgParser &p,const std::string &n) :_parser(p),_name(n) {}
 
       
   289       operator bool() 
       
   290       {
 
       
   291 	Opts::iterator i = _parser._opts.find(_name);
 
       
   292 	if(i==_parser._opts.end()) exit(3); ///\todo throw exception instead
 
       
   293 	else if(i->second.type!=ArgParser::BOOL) exit(3);
 
       
   294 	else return *(i->second.bool_p);
 
       
   295       }
 
       
   296       operator std::string()
 
       
   297       {
 
       
   298 	Opts::iterator i = _parser._opts.find(_name);
 
       
   299 	if(i==_parser._opts.end()) exit(3); ///\todo throw exception instead
 
       
   300 	else if(i->second.type!=ArgParser::STRING) exit(3);
 
       
   301 	else return *(i->second.string_p);
 
       
   302       }
 
       
   303       operator double() 
       
   304       {
 
       
   305 	Opts::iterator i = _parser._opts.find(_name);
 
       
   306 	if(i==_parser._opts.end()) exit(3); ///\todo throw exception instead
 
       
   307 	else if(i->second.type!=ArgParser::DOUBLE) exit(3);
 
       
   308 	else return *(i->second.double_p);
 
       
   309       }
 
       
   310       operator int() 
       
   311       {
 
       
   312 	Opts::iterator i = _parser._opts.find(_name);
 
       
   313 	if(i==_parser._opts.end()) exit(3); ///\todo throw exception instead
 
       
   314 	else if(i->second.type!=ArgParser::INTEGER) exit(3);
 
       
   315 	else return *(i->second.int_p);
 
       
   316       }
 
       
   317 
       
   318     };
 
       
   319 
       
   320     RefType operator[](const std::string &n)
 
       
   321     {
 
       
   322       return RefType(*this, n);
 
       
   323     }
 
       
   324     
       
   325       
   236   };
 
   326   };
 
   237 }
 
   327 }
 
   238 
   328 
   239     
   329     
   240 
   330
lemon-0.x