]> git.stg.codes - stg.git/blob - projects/sgconf/actions.h
886e17e2568619da73bcdaf31873c0698c93853a
[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 namespace SGCONF
34 {
35
36 typedef void (* FUNC0)();
37
38 template <typename F>
39 class FUNC0_ACTION : public ACTION
40 {
41     public:
42         FUNC0_ACTION(const F & func) : m_func(func) {}
43
44         virtual ACTION * Clone() const { return new FUNC0_ACTION<F>(*this); }
45
46         virtual std::string ParamDescription() const { return ""; }
47         virtual std::string DefaultDescription() const { return ""; }
48         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
49         virtual PARSER_STATE Parse(int argc, char ** argv)
50         {
51         m_func();
52         return PARSER_STATE(true, argc, argv);
53         }
54
55     private:
56         F m_func;
57         OPTION_BLOCK m_suboptions;
58 };
59
60 template <typename F>
61 inline
62 FUNC0_ACTION<F> * MakeFunc0Action(F func)
63 {
64 return new FUNC0_ACTION<F>(func);
65 }
66
67 template <typename T>
68 class PARAM_ACTION : public ACTION
69 {
70     public:
71         PARAM_ACTION(RESETABLE<T> & param,
72                      const T & defaultValue,
73                      const std::string & paramDescription)
74             : m_param(param),
75               m_defaltValue(defaultValue),
76               m_description(paramDescription),
77               m_hasDefault(true)
78         {}
79         PARAM_ACTION(RESETABLE<T> & param,
80                      const std::string & paramDescription)
81             : m_param(param),
82               m_description(paramDescription),
83               m_hasDefault(false)
84         {}
85
86         virtual ACTION * Clone() const { return new PARAM_ACTION<T>(*this); }
87
88         virtual std::string ParamDescription() const { return m_description; }
89         virtual std::string DefaultDescription() const;
90         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
91         virtual PARSER_STATE Parse(int argc, char ** argv);
92
93     private:
94         RESETABLE<T> & m_param;
95         T m_defaltValue;
96         std::string m_description;
97         bool m_hasDefault;
98         OPTION_BLOCK m_suboptions;
99 };
100
101 template <typename T>
102 inline
103 std::string PARAM_ACTION<T>::DefaultDescription() const
104 {
105 return m_hasDefault ? " (default: '" + x2str(m_defaltValue) + "')"
106                     : "";
107 }
108
109 template <>
110 inline
111 std::string PARAM_ACTION<std::string>::DefaultDescription() const
112 {
113 return m_hasDefault ? " (default: '" + m_defaltValue + "')"
114                     : "";
115 }
116
117 template <typename T>
118 inline
119 PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv)
120 {
121 T value;
122 if (str2x(*argv, value))
123     throw ERROR(std::string("Bad argument: '") + *argv + "'");
124 m_param = value;
125 return PARSER_STATE(false, --argc, ++argv);
126 }
127
128 template <>
129 inline
130 PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv)
131 {
132 m_param = *argv;
133 return PARSER_STATE(false, --argc, ++argv);
134 }
135
136 template <typename T>
137 inline
138 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
139                                   const T & defaultValue,
140                                   const std::string & paramDescription)
141 {
142 return new PARAM_ACTION<T>(param, defaultValue, paramDescription);
143 }
144
145 template <typename T>
146 inline
147 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
148                                   const std::string & paramDescription)
149 {
150 return new PARAM_ACTION<T>(param, paramDescription);
151 }
152
153 } // namespace SGCONF
154
155 #endif