source/core/getopt.h

   1 #ifndef MSP_CORE_GETOPT_H_
   2 #define MSP_CORE_GETOPT_H_
   3
   4 #include <list>
   5 #include <stdexcept>
   6 #include <string>
   7 #include <vector>
   8 #include <msp/strings/lexicalcast.h>
   9
  10 namespace Msp {
  11
  12 class usage_error: public std::runtime_error
  13 {
  14 private:
  15         std::string help_;
  16
  17 public:
  18         usage_error(const std::string &w, const std::string &h = std::string()): std::runtime_error(w), help_(h) { }
  19         ~usage_error() throw() { }
  20
  21         const char *help() const throw() { return help_.c_str(); }
  22 };
  23
  24
  25 /**
  26 Command line option processor.  Both short and long options are supported, with
  27 optional and required arguments.  Automatic help text generation is also
  28 available.
  29
  30 Short options begin with a single dash and are identified by a single letter.
  31 Multiple short options may be grouped if they take no arguments; for example,
  32 the string "-abc" could be interpreted as having the options 'a', 'b' and 'c'.
  33 If the option takes an argument and there are unused characters in the argv
  34 element, then those characters are interpreted as the argument.  Otherwise the
  35 next element is taken as the argument.  An optional argument must be given in
  36 the same element.
  37
  38 Long options begin with a double dash and are identified by an arbitrary
  39 string.  An argument can be specified either in the same argv element,
  40 separated by an equals sign, or in the next element.  As with short options,
  41 an optional argument must be in the same element.
  42
  43 A single option may have both alternative forms, but must always have at least
  44 a long form.  This is to encourage self-documenting options; it's much easier
  45 to remember words than letters.
  46
  47 A built-in --help option is provided and will output a list of options and
  48 their associated help texts.  An application may override this by providing
  49 its own option with the same name.
  50 */
  51 class GetOpt
  52 {
  53 public:
  54         enum ArgType
  55         {
  56                 NO_ARG,
  57                 OPTIONAL_ARG,
  58                 REQUIRED_ARG
  59         };
  60
  61         class Option
  62         {
  63         protected:
  64                 Option() { }
  65         public:
  66                 virtual ~Option() { }
  67
  68                 /// Sets help text for the option.
  69                 virtual Option &set_help(const std::string &) = 0;
  70
  71                 /** Sets help text for the option, with a placeholder metavariable.  The
  72                 metavariable is used to denote the argument in the option list. */
  73                 virtual Option &set_help(const std::string &, const std::string &) = 0;
  74
  75                 virtual Option &bind_seen_count(unsigned &) = 0;
  76
  77                 /// Returns the number of times this option was seen on the command line.
  78                 virtual unsigned get_seen_count() const = 0;
  79         };
  80
  81 private:
  82         class Store
  83         {
  84         protected:
  85                 Store() { }
  86         public:
  87                 virtual ~Store() { }
  88
  89                 virtual Store *clone() const = 0;
  90
  91                 virtual void store() = 0;
  92                 virtual void store(const std::string &) = 0;
  93         };
  94
  95         class OptionImpl: public Option
  96         {
  97         protected:
  98                 char shrt;
  99                 std::string lng;
 100                 ArgType arg_type;
 101                 unsigned seen_count;
 102                 unsigned *ext_seen_count;
 103                 std::string help;
 104                 std::string metavar;
 105                 Store *store;
 106
 107         public:
 108                 OptionImpl(char, const std::string &, const Store &, ArgType);
 109                 virtual ~OptionImpl();
 110
 111                 virtual OptionImpl &set_help(const std::string &);
 112                 virtual OptionImpl &set_help(const std::string &, const std::string &);
 113                 virtual OptionImpl &bind_seen_count(unsigned &);
 114                 char get_short() const { return shrt; }
 115                 const std::string &get_long() const { return lng; }
 116                 ArgType get_arg_type() const { return arg_type; }
 117                 const std::string &get_help() const { return help; }
 118                 const std::string &get_metavar() const { return metavar; }
 119                 virtual unsigned get_seen_count() const { return seen_count; }
 120                 void process();
 121                 void process(const std::string &);
 122         };
 123
 124         template<typename T>
 125         class SimpleStore: public Store
 126         {
 127         private:
 128                 T &data;
 129
 130         public:
 131                 SimpleStore(T &d): data(d) { }
 132
 133                 virtual SimpleStore *clone() const
 134                 { return new SimpleStore(data); }
 135
 136                 virtual void store() { }
 137
 138                 virtual void store(const std::string &a)
 139                 { data = lexical_cast<T>(a); }
 140         };
 141
 142         template<typename T>
 143         class ListStore: public Store
 144         {
 145         private:
 146                 T &data;
 147
 148         public:
 149                 ListStore(T &d): data(d) { }
 150
 151                 virtual ListStore *clone() const
 152                 { return new ListStore(data); }
 153
 154                 virtual void store() { }
 155
 156                 virtual void store(const std::string &a)
 157                 { data.push_back(lexical_cast<typename T::value_type>(a)); }
 158         };
 159
 160         typedef std::list<OptionImpl *> OptionList;
 161
 162         bool help;
 163         OptionList opts;
 164         std::vector<std::string> args;
 165
 166 public:
 167         GetOpt();
 168         ~GetOpt();
 169
 170         /// Returns any non-option arguments encountered during processing.
 171         const std::vector<std::string> &get_args() const { return args; }
 172
 173         /** Adds an option with both short and long forms.  Processing depends on
 174         the type of the destination variable and whether an argument is taken or
 175         not.  With an argument, the value is lexical_cast to appropriate type and
 176         stored in the destination.  Without an argument, a bool will be set to true
 177         and an unsigned will be incremented; any other type will be ignored. */
 178         template<typename T>
 179         Option &add_option(char s, const std::string &l, T &d, ArgType a = NO_ARG)
 180         { return add_option(s, l, SimpleStore<T>(d), a); }
 181
 182         /** Adds an option with both short and long forms.  The option may be
 183         specified multiple times, and the argument from each occurrence is stored in
 184         the list.  The argument type must be REQUIRED_ARG. */
 185         template<typename T>
 186         Option &add_option(char s, const std::string &l, std::list<T> &d, ArgType a = REQUIRED_ARG)
 187         { return add_option(s, l, ListStore<std::list<T> >(d), a); }
 188
 189         /** Adds an option with only a long form. */
 190         template<typename T>
 191         Option &add_option(const std::string &l, T &d, ArgType a)
 192         { return add_option(0, l, d, a); }
 193
 194 private:
 195         OptionImpl &add_option(char, const std::string &, const Store &, ArgType);
 196
 197         OptionImpl &get_option(char);
 198         OptionImpl &get_option(const std::string &);
 199
 200 public:
 201         /** Processes argc/argv style command line arguments.  The contents of argv
 202         will be unchanged; use get_args to access non-option arguments. */
 203         void operator()(unsigned, const char *const *);
 204
 205 private:
 206         /** Processes a long option.  Returns the number of arguments eaten. */
 207         unsigned process_long(const char *const *);
 208
 209         /** Processes short options.  Returns the number of arguments eaten. */
 210         unsigned process_short(const char *const *);
 211
 212 public:
 213         /** Generates a single line that describes known options. */
 214         std::string generate_usage(const std::string &) const;
 215
 216         /** Generates help for known options in tabular format, one option per
 217         line.  The returned string will have a linefeed at the end. */
 218         std::string generate_help() const;
 219 };
 220
 221 template<> inline void GetOpt::SimpleStore<bool>::store()
 222 { data = true; }
 223
 224 template<> inline void GetOpt::SimpleStore<unsigned>::store()
 225 { ++data; }
 226
 227 template<> inline void GetOpt::SimpleStore<std::string>::store(const std::string &a)
 228 { data = a; }
 229
 230 template<> inline void GetOpt::ListStore<std::list<std::string> >::store(const std::string &a)
 231 { data.push_back(a); }
 232
 233 } // namespace Msp
 234
 235 #endif