source/core/getopt.h

   1 /* $Id$
   2
   3 This file is part of libmspcore
   4 Copyright © 2006-2009, 2011 Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7
   8 #ifndef MSP_CORE_GETOPT_H_
   9 #define MSP_CORE_GETOPT_H_
  10
  11 #include <list>
  12 #include <sstream>
  13 #include <stdexcept>
  14 #include <string>
  15 #include <vector>
  16
  17 namespace Msp {
  18
  19 class usage_error: public std::runtime_error
  20 {
  21 private:
  22         std::string help_;
  23
  24 public:
  25         usage_error(const std::string &w, const std::string &h = std::string()): std::runtime_error(w), help_(h) { }
  26         ~usage_error() throw() { }
  27
  28         const char *help() const throw() { return help_.c_str(); }
  29 };
  30
  31
  32 class GetOpt
  33 {
  34 public:
  35         enum ArgType
  36         {
  37                 NO_ARG,
  38                 OPTIONAL_ARG,
  39                 REQUIRED_ARG
  40         };
  41
  42         class OptBase
  43         {
  44         protected:
  45                 char shrt;
  46                 std::string lng;
  47                 ArgType arg_type;
  48                 unsigned seen_count;
  49                 std::string help;
  50                 std::string metavar;
  51
  52                 OptBase(char, const std::string &, ArgType);
  53         public:
  54                 virtual ~OptBase() { }
  55
  56                 OptBase &set_help(const std::string &);
  57                 OptBase &set_help(const std::string &, const std::string &);
  58                 char get_short() const { return shrt; }
  59                 const std::string &get_long() const { return lng; }
  60                 ArgType get_arg_type() const { return arg_type; }
  61                 const std::string &get_help() const { return help; }
  62                 const std::string &get_metavar() const { return metavar; }
  63                 unsigned get_seen_count() const { return seen_count; }
  64                 void process();
  65                 void process(const std::string &);
  66         protected:
  67                 virtual void store() = 0;
  68                 virtual void store(const std::string &) = 0;
  69         };
  70
  71 private:
  72         template<typename T>
  73         class Option: public OptBase
  74         {
  75         public:
  76                 Option(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d) { }
  77
  78                 virtual void store() { }
  79
  80                 virtual void store(const std::string &a)
  81                 {
  82                         T tmp;
  83                         std::istringstream ss(a);
  84                         ss>>tmp;
  85                         if(ss.fail())
  86                                 throw usage_error("Invalid argument for --"+lng);
  87
  88                         data = tmp;
  89                 }
  90         private:
  91                 T &data;
  92         };
  93
  94         template<typename T>
  95         class ListOption: public OptBase
  96         {
  97         public:
  98                 ListOption(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d)
  99                 { if(arg_type!=REQUIRED_ARG) throw std::invalid_argument("ListOption arg_type!=REQUIRED"); }
 100
 101                 virtual void store() { }
 102
 103                 virtual void store(const std::string &a)
 104                 {
 105                         typename T::value_type tmp;
 106                         std::istringstream ss(a);
 107                         ss>>tmp;
 108                         if(ss.fail())
 109                                 throw usage_error("Invalid argument for --"+lng);
 110
 111                         data.push_back(tmp);
 112                 }
 113         private:
 114                 T &data;
 115         };
 116
 117         bool help;
 118         std::list<OptBase *> opts;
 119         std::vector<std::string> args;
 120
 121 public:
 122         GetOpt();
 123         ~GetOpt();
 124
 125         const std::vector<std::string> &get_args() const { return args; }
 126
 127         template<typename T>
 128         OptBase &add_option(char s, const std::string &l, T &d, ArgType a = NO_ARG)
 129         { opts.push_back(new Option<T>(s, l, d, a)); return *opts.back(); }
 130
 131         template<typename T>
 132         OptBase &add_option(char s, const std::string &l, std::list<T> &d, ArgType a = REQUIRED_ARG)
 133         { opts.push_back(new ListOption<std::list<T> >(s, l, d, a)); return *opts.back(); }
 134
 135         template<typename T>
 136         OptBase &add_option(const std::string &l, T &d, ArgType a)
 137         { return add_option(0, l, d, a); }
 138
 139 private:
 140         OptBase &get_option(char);
 141         OptBase &get_option(const std::string &);
 142
 143 public:
 144         /** Processes argc/argv style command line arguments.  The contents of argv
 145         will be unchanged; use get_args to access non-option arguments. */
 146         void operator()(unsigned, const char *const *);
 147
 148 private:
 149         /** Processes a long option.  Returns the number of arguments eaten. */
 150         unsigned process_long(const char *const *);
 151
 152         /** Processes short options.  Returns the number of arguments eaten. */
 153         unsigned process_short(const char *const *);
 154
 155 public:
 156         /** Generates a single line that describes known options. */
 157         std::string generate_usage(const std::string &) const;
 158
 159         /** Generates help for known options in tabular format, one option per
 160         line.  The returned string will have a linefeed at the end. */
 161         std::string generate_help() const;
 162 };
 163
 164 template<> inline void GetOpt::Option<bool>::store()     { data = true; }
 165 template<> inline void GetOpt::Option<unsigned>::store() { ++data; }
 166
 167 template<> inline void GetOpt::Option<std::string>::store(const std::string &a)
 168 { data = a; }
 169
 170 template<> inline void GetOpt::ListOption<std::list<std::string> >::store(const std::string &a)
 171 { data.push_back(a); }
 172
 173 } // namespace Msp
 174
 175 #endif