HSAdmin Backend Domains, E-Mail, Datenbanken
Purodha
2013-02-20 4a7e12928010374d76e677c8ec3ea4f5e63e9487
commit | author | age
c64ab5 1 /***************************************************************************
CD 2  *   Copyright (C) 2005 by Christof Donat   *
3  *   cdonat@gmx.de   *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) any later version.                                   *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19  ***************************************************************************/
20
21
22 #include <vector>
23 #include <string>
24 #include <map>
25 #include <boost/shared_ptr.hpp>
26 #include <boost/scoped_ptr.hpp>
27
28 #include "abstractcmdlineparser.h"
29 #include "configfile.h"
30
31 //! here comes the commandline-Parser - with help of the abstractcommandlineparser.
32
33 namespace commandline {
34
35 #ifndef HSADMIN_CMDLINEPARSER
36 #define HSADMIN_CMDLINEPARSER
37
38 using std::vector;
39 using std::string;
40 using std::map;
41 using boost::shared_ptr;
42 using boost::scoped_ptr;
43
44 // Parameter Objects are the resultof each Parser step and used in second step.
45
46 //! parsed values of a --setall, --set, --input, --passinput or a --infile option
47 class setParameter {
48     public:
49     string m_property;
50     string m_value;
51
52     string toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile);
53 };
54
55 //! parsed values of a --only or a --where option
56 class whereParameter {
57     public:
58     string m_property;
59     string m_pattern;
60
61     string toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile);
62 };
63
64 //! parsed values of a --global-order or a --order option
65 class orderParameter {
66     public:
67     string m_property;
68     bool m_ascending;
69
70     string toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile);
71 };
72
73 //! a whole parsed --call Option which holds all the relevant other options
74 class callParameter {
75     public:
76     callParameter(): m_module(""), m_function(""), m_display(""), m_ignoreerror(false), m_force(false), m_globalOrderIndex(-1) { };
77     
78     string m_module;
79     string m_function;
80
81     string m_display;
82     vector<shared_ptr<setParameter> >   m_set;
83     vector<shared_ptr<whereParameter> > m_where;
84     vector<shared_ptr<orderParameter> > m_order;
85     vector<string> m_objects;
86     vector<string> m_unset;
87
88     bool   m_ignoreerror;
89     bool   m_force;
90     int    m_globalOrderIndex;
91
92     vector<string> parseDisplayspec();
93     string evalDisplay(const map<string, string> &values);
94     string toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile);
95 };
96
97 enum parseError { NOERROR = 0, NeedCall = 1 };
98
99 //! all the parsed values
100 class parsedParameters {
101     public:
102     parsedParameters();
103     parseError m_error;
104     string m_user;
105     string m_ticket;
106     string m_defaultDisplay;
107     string m_addConfigFile;
108     bool m_test;
109     bool m_ignoreerrors;
110     vector<shared_ptr<whereParameter> > m_only;
111     vector<shared_ptr<setParameter> >   m_setall;
112     vector<shared_ptr<orderParameter> > m_globalOrder;
113     vector<shared_ptr<callParameter> >  m_call;
114     vector<string> m_unsetall;
115
116     string toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile);
117 };
118
119 // Option classes are used in first Parse step
120
121 //! --test
122 class TestOption: public abstractcommandlineparser::CmdLineOption<true,true,false,parsedParameters> {
123     public:
124     TestOption();
125     protected:
126     virtual bool handle(shared_ptr<parsedParameters> result);
127 };
128
129 //! --ignoreerror
130 class IgnoreErrorOption: public abstractcommandlineparser::CmdLineOption<true,true,false,parsedParameters> {
131     public:
132     IgnoreErrorOption();
133     protected:
134     virtual bool handle(shared_ptr<parsedParameters> result);
135 };
136
137 //! --ignoreerrors
138 class IgnoreErrorsOption: public IgnoreErrorOption {
139     public:
140     IgnoreErrorsOption();
141     protected:
142     virtual bool handle(shared_ptr<parsedParameters> result);
143 };
144
145 //! --verbosity
146 class VerbosityOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
147     public:
148     VerbosityOption();
149     bool parseThis(vector<string>& options, shared_ptr<parsedParameters> result);
150     protected:
151     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
152 };
153
154 //! --quiet
155 class QuietOption: public abstractcommandlineparser::CmdLineOption<true,true,false,parsedParameters> {
156     public:
157     QuietOption();
158     protected:
159     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
160 };
161
162 //! --runas
163 class RunAsOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
164     public:
165     RunAsOption();
166     protected:
167     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
168 };
169
170 //! --ticket
171 class TicketOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
172     public:
173     TicketOption();
174     protected:
175     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
176 };
177
178 //! --config
179 class ConfigOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
180     public:
181     ConfigOption();
182     protected:
183     virtual bool handle(string & parameter, shared_ptr<parsedParameters> result);
184 };
185
186 //! --force
187 class ForceOption: public abstractcommandlineparser::CmdLineOption<true,false,false,parsedParameters> {
188     public:
189     ForceOption();
190     protected:
191     virtual bool handle(shared_ptr<parsedParameters> result);
192 };
193
194 //! --globals
195 class GlobalsOption: public abstractcommandlineparser::CmdLineOption<true,true,false,parsedParameters> {
196     public:
197     GlobalsOption();
198     protected:
199     virtual bool handle(shared_ptr<parsedParameters> result);
200 };
201
202 //! --where
203 class WhereOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
204     public:
205     WhereOption();
206     protected:
207     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
208 };
209
210 //! --only
211 class OnlyOption: public WhereOption {
212     public:
213     OnlyOption();
214     protected:
215     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
216 };
217
218 //! --set
219 class SetOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
220     public:
221     SetOption();
222     protected:
223     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
224 };
225
226 //! --setall
227 class SetAllOption: public SetOption {
228     public:
229     SetAllOption();
230     protected:
231     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
232 };
233
234 //! --infile
235 class InfileOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
236     public:
237     InfileOption();
238     protected:
239     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
240 };
241
242 //! --order
243 class OrderOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
244     public:
245     OrderOption();
246     protected:
247     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
248 };
249
250 //! --global-order
251 class GlobalOrderOption: public OrderOption {
252     public:
253     GlobalOrderOption();
254     protected:
255     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
256 };
257
258 //! --input
259 class InputOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
260     public:
261     InputOption();
262     protected:
263     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
264 };
265
266 //! --passinput
267 class PassInputOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
268     public:
269     PassInputOption();
270     protected:
271     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
272 };
273
274 //! --display
275 class DisplayOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
276     public:
277     DisplayOption();
278     protected:
279     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
280 };
281
282 //! --default-display
283 class DefaultDisplayOption: public DisplayOption {
284     public:
285     DefaultDisplayOption();
286     protected:
287     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
288 };
289
290 //! --call
291 class CallOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
292     public:
293     CallOption();
294     protected:
295     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
296 };
297
298 //! --unset
299 class UnsetOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
300     public:
301     UnsetOption();
302     protected:
303     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
304 };
305
306 //! --unsetall
307 class UnsetAllOption: public abstractcommandlineparser::CmdLineOption<true,true,true,parsedParameters> {
308     public:
309     UnsetAllOption();
310     protected:
311     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
312 };
313
314 //! all other parameters are objectIDs.
315 class ObjectID: public abstractcommandlineparser::CmdLineOption<false,false,true,parsedParameters> {
316     public:
317     ObjectID();
318     protected:
319     virtual bool handle(string &parameter, shared_ptr<parsedParameters> result);
320 };
321
322 //! putting it all together in a typelist
323 typedef Parameterlist24(
324     TestOption, 
325     IgnoreErrorsOption, 
326     VerbosityOption, 
327     RunAsOption, 
328     TicketOption,
329     ConfigOption,
330     SetAllOption, 
331     UnsetAllOption,
332     OnlyOption, 
333     GlobalOrderOption, 
334     DefaultDisplayOption, 
335     IgnoreErrorOption, 
336     ForceOption, 
337     GlobalsOption, 
338     WhereOption, 
339     SetOption, 
340     InfileOption, 
341     OrderOption, 
342     InputOption, 
343     PassInputOption, 
344     UnsetOption, 
345     DisplayOption, 
346     ObjectID, 
347     CallOption ) allParameters;
348
349 //! generating a class with parse()-function from the list of Options
350 typedef abstractcommandlineparser::CmdLineOptionList<allParameters, parsedParameters> Parameters;
351
352 #else
353 class parsedParameters;
354 class setParameter;
355 class whereParameter;
356 class orderParameter;
357 class callParameter;
358 class TestOption;
359 class IgnoreErrorOption;
360 class IgnoreErrorsOption;
361 class VerbosityOption;
362 class RunAsOption;
363 class TicketOption;
364 class ConfigOption;
365 class SetAllOption;
366 class OnlyOption;
367 class UnsetAllOption;
368 class GlobalOrderOption;
369 class DefaultDisplayOption;
370 class ForceOption;
371 class GlobalsOption;
372 class WhereOption;
373 class SetOption;
374 class InfileOption;
375 class OrderOption;
376 class InputOption;
377 class PassInputOption;
378 class DisplayOption;
379 class unsetOption;
380 class CallOption;
381 class ObjectID;
382
383 #endif /* HSADMIN_CMDLINEPARSER */
384
385 };
386