};
+/**
+Command line option processor. Both short and long options are supported, with
+optional and required arguments. Automatic help text generation is also
+available.
+
+Short options begin with a single dash and are identified by a single letter.
+Multiple short options may be grouped if they take no arguments; for example,
+the string "-abc" could be interpreted as having the options 'a', 'b' and 'c'.
+If the option takes an argument and there are unused characters in the argv
+element, then those characters are interpreted as the argument. Otherwise the
+next element is taken as the argument. An optional argument must be given in
+the same element.
+
+Long options begin with a double dash and are identified by an arbitrary
+string. An argument can be specified either in the same argv element,
+separated by an equals sign, or in the next element. As with short options,
+an optional argument must be in the same element.
+
+A single option may have both alternative forms, but must always have at least
+a long form. This is to encourage self-documenting options; it's much easier
+to remember words than letters.
+
+A built-in --help option is provided and will output a list of options and
+their associated help texts. An application may override this by providing
+its own option with the same name.
+*/
class GetOpt
{
public:
OPTIONAL_ARG,
REQUIRED_ARG
};
-
+
class Option
{
protected:
public:
virtual ~Option() { }
+ /// Sets help text for the option.
virtual Option &set_help(const std::string &) = 0;
+
+ /** Sets help text for the option, with a placeholder metavariable. The
+ metavariable is used to denote the argument in the option list. */
virtual Option &set_help(const std::string &, const std::string &) = 0;
+
+ virtual Option &bind_seen_count(unsigned &) = 0;
+
+ /// Returns the number of times this option was seen on the command line.
virtual unsigned get_seen_count() const = 0;
};
private:
- class OptBase: public Option
+ class Store
+ {
+ protected:
+ Store() { }
+ public:
+ virtual ~Store() { }
+
+ virtual Store *clone() const = 0;
+
+ virtual void store() = 0;
+ virtual void store(const std::string &) = 0;
+ };
+
+ class OptionImpl: public Option
{
protected:
char shrt;
std::string lng;
ArgType arg_type;
unsigned seen_count;
+ unsigned *ext_seen_count;
std::string help;
std::string metavar;
+ Store *store;
- OptBase(char, const std::string &, ArgType);
public:
- virtual ~OptBase() { }
+ OptionImpl(char, const std::string &, const Store &, ArgType);
+ virtual ~OptionImpl();
- virtual OptBase &set_help(const std::string &);
- virtual OptBase &set_help(const std::string &, const std::string &);
+ virtual OptionImpl &set_help(const std::string &);
+ virtual OptionImpl &set_help(const std::string &, const std::string &);
+ virtual OptionImpl &bind_seen_count(unsigned &);
char get_short() const { return shrt; }
const std::string &get_long() const { return lng; }
ArgType get_arg_type() const { return arg_type; }
virtual unsigned get_seen_count() const { return seen_count; }
void process();
void process(const std::string &);
- protected:
- virtual void store() = 0;
- virtual void store(const std::string &) = 0;
};
template<typename T>
- class SimpleOption: public OptBase
+ class SimpleStore: public Store
{
private:
T &data;
public:
- SimpleOption(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d) { }
+ SimpleStore(T &d): data(d) { }
+
+ virtual SimpleStore *clone() const
+ { return new SimpleStore(data); }
virtual void store() { }
virtual void store(const std::string &a)
- {
- try
- {
- data = lexical_cast<T>(a);
- }
- catch(const lexical_error &e)
- {
- throw usage_error("Invalid argument for --"+lng+" ("+e.what()+")");
- }
- }
+ { data = lexical_cast<T>(a); }
};
template<typename T>
- class ListOption: public OptBase
+ class ListStore: public Store
{
private:
T &data;
public:
- ListOption(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d)
- { if(arg_type!=REQUIRED_ARG) throw std::invalid_argument("ListOption arg_type!=REQUIRED"); }
+ ListStore(T &d): data(d) { }
+
+ virtual ListStore *clone() const
+ { return new ListStore(data); }
virtual void store() { }
virtual void store(const std::string &a)
- {
- try
- {
- data.push_back(lexical_cast<typename T::value_type>(a));
- }
- catch(const lexical_error &e)
- {
- throw usage_error("Invalid argument for --"+lng+" ("+e.what()+")");
- }
- }
+ { data.push_back(lexical_cast<typename T::value_type>(a)); }
};
+ typedef std::list<OptionImpl *> OptionList;
+
bool help;
- std::list<OptBase *> opts;
+ OptionList opts;
std::vector<std::string> args;
public:
GetOpt();
~GetOpt();
+ /// Returns any non-option arguments encountered during processing.
const std::vector<std::string> &get_args() const { return args; }
+ /** Adds an option with both short and long forms. Processing depends on
+ the type of the destination variable and whether an argument is taken or
+ not. With an argument, the value is lexical_cast to appropriate type and
+ stored in the destination. Without an argument, a bool will be set to true
+ and an unsigned will be incremented; any other type will be ignored. */
template<typename T>
Option &add_option(char s, const std::string &l, T &d, ArgType a = NO_ARG)
- { return add_option(new SimpleOption<T>(s, l, d, a)); }
-
+ { return add_option(s, l, SimpleStore<T>(d), a); }
+
+ /** Adds an option with both short and long forms. The option may be
+ specified multiple times, and the argument from each occurrence is stored in
+ the list. The argument type must be REQUIRED_ARG. */
template<typename T>
Option &add_option(char s, const std::string &l, std::list<T> &d, ArgType a = REQUIRED_ARG)
- { return add_option(new ListOption<std::list<T> >(s, l, d, a)); }
-
+ { return add_option(s, l, ListStore<std::list<T> >(d), a); }
+
+ /** Adds an option with only a long form. */
template<typename T>
Option &add_option(const std::string &l, T &d, ArgType a)
{ return add_option(0, l, d, a); }
private:
- OptBase &add_option(OptBase *);
+ OptionImpl &add_option(char, const std::string &, const Store &, ArgType);
- OptBase &get_option(char);
- OptBase &get_option(const std::string &);
+ OptionImpl &get_option(char);
+ OptionImpl &get_option(const std::string &);
public:
/** Processes argc/argv style command line arguments. The contents of argv
std::string generate_help() const;
};
-template<> inline void GetOpt::SimpleOption<bool>::store()
+template<> inline void GetOpt::SimpleStore<bool>::store()
{ data = true; }
-template<> inline void GetOpt::SimpleOption<unsigned>::store()
+template<> inline void GetOpt::SimpleStore<unsigned>::store()
{ ++data; }
-template<> inline void GetOpt::SimpleOption<std::string>::store(const std::string &a)
+template<> inline void GetOpt::SimpleStore<std::string>::store(const std::string &a)
{ data = a; }
-template<> inline void GetOpt::ListOption<std::list<std::string> >::store(const std::string &a)
+template<> inline void GetOpt::ListStore<std::list<std::string> >::store(const std::string &a)
{ data.push_back(a); }
} // namespace Msp
projects / libs / core.git / blobdiff