Replace earlier options sharing the same short or long name
[libs/core.git] / 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 class GetOpt
26 {
27 public:
28         enum ArgType
29         {
30                 NO_ARG,
31                 OPTIONAL_ARG,
32                 REQUIRED_ARG
33         };
34         
35         class OptBase
36         {
37         protected:
38                 char shrt;
39                 std::string lng;
40                 ArgType arg_type;
41                 unsigned seen_count;
42                 std::string help;
43                 std::string metavar;
44
45                 OptBase(char, const std::string &, ArgType);
46         public:
47                 virtual ~OptBase() { }
48
49                 OptBase &set_help(const std::string &);
50                 OptBase &set_help(const std::string &, const std::string &);
51                 char get_short() const { return shrt; }
52                 const std::string &get_long() const { return lng; }
53                 ArgType get_arg_type() const { return arg_type; }
54                 const std::string &get_help() const { return help; }
55                 const std::string &get_metavar() const { return metavar; }
56                 unsigned get_seen_count() const { return seen_count; }
57                 void process();
58                 void process(const std::string &);
59         protected:
60                 virtual void store() = 0;
61                 virtual void store(const std::string &) = 0;
62         };
63
64 private:
65         template<typename T>
66         class Option: public OptBase
67         {
68         private:
69                 T &data;
70
71         public:
72                 Option(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d) { }
73
74                 virtual void store() { }
75
76                 virtual void store(const std::string &a)
77                 {
78                         try
79                         {
80                                 data = lexical_cast<T>(a);
81                         }
82                         catch(const lexical_error &e)
83                         {
84                                 throw usage_error("Invalid argument for --"+lng+" ("+e.what()+")");
85                         }
86                 }
87         };
88
89         template<typename T>
90         class ListOption: public OptBase
91         {
92         private:
93                 T &data;
94
95         public:
96                 ListOption(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d)
97                 { if(arg_type!=REQUIRED_ARG) throw std::invalid_argument("ListOption arg_type!=REQUIRED"); }
98
99                 virtual void store() { }
100
101                 virtual void store(const std::string &a)
102                 {
103                         try
104                         {
105                                 data.push_back(lexical_cast<typename T::value_type>(a));
106                         }
107                         catch(const lexical_error &e)
108                         {
109                                 throw usage_error("Invalid argument for --"+lng+" ("+e.what()+")");
110                         }
111                 }
112         };
113
114         bool help;
115         std::list<OptBase *> opts;
116         std::vector<std::string> args;
117
118 public:
119         GetOpt();
120         ~GetOpt();
121
122         const std::vector<std::string> &get_args() const { return args; }
123
124         template<typename T>
125         OptBase &add_option(char s, const std::string &l, T &d, ArgType a = NO_ARG)
126         { return add_option(new Option<T>(s, l, d, a)); }
127         
128         template<typename T>
129         OptBase &add_option(char s, const std::string &l, std::list<T> &d, ArgType a = REQUIRED_ARG)
130         { return add_option(new ListOption<std::list<T> >(s, l, d, a)); }
131         
132         template<typename T>
133         OptBase &add_option(const std::string &l, T &d, ArgType a)
134         { return add_option(0, l, d, a); }
135
136 private:
137         OptBase &add_option(OptBase *);
138
139         OptBase &get_option(char);
140         OptBase &get_option(const std::string &);
141
142 public:
143         /** Processes argc/argv style command line arguments.  The contents of argv
144         will be unchanged; use get_args to access non-option arguments. */
145         void operator()(unsigned, const char *const *);
146
147 private:
148         /** Processes a long option.  Returns the number of arguments eaten. */
149         unsigned process_long(const char *const *);
150
151         /** Processes short options.  Returns the number of arguments eaten. */
152         unsigned process_short(const char *const *);
153
154 public:
155         /** Generates a single line that describes known options. */
156         std::string generate_usage(const std::string &) const;
157
158         /** Generates help for known options in tabular format, one option per
159         line.  The returned string will have a linefeed at the end. */
160         std::string generate_help() const;
161 };
162
163 template<> inline void GetOpt::Option<bool>::store()
164 { data = true; }
165
166 template<> inline void GetOpt::Option<unsigned>::store()
167 { ++data; }
168
169 template<> inline void GetOpt::Option<std::string>::store(const std::string &a)
170 { data = a; }
171
172 template<> inline void GetOpt::ListOption<std::list<std::string> >::store(const std::string &a)
173 { data.push_back(a); }
174
175 } // namespace Msp
176
177 #endif