]> git.stg.codes - stg.git/blob - projects/sgconf/actions.h
Fixed Split.
[stg.git] / projects / sgconf / actions.h
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
19  */
20
21 #ifndef __STG_SGCONF_ACTIONS_H__
22 #define __STG_SGCONF_ACTIONS_H__
23
24 #include "action.h"
25 #include "options.h"
26 #include "parser_state.h"
27
28 #include "stg/common.h"
29 #include "stg/resetable.h"
30
31 #include <string>
32
33 #include <cassert>
34
35 namespace SGCONF
36 {
37
38 typedef void (* FUNC0)();
39
40 template <typename F>
41 class FUNC0_ACTION : public ACTION
42 {
43     public:
44         FUNC0_ACTION(const F & func) : m_func(func) {}
45
46         virtual ACTION * Clone() const { return new FUNC0_ACTION<F>(*this); }
47
48         virtual std::string ParamDescription() const { return ""; }
49         virtual std::string DefaultDescription() const { return ""; }
50         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
51         virtual PARSER_STATE Parse(int argc, char ** argv, void * /*data*/)
52         {
53         m_func();
54         return PARSER_STATE(true, argc, argv);
55         }
56
57     private:
58         F m_func;
59         OPTION_BLOCK m_suboptions;
60 };
61
62 template <typename F>
63 inline
64 FUNC0_ACTION<F> * MakeFunc0Action(F func)
65 {
66 return new FUNC0_ACTION<F>(func);
67 }
68
69 template <typename T>
70 class PARAM_ACTION : public ACTION
71 {
72     public:
73         PARAM_ACTION(RESETABLE<T> & param,
74                      const T & defaultValue,
75                      const std::string & paramDescription)
76             : m_param(param),
77               m_defaltValue(defaultValue),
78               m_description(paramDescription),
79               m_hasDefault(true)
80         {}
81         PARAM_ACTION(RESETABLE<T> & param,
82                      const std::string & paramDescription)
83             : m_param(param),
84               m_description(paramDescription),
85               m_hasDefault(false)
86         {}
87
88         virtual ACTION * Clone() const { return new PARAM_ACTION<T>(*this); }
89
90         virtual std::string ParamDescription() const { return m_description; }
91         virtual std::string DefaultDescription() const;
92         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
93         virtual PARSER_STATE Parse(int argc, char ** argv, void * /*data*/);
94         virtual void ParseValue(const std::string & value);
95
96     private:
97         RESETABLE<T> & m_param;
98         T m_defaltValue;
99         std::string m_description;
100         bool m_hasDefault;
101         OPTION_BLOCK m_suboptions;
102 };
103
104 template <typename T>
105 inline
106 std::string PARAM_ACTION<T>::DefaultDescription() const
107 {
108 return m_hasDefault ? " (default: '" + x2str(m_defaltValue) + "')"
109                     : "";
110 }
111
112 template <>
113 inline
114 std::string PARAM_ACTION<std::string>::DefaultDescription() const
115 {
116 return m_hasDefault ? " (default: '" + m_defaltValue + "')"
117                     : "";
118 }
119
120 template <typename T>
121 inline
122 PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv, void * /*data*/)
123 {
124 if (argc == 0 ||
125     argv == NULL ||
126     *argv == NULL)
127     throw ERROR("Missing argument.");
128 T value;
129 if (str2x(*argv, value))
130     throw ERROR(std::string("Bad argument: '") + *argv + "'");
131 m_param = value;
132 return PARSER_STATE(false, --argc, ++argv);
133 }
134
135 template <typename T>
136 inline
137 void PARAM_ACTION<T>::ParseValue(const std::string & stringValue)
138 {
139 if (stringValue.empty())
140     throw ERROR("Missing value.");
141 T value;
142 if (str2x(stringValue, value))
143     throw ERROR(std::string("Bad value: '") + stringValue + "'");
144 m_param = value;
145 }
146
147 template <>
148 inline
149 void PARAM_ACTION<std::string>::ParseValue(const std::string & stringValue)
150 {
151 m_param = stringValue;
152 }
153
154 template <>
155 inline
156 PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv, void * /*data*/)
157 {
158 if (argc == 0 ||
159     argv == NULL ||
160     *argv == NULL)
161     throw ERROR("Missing argument.");
162 m_param = *argv;
163 return PARSER_STATE(false, --argc, ++argv);
164 }
165
166 template <typename T>
167 inline
168 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
169                                   const T & defaultValue,
170                                   const std::string & paramDescription)
171 {
172 return new PARAM_ACTION<T>(param, defaultValue, paramDescription);
173 }
174
175 template <typename T>
176 inline
177 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
178                                   const std::string & paramDescription)
179 {
180 return new PARAM_ACTION<T>(param, paramDescription);
181 }
182
183 class KV_ACTION : public ACTION
184 {
185     public:
186         KV_ACTION(const std::string & name,
187                   const std::string & paramDescription)
188             : m_name(name),
189               m_description(paramDescription)
190         {}
191
192         virtual ACTION * Clone() const { return new KV_ACTION(*this); }
193
194         virtual std::string ParamDescription() const { return m_description; }
195         virtual std::string DefaultDescription() const { return ""; }
196         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
197         virtual PARSER_STATE Parse(int argc, char ** argv, void * data);
198
199     private:
200         std::string m_name;
201         std::string m_description;
202         OPTION_BLOCK m_suboptions;
203 };
204
205 inline
206 PARSER_STATE KV_ACTION::Parse(int argc, char ** argv, void * data)
207 {
208 if (argc == 0 ||
209     argv == NULL ||
210     *argv == NULL)
211     throw ERROR("Missing argument.");
212 assert(data != NULL && "Expecting container pointer.");
213 std::map<std::string, std::string> & kvs = *static_cast<std::map<std::string, std::string>*>(data);
214 kvs[m_name] = *argv;
215 return PARSER_STATE(false, --argc, ++argv);
216 }
217
218 inline
219 KV_ACTION * MakeKVAction(const std::string & name,
220                          const std::string & paramDescription)
221 {
222 return new KV_ACTION(name, paramDescription);
223 }
224
225 } // namespace SGCONF
226
227 #endif