wibble 1.1
options.h
Go to the documentation of this file.
1#ifndef WIBBLE_COMMANDLINE_OPTIONS_H
2#define WIBBLE_COMMANDLINE_OPTIONS_H
3
5#include <string>
6#include <vector>
7
8namespace wibble {
9namespace commandline {
10
11// Types of values for the command line options
12
13struct Bool
14{
15 typedef bool value_type;
16 static bool parse(const std::string& val);
17
18 static bool toBool(const value_type& val);
19 static int toInt(const value_type& val);
20 static std::string toString(const value_type& val);
21 static bool init_val;
22};
23
24struct Int
25{
26 typedef int value_type;
27 static int parse(const std::string& val);
28
29 static bool toBool(const value_type& val);
30 static int toInt(const value_type& val);
31 static std::string toString(const value_type& val);
32 static int init_val;
33};
34
35struct String
36{
37 typedef std::string value_type;
38 static std::string parse(const std::string& val);
39
40 static bool toBool(const value_type& val);
41 static int toInt(const value_type& val);
42 static std::string toString(const value_type& val);
43 static std::string init_val;
44};
45
47{
48 typedef std::string value_type;
49 static std::string parse(const std::string& val);
50 static std::string toString(const value_type& val);
51 static std::string init_val;
52};
53
55class Option : public Managed
56{
57 std::string m_name;
58 mutable std::string m_fullUsage;
59
60protected:
61 bool m_isset;
62
63 Option(const std::string& name) : m_name(name), m_isset(false), hidden(false) {}
64 Option(const std::string& name,
65 char shortName,
66 const std::string& longName,
67 const std::string& usage = std::string(),
68 const std::string& description = std::string())
70 {
71 if (shortName != 0)
72 shortNames.push_back(shortName);
73 if (!longName.empty())
74 longNames.push_back(longName);
75 }
76
88 virtual ArgList::iterator parse(ArgList& list, ArgList::iterator begin) = 0;
89
95 virtual bool parse(const std::string& param) = 0;
96
101 virtual void parse_noarg() = 0;
102
104 virtual bool arg_is_optional() const { return false; }
105
106public:
107 Option();
108 virtual ~Option() {}
109
110 bool isSet() const { return m_isset; }
111 const std::string& name() const { return m_name; }
112
113 void addAlias(char c) { shortNames.push_back(c); }
114 void addAlias(const std::string& str) { longNames.push_back(str); }
115
117 const std::string& fullUsage() const;
118 std::string fullUsageForMan() const;
119
120 std::vector<char> shortNames;
121 std::vector<std::string> longNames;
122
123 std::string usage;
124 std::string description;
125
126 // Set to true if the option should not be documented
127 bool hidden;
128
129 friend class OptionGroup;
130 friend class Engine;
131};
132
134class BoolOption : public Option
135{
136 bool m_value;
137
138protected:
139 BoolOption(const std::string& name)
140 : Option(name), m_value(false) {}
141 BoolOption(const std::string& name,
142 char shortName,
143 const std::string& longName,
144 const std::string& usage = std::string(),
145 const std::string& description = std::string())
147
148 virtual ArgList::iterator parse(ArgList&, ArgList::iterator begin) { parse_noarg(); return begin; }
149 virtual bool parse(const std::string&) { parse_noarg(); return false; }
150 virtual void parse_noarg() { m_isset = true; m_value = true; }
151
152public:
153 bool boolValue() const { return m_value; }
154 std::string stringValue() const { return m_value ? "true" : "false"; }
155
156 friend class OptionGroup;
157 friend class Engine;
158};
159
160template<typename T>
161class SingleOption : public Option
162{
163protected:
164 typename T::value_type m_value;
165
166 SingleOption(const std::string& name)
167 : Option(name), m_value(T::init_val)
168 {
169 usage = "<val>";
170 }
171 SingleOption(const std::string& name,
172 char shortName,
173 const std::string& longName,
174 const std::string& usage = std::string(),
175 const std::string& description = std::string())
177 {
178 if (usage.empty())
179 this->usage = "<val>";
180 }
181
182 ArgList::iterator parse(ArgList& list, ArgList::iterator begin)
183 {
184 if (begin == list.end())
185 throw exception::BadOption("option requires an argument");
186 m_value = T::parse(*begin);
187 m_isset = true;
188 // Remove the parsed element
189 return list.eraseAndAdvance(begin);
190 }
191 bool parse(const std::string& param)
192 {
193 m_value = T::parse(param);
194 m_isset = true;
195 return true;
196 }
198 {
199 throw exception::BadOption("option requires an argument");
200 }
201
202public:
203 void setValue( const typename T::value_type &a ) {
204 m_value = a;
205 }
206
207 typename T::value_type value() const { return m_value; }
208
209 // Deprecated
210 bool boolValue() const { return T::toBool(m_value); }
211 int intValue() const { return T::toInt(m_value); }
212 std::string stringValue() const { return T::toString(m_value); }
213
214 friend class OptionGroup;
215 friend class Engine;
216};
217
224template<typename T>
226{
227protected:
228 typename T::value_type m_value;
230
231 SingleOptvalOption(const std::string& name)
232 : Option(name)
233 {
234 usage = "<val>";
235 }
236 SingleOptvalOption(const std::string& name,
237 char shortName,
238 const std::string& longName,
239 const std::string& usage = std::string(),
240 const std::string& description = std::string())
242 {
243 if (shortName != 0)
245 "creating option " + name + " with optional value"
246 "short options with optional values are not allowed");
247 if (usage.empty())
248 this->usage = "<val>";
249 }
250
251 ArgList::iterator parse(ArgList& list, ArgList::iterator begin)
252 {
254 "parsing option with optional value"
255 "short options with optional values are not allowed");
256 }
257 bool parse(const std::string& param)
258 {
259 m_value = T::parse(param);
260 m_isset = true;
261 m_hasval = true;
262 return true;
263 }
265 {
266 m_isset = true;
267 m_hasval = false;
268 }
269
270 virtual bool arg_is_optional() const { return true; }
271
272public:
273 bool hasValue() const { return m_hasval; }
274
275 void setValue( const typename T::value_type &a ) {
276 m_value = a;
277 }
278
279 typename T::value_type value() const { return m_value; }
280
281 friend class OptionGroup;
282 friend class Engine;
283};
284
285// Option needing a compulsory string value
287
288// Option with an optional string value
290
291// Option needing a compulsory int value
293
294// Option with an optional int value
296
299
302
303
304// Option that can be specified multiple times
305template<typename T>
306class VectorOption : public Option
307{
308 std::vector< typename T::value_type > m_values;
309
310protected:
311 VectorOption(const std::string& name)
312 : Option(name)
313 {
314 usage = "<val>";
315 }
316 VectorOption(const std::string& name,
317 char shortName,
318 const std::string& longName,
319 const std::string& usage = std::string(),
320 const std::string& description = std::string())
322 {
323 if (usage.empty())
324 this->usage = "<val>";
325 }
326
327 ArgList::iterator parse(ArgList& list, ArgList::iterator begin)
328 {
329 if (begin == list.end())
330 throw exception::BadOption("no string argument found");
331 m_isset = true;
332 m_values.push_back(T::parse(*begin));
333 // Remove the parsed element
334 return list.eraseAndAdvance(begin);
335 }
336 bool parse(const std::string& param)
337 {
338 m_isset = true;
339 m_values.push_back(T::parse(param));
340 return true;
341 }
343 {
344 throw exception::BadOption("option requires an argument");
345 }
346
347public:
348 bool boolValue() const { return !m_values.empty(); }
349 const std::vector< typename T::value_type >& values() const { return m_values; }
350
351 friend class OptionGroup;
352 friend class Engine;
353};
354
355
359class OptionGroup : public Managed
360{
361 MemoryManager* m_manager;
362
363protected:
364 OptionGroup(MemoryManager* mman = 0, const std::string& description = std::string())
365 : m_manager(mman), description(description), hidden(false) {}
366
367public:
368 Option* add(Option* o) { options.push_back(o); return o; }
369
370 std::vector<Option*> options;
371
372 std::string description;
373
374 // Set to true if the option group should not be documented
375 bool hidden;
376
380 template<typename T>
381 T* create(const std::string& name,
382 char shortName,
383 const std::string& longName,
384 const std::string& usage = std::string(),
385 const std::string& description = std::string())
386 {
387 T* item = new T(name, shortName, longName, usage, description);
388 if (m_manager) m_manager->add(item);
389 return item;
390 }
391
395 template<typename T>
396 T* add(const std::string& name,
397 char shortName,
398 const std::string& longName,
399 const std::string& usage = std::string(),
400 const std::string& description = std::string())
401 {
402 T* res = create<T>(name, shortName, longName, usage, description);
403 add(res);
404 return res;
405 }
406
407 friend class Engine;
408};
409
410}
411}
412
413// vim:set ts=4 sw=4:
414#endif
Definition core.h:30
iterator & eraseAndAdvance(iterator &i)
Definition core.h:34
Boolean option.
Definition options.h:135
BoolOption(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Definition options.h:141
BoolOption(const std::string &name)
Definition options.h:139
std::string stringValue() const
Definition options.h:154
bool boolValue() const
Definition options.h:153
virtual ArgList::iterator parse(ArgList &, ArgList::iterator begin)
Parse the next commandline parameter after the short form of the command has been found.
Definition options.h:148
virtual void parse_noarg()
Notify that the option is present in the command line, but has no arguments.
Definition options.h:150
virtual bool parse(const std::string &)
Parse the commandline parameter of a long commandline switch.
Definition options.h:149
Parse commandline options.
Definition engine.h:39
Definition core.h:52
Keep track of various wibble::commandline components, and deallocate them at object destruction.
Definition core.h:63
T * add(T *item)
Definition core.h:76
Group related commandline options.
Definition options.h:360
T * create(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Create a new option.
Definition options.h:381
T * add(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Create a new option and add it to this group.
Definition options.h:396
std::vector< Option * > options
Definition options.h:370
std::string description
Definition options.h:372
OptionGroup(MemoryManager *mman=0, const std::string &description=std::string())
Definition options.h:364
Option * add(Option *o)
Definition options.h:368
bool hidden
Definition options.h:375
Interface for a parser for one commandline option.
Definition options.h:56
virtual bool parse(const std::string &param)=0
Parse the commandline parameter of a long commandline switch.
virtual bool arg_is_optional() const
Return true if the argument to this function can be omitted.
Definition options.h:104
std::vector< std::string > longNames
Definition options.h:121
Option()
Definition options.cpp:99
std::string usage
Definition options.h:123
void addAlias(const std::string &str)
Definition options.h:114
virtual ~Option()
Definition options.h:108
virtual void parse_noarg()=0
Notify that the option is present in the command line, but has no arguments.
virtual ArgList::iterator parse(ArgList &list, ArgList::iterator begin)=0
Parse the next commandline parameter after the short form of the command has been found.
std::string description
Definition options.h:124
Option(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Definition options.h:64
const std::string & name() const
Definition options.h:111
const std::string & fullUsage() const
Return a full usage message including all the aliases for this option.
Definition options.cpp:101
std::vector< char > shortNames
Definition options.h:120
bool hidden
Definition options.h:127
void addAlias(char c)
Definition options.h:113
bool isSet() const
Definition options.h:110
bool m_isset
Definition options.h:61
std::string fullUsageForMan() const
Definition options.cpp:124
Option(const std::string &name)
Definition options.h:63
Definition options.h:162
SingleOption(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Definition options.h:171
bool parse(const std::string &param)
Parse the commandline parameter of a long commandline switch.
Definition options.h:191
ArgList::iterator parse(ArgList &list, ArgList::iterator begin)
Parse the next commandline parameter after the short form of the command has been found.
Definition options.h:182
T::value_type m_value
Definition options.h:164
T::value_type value() const
Definition options.h:207
int intValue() const
Definition options.h:211
std::string stringValue() const
Definition options.h:212
void setValue(const typename T::value_type &a)
Definition options.h:203
void parse_noarg()
Notify that the option is present in the command line, but has no arguments.
Definition options.h:197
SingleOption(const std::string &name)
Definition options.h:166
bool boolValue() const
Definition options.h:210
Single option whose value can be or not be specified.
Definition options.h:226
virtual bool arg_is_optional() const
Return true if the argument to this function can be omitted.
Definition options.h:270
SingleOptvalOption(const std::string &name)
Definition options.h:231
T::value_type m_value
Definition options.h:228
bool parse(const std::string &param)
Parse the commandline parameter of a long commandline switch.
Definition options.h:257
ArgList::iterator parse(ArgList &list, ArgList::iterator begin)
Parse the next commandline parameter after the short form of the command has been found.
Definition options.h:251
bool hasValue() const
Definition options.h:273
T::value_type value() const
Definition options.h:279
void setValue(const typename T::value_type &a)
Definition options.h:275
SingleOptvalOption(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Definition options.h:236
void parse_noarg()
Notify that the option is present in the command line, but has no arguments.
Definition options.h:264
bool m_hasval
Definition options.h:229
Definition options.h:307
ArgList::iterator parse(ArgList &list, ArgList::iterator begin)
Parse the next commandline parameter after the short form of the command has been found.
Definition options.h:327
VectorOption(const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
Definition options.h:316
VectorOption(const std::string &name)
Definition options.h:311
bool parse(const std::string &param)
Parse the commandline parameter of a long commandline switch.
Definition options.h:336
void parse_noarg()
Notify that the option is present in the command line, but has no arguments.
Definition options.h:342
bool boolValue() const
Definition options.h:348
const std::vector< typename T::value_type > & values() const
Definition options.h:349
Definition core.h:13
Exception thrown when some consistency check fails.
Definition exception.h:255
void usage(ostream &out, const string &argv0)
Definition commandline-demo.cpp:75
SingleOptvalOption< ExistingFile > OptvalExistingFileOption
Commandline option with an optional argument naming a file which must exist.
Definition options.h:301
SingleOptvalOption< Int > OptvalIntOption
Definition options.h:295
SingleOption< Int > IntOption
Definition options.h:292
SingleOptvalOption< String > OptvalStringOption
Definition options.h:289
SingleOption< String > StringOption
Definition options.h:286
SingleOption< ExistingFile > ExistingFileOption
Commandline option with a mandatory argument naming a file which must exist.
Definition options.h:298
Definition amorph.h:17
Definition amorph.h:30
Definition options.h:14
static std::string toString(const value_type &val)
Definition options.cpp:27
bool value_type
Definition options.h:15
static bool toBool(const value_type &val)
Definition options.cpp:25
static bool init_val
Definition options.h:21
static bool parse(const std::string &val)
Definition options.cpp:17
static int toInt(const value_type &val)
Definition options.cpp:26
Definition options.h:47
std::string value_type
Definition options.h:48
static std::string parse(const std::string &val)
static std::string toString(const value_type &val)
Definition options.cpp:60
static std::string init_val
Definition options.h:51
Definition options.h:25
static bool toBool(const value_type &val)
Definition options.cpp:38
static int parse(const std::string &val)
Definition options.cpp:30
int value_type
Definition options.h:26
static int init_val
Definition options.h:32
static std::string toString(const value_type &val)
Definition options.cpp:40
static int toInt(const value_type &val)
Definition options.cpp:39
Definition options.h:36
static std::string parse(const std::string &val)
Definition options.cpp:43
static std::string init_val
Definition options.h:43
static std::string toString(const value_type &val)
Definition options.cpp:49
static bool toBool(const value_type &val)
Definition options.cpp:47
std::string value_type
Definition options.h:37
static int toInt(const value_type &val)
Definition options.cpp:48