|
1 /* -*- C++ -*- |
|
2 * lemon/main_params.h - Part of LEMON, a generic C++ optimization library |
|
3 * |
|
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
|
5 * (Egervary Research Group on Combinatorial Optimization, EGRES). |
|
6 * |
|
7 * Permission to use, modify and distribute this software is granted |
|
8 * provided that this copyright notice appears in all copies. For |
|
9 * precise terms see the accompanying LICENSE file. |
|
10 * |
|
11 * This software is provided "AS IS" with no warranty of any kind, |
|
12 * express or implied, and with no claim as to its suitability for any |
|
13 * purpose. |
|
14 * |
|
15 */ |
|
16 |
|
17 #include <lemon/arg_parser.h> |
|
18 |
|
19 namespace lemon { |
|
20 |
|
21 void ArgParser::_showHelp(void *p) |
|
22 { |
|
23 ((ArgParser*)p)->showHelp(); |
|
24 exit(1); |
|
25 } |
|
26 |
|
27 ArgParser::ArgParser(int argc, char **argv) :_argc(argc), _argv(argv), |
|
28 _command_name(argv[0]) { |
|
29 option("-help","Print a short help message",_showHelp,this); |
|
30 synonym("help","-help"); |
|
31 synonym("h","-help"); |
|
32 |
|
33 } |
|
34 |
|
35 ArgParser &ArgParser::option(const std::string &name, |
|
36 const std::string &help, |
|
37 int &value, bool obl) |
|
38 { |
|
39 ParData p; |
|
40 p.int_p=&value; |
|
41 p.help=help; |
|
42 p.type=INTEGER; |
|
43 p.mandatory=obl; |
|
44 _opts[name]=p; |
|
45 return *this; |
|
46 } |
|
47 |
|
48 ArgParser &ArgParser::option(const std::string &name, |
|
49 const std::string &help, |
|
50 double &value, bool obl) |
|
51 { |
|
52 ParData p; |
|
53 p.double_p=&value; |
|
54 p.help=help; |
|
55 p.type=DOUBLE; |
|
56 p.mandatory=obl; |
|
57 _opts[name]=p; |
|
58 return *this; |
|
59 } |
|
60 |
|
61 ArgParser &ArgParser::option(const std::string &name, |
|
62 const std::string &help, |
|
63 bool &value, bool obl) |
|
64 { |
|
65 ParData p; |
|
66 p.bool_p=&value; |
|
67 p.help=help; |
|
68 p.type=BOOL; |
|
69 p.mandatory=obl; |
|
70 _opts[name]=p; |
|
71 |
|
72 value = false; |
|
73 |
|
74 return *this; |
|
75 } |
|
76 |
|
77 ArgParser &ArgParser::option(const std::string &name, |
|
78 const std::string &help, |
|
79 std::string &value, bool obl) |
|
80 { |
|
81 ParData p; |
|
82 p.string_p=&value; |
|
83 p.help=help; |
|
84 p.type=STRING; |
|
85 p.mandatory=obl; |
|
86 _opts[name]=p; |
|
87 return *this; |
|
88 } |
|
89 |
|
90 ArgParser &ArgParser::option(const std::string &name, |
|
91 const std::string &help, |
|
92 void (*func)(void *),void *data) |
|
93 { |
|
94 ParData p; |
|
95 p.func_p.p=func; |
|
96 p.func_p.data=data; |
|
97 p.help=help; |
|
98 p.type=FUNC; |
|
99 p.mandatory=false; |
|
100 _opts[name]=p; |
|
101 return *this; |
|
102 } |
|
103 ArgParser &ArgParser::optionGroup(const std::string &group, |
|
104 const std::string &opt) |
|
105 { |
|
106 Opts::iterator i = _opts.find(opt); |
|
107 if(i==_opts.end()) exit(3); ///\todo throw exception instead |
|
108 else if(i->second.ingroup) exit(3); ///\todo throw exception instead |
|
109 else { |
|
110 GroupData &g=_groups[group]; |
|
111 g.opts.push_back(opt); |
|
112 i->second.ingroup=true; |
|
113 } |
|
114 return *this; |
|
115 } |
|
116 |
|
117 ArgParser &ArgParser::onlyOneGroup(const std::string &group) |
|
118 { |
|
119 GroupData &g=_groups[group]; |
|
120 g.only_one=true; |
|
121 return *this; |
|
122 } |
|
123 |
|
124 ArgParser &ArgParser::synonym(const std::string &syn, |
|
125 const std::string &opt) |
|
126 { |
|
127 Opts::iterator o = _opts.find(opt); |
|
128 Opts::iterator s = _opts.find(syn); |
|
129 if(o==_opts.end()||s!=_opts.end()) |
|
130 exit(3); ///\todo throw exception instead |
|
131 else { |
|
132 ParData p; |
|
133 p.help=opt; |
|
134 p.mandatory=false; |
|
135 p.syn=true; |
|
136 _opts[syn]=p; |
|
137 o->second.has_syn=true; |
|
138 } |
|
139 return *this; |
|
140 } |
|
141 |
|
142 ArgParser &ArgParser::mandatoryGroup(const std::string &group) |
|
143 { |
|
144 GroupData &g=_groups[group]; |
|
145 g.mandatory=true; |
|
146 return *this; |
|
147 } |
|
148 |
|
149 ArgParser &ArgParser::other(const std::string &name, |
|
150 const std::string &help) |
|
151 { |
|
152 _others_help.push_back(OtherArg(name,help)); |
|
153 return *this; |
|
154 } |
|
155 |
|
156 void ArgParser::show(std::ostream &os,Opts::iterator i) |
|
157 { |
|
158 os << "-" << i->first; |
|
159 if(i->second.has_syn) |
|
160 for(Opts::iterator j=_opts.begin();j!=_opts.end();++j) |
|
161 if(j->second.syn&&j->second.help==i->first) |
|
162 os << "|-" << j->first; |
|
163 switch(i->second.type) { |
|
164 case STRING: |
|
165 os << " str"; |
|
166 break; |
|
167 case INTEGER: |
|
168 os << " int"; |
|
169 break; |
|
170 case DOUBLE: |
|
171 os << " num"; |
|
172 break; |
|
173 default: |
|
174 break; |
|
175 } |
|
176 } |
|
177 |
|
178 void ArgParser::show(std::ostream &os,Groups::iterator i) |
|
179 { |
|
180 GroupData::Opts::iterator o=i->second.opts.begin(); |
|
181 while(o!=i->second.opts.end()) { |
|
182 show(os,_opts.find(*o)); |
|
183 ++o; |
|
184 if(o!=i->second.opts.end()) os<<'|'; |
|
185 } |
|
186 } |
|
187 |
|
188 void ArgParser::showHelp(Opts::iterator i) |
|
189 { |
|
190 if(i->second.help.size()==0||i->second.syn) return; |
|
191 std::cerr << " "; |
|
192 show(std::cerr,i); |
|
193 std::cerr << std::endl; |
|
194 std::cerr << " " << i->second.help << std::endl; |
|
195 } |
|
196 void ArgParser::showHelp(std::vector<ArgParser::OtherArg>::iterator i) |
|
197 { |
|
198 if(i->help.size()==0) return; |
|
199 std::cerr << " " << i->name << std::endl |
|
200 << " " << i->help << std::endl; |
|
201 } |
|
202 |
|
203 void ArgParser::shortHelp() |
|
204 { |
|
205 const unsigned int LINE_LEN=77; |
|
206 const std::string indent(" "); |
|
207 std::cerr << "Usage:\n " << _command_name; |
|
208 int pos=_command_name.size()+2; |
|
209 for(Groups::iterator g=_groups.begin();g!=_groups.end();++g) { |
|
210 std::ostringstream cstr; |
|
211 cstr << ' '; |
|
212 if(!g->second.mandatory) cstr << '['; |
|
213 show(cstr,g); |
|
214 if(!g->second.mandatory) cstr << ']'; |
|
215 if(pos+cstr.str().size()>LINE_LEN) { |
|
216 std::cerr << std::endl << indent; |
|
217 pos=indent.size(); |
|
218 } |
|
219 std::cerr << cstr.str(); |
|
220 pos+=cstr.str().size(); |
|
221 } |
|
222 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) |
|
223 if(!i->second.ingroup&&!i->second.syn) { |
|
224 std::ostringstream cstr; |
|
225 cstr << ' '; |
|
226 if(!i->second.mandatory) cstr << '['; |
|
227 show(cstr,i); |
|
228 if(!i->second.mandatory) cstr << ']'; |
|
229 if(pos+cstr.str().size()>LINE_LEN) { |
|
230 std::cerr << std::endl << indent; |
|
231 pos=indent.size(); |
|
232 } |
|
233 std::cerr << cstr.str(); |
|
234 pos+=cstr.str().size(); |
|
235 } |
|
236 for(std::vector<OtherArg>::iterator i=_others_help.begin(); |
|
237 i!=_others_help.end();++i) |
|
238 { |
|
239 std::ostringstream cstr; |
|
240 cstr << ' ' << i->name; |
|
241 |
|
242 if(pos+cstr.str().size()>LINE_LEN) { |
|
243 std::cerr << std::endl << indent; |
|
244 pos=indent.size(); |
|
245 } |
|
246 std::cerr << cstr.str(); |
|
247 pos+=cstr.str().size(); |
|
248 } |
|
249 std::cerr << std::endl; |
|
250 } |
|
251 |
|
252 void ArgParser::showHelp() |
|
253 { |
|
254 shortHelp(); |
|
255 std::cerr << "Where:\n"; |
|
256 for(std::vector<OtherArg>::iterator i=_others_help.begin(); |
|
257 i!=_others_help.end();++i) showHelp(i); |
|
258 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i); |
|
259 exit(1); |
|
260 } |
|
261 |
|
262 |
|
263 void ArgParser::unknownOpt(std::string arg) |
|
264 { |
|
265 std::cerr << "\nUnknown option: " << arg << "\n"; |
|
266 std::cerr << "\nType '" << _command_name << |
|
267 " --help' to obtain a short summary on the usage.\n\n"; |
|
268 exit(1); |
|
269 } |
|
270 |
|
271 void ArgParser::requiresValue(std::string arg, OptType t) |
|
272 { |
|
273 std::cerr << "Argument '" << arg << "' requires a"; |
|
274 switch(t) { |
|
275 case STRING: |
|
276 std::cerr << " string"; |
|
277 break; |
|
278 case INTEGER: |
|
279 std::cerr << "n integer"; |
|
280 break; |
|
281 case DOUBLE: |
|
282 std::cerr << " floating point"; |
|
283 break; |
|
284 default: |
|
285 break; |
|
286 } |
|
287 std::cerr << " value\n\n"; |
|
288 showHelp(); |
|
289 } |
|
290 |
|
291 |
|
292 void ArgParser::checkMandatories() |
|
293 { |
|
294 bool ok=true; |
|
295 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) |
|
296 if(i->second.mandatory&&!i->second.set) |
|
297 { |
|
298 if(ok) |
|
299 std::cerr << _command_name |
|
300 << ": The following mandatory arguments are missing.\n"; |
|
301 ok=false; |
|
302 showHelp(i); |
|
303 } |
|
304 for(Groups::iterator i=_groups.begin();i!=_groups.end();++i) |
|
305 if(i->second.mandatory||i->second.only_one) |
|
306 { |
|
307 int set=0; |
|
308 for(GroupData::Opts::iterator o=i->second.opts.begin(); |
|
309 o!=i->second.opts.end();++o) |
|
310 if(_opts.find(*o)->second.set) ++set; |
|
311 if(i->second.mandatory&&!set) { |
|
312 std::cerr << _command_name |
|
313 << ": At least one of the following arguments is mandatory.\n"; |
|
314 ok=false; |
|
315 for(GroupData::Opts::iterator o=i->second.opts.begin(); |
|
316 o!=i->second.opts.end();++o) |
|
317 showHelp(_opts.find(*o)); |
|
318 } |
|
319 if(i->second.only_one&&set>1) { |
|
320 std::cerr << _command_name |
|
321 << ": At most one of the following arguments can be given.\n"; |
|
322 ok=false; |
|
323 for(GroupData::Opts::iterator o=i->second.opts.begin(); |
|
324 o!=i->second.opts.end();++o) |
|
325 showHelp(_opts.find(*o)); |
|
326 } |
|
327 } |
|
328 if(!ok) { |
|
329 std::cerr << "\nType '" << _command_name << |
|
330 " --help' to obtain a short summary on the usage.\n\n"; |
|
331 exit(1); |
|
332 } |
|
333 } |
|
334 |
|
335 ArgParser &ArgParser::parse() |
|
336 { |
|
337 for(int ar=1; ar<_argc; ++ar) { |
|
338 std::string arg(_argv[ar]); |
|
339 if (arg[0] != '-' || arg.size() == 1) { |
|
340 _file_args.push_back(arg); |
|
341 } |
|
342 else { |
|
343 Opts::iterator i = _opts.find(arg.substr(1)); |
|
344 if(i==_opts.end()) unknownOpt(arg); |
|
345 else { |
|
346 if(i->second.syn) i=_opts.find(i->second.help); |
|
347 ParData &p(i->second); |
|
348 if (p.type==BOOL) *p.bool_p=true; |
|
349 else if (p.type==FUNC) p.func_p.p(p.func_p.data); |
|
350 else if(++ar==_argc) requiresValue(arg, p.type); |
|
351 else { |
|
352 std::string val(_argv[ar]); |
|
353 std::istringstream vals(val); |
|
354 switch(p.type) { |
|
355 case STRING: |
|
356 *p.string_p=val; |
|
357 break; |
|
358 case INTEGER: |
|
359 vals >> *p.int_p; |
|
360 break; |
|
361 case DOUBLE: |
|
362 vals >> *p.double_p; |
|
363 break; |
|
364 default: |
|
365 break; |
|
366 } |
|
367 if(p.type!=STRING&&(!vals||!vals.eof())) |
|
368 requiresValue(arg, p.type); |
|
369 } |
|
370 p.set = true; |
|
371 } |
|
372 } |
|
373 } |
|
374 checkMandatories(); |
|
375 |
|
376 return *this; |
|
377 } |
|
378 |
|
379 } |