1
1
#include " wsjcpp_arguments.h"
2
2
#include < wsjcpp_core.h>
3
3
4
+ WSJCppArgumentSingle::WSJCppArgumentSingle (const std::string &sName , const std::string &sDescription ) {
5
+ TAG = " WSJCppArgumentSingle-" + sName ;
6
+ m_sName = sName ;
7
+ m_sDescription = sDescription ;
8
+ }
9
+
4
10
// ---------------------------------------------------------------------
5
11
6
- WSJCppArgumentProcessor::WSJCppArgumentProcessor (const std::string &sName , const std::string &sDescription ) {
7
- TAG = " WSJCppArgumentProcessor-" + sName ;
12
+ std::string WSJCppArgumentSingle::getName () {
13
+ return m_sName;
14
+ }
15
+
16
+ // ---------------------------------------------------------------------
17
+
18
+ std::string WSJCppArgumentSingle::getDescription () {
19
+ return m_sDescription;
20
+ }
21
+
22
+ // ---------------------------------------------------------------------
23
+
24
+ std::string WSJCppArgumentSingle::help (const std::string &sProgramName , const std::string &sPrefix ) {
25
+ return sPrefix + " [" + m_sName + " ] - " + m_sDescription;
26
+ }
27
+
28
+ // ---------------------------------------------------------------------
29
+
30
+ WSJCppArgumentParameter::WSJCppArgumentParameter (const std::string &sName , const std::string &sDescription ) {
31
+ TAG = " WSJCppArgumentParameter-" + sName ;
8
32
m_sName = sName ;
9
33
m_sDescription = sDescription ;
10
34
}
11
35
12
36
// ---------------------------------------------------------------------
13
37
14
- std::string WSJCppArgumentProcessor ::getName () {
38
+ std::string WSJCppArgumentParameter ::getName () {
15
39
return m_sName;
16
40
}
17
41
18
42
// ---------------------------------------------------------------------
19
43
20
- std::string WSJCppArgumentProcessor ::getDescription () {
44
+ std::string WSJCppArgumentParameter ::getDescription () {
21
45
return m_sDescription;
22
46
}
23
47
24
48
// ---------------------------------------------------------------------
25
49
26
- int WSJCppArgumentProcessor::handle (const std::string &sProgramName , const std::vector<std::string> &vSubParams) {
50
+ std::string WSJCppArgumentParameter::getValue () {
51
+ return m_sValue;
52
+ }
27
53
28
- return -1 ;
54
+ // ---------------------------------------------------------------------
55
+
56
+ void WSJCppArgumentParameter::setValue (const std::string &sValue ) {
57
+ m_sValue = sValue ;
29
58
}
30
59
31
60
// ---------------------------------------------------------------------
32
61
33
- bool WSJCppArgumentProcessor::canHandle (const std::vector<std::string> &vSubParams) {
34
- return false ;
62
+ std::string WSJCppArgumentParameter::help (const std::string &sProgramName , const std::string &sPrefix ) {
63
+ return sPrefix + " [" + m_sName + " <val>] - " + m_sDescription;
64
+ }
65
+
66
+ // ---------------------------------------------------------------------
67
+
68
+ WSJCppArgumentProcessor::WSJCppArgumentProcessor (const std::string &sName , const std::string &sDescription ) {
69
+ TAG = " WSJCppArgumentProcessor-" + sName ;
70
+ m_sName = sName ;
71
+ m_sDescription = sDescription ;
72
+ }
73
+
74
+ // ---------------------------------------------------------------------
75
+
76
+ std::string WSJCppArgumentProcessor::getName () {
77
+ return m_sName;
78
+ }
79
+
80
+ // ---------------------------------------------------------------------
81
+
82
+ std::string WSJCppArgumentProcessor::getDescription () {
83
+ return m_sDescription;
35
84
}
36
85
37
86
// ---------------------------------------------------------------------
38
87
39
88
void WSJCppArgumentProcessor::registryProcessor (WSJCppArgumentProcessor *p) {
40
- for (int i = 0 ; i < m_vProcessors.size (); i++) {
41
- if (m_vProcessors[i]->getName () == p->getName ()) {
42
- WSJCppLog::throw_err (TAG, " Processor '" + p->getName () + " ' already registered" );
43
- }
89
+ if (hasRegisteredArgumentName (p->getName ())) {
90
+ WSJCppLog::throw_err (TAG, " Argument Name '" + p->getName () + " ' already registered" );
44
91
}
45
92
m_vProcessors.push_back (p);
46
93
}
47
94
48
95
// ---------------------------------------------------------------------
49
96
50
97
void WSJCppArgumentProcessor::registrySingleArgument (const std::string &sArgumentName , const std::string &sDescription ) {
51
-
98
+ if (hasRegisteredArgumentName (sArgumentName )) {
99
+ WSJCppLog::throw_err (TAG, " Argument Name '" + sArgumentName + " ' already registered" );
100
+ }
101
+ m_vSingleArguments.push_back (new WSJCppArgumentSingle (sArgumentName , sDescription ));
52
102
}
53
103
54
104
// ---------------------------------------------------------------------
55
105
56
- void WSJCppArgumentProcessor::registryParamArgument (const std::string &sArgumentName , const std::string &sDescription ) {
57
-
106
+ void WSJCppArgumentProcessor::registryParameterArgument (const std::string &sArgumentName , const std::string &sDescription ) {
107
+ if (hasRegisteredArgumentName (sArgumentName )) {
108
+ WSJCppLog::throw_err (TAG, " Argument Name '" + sArgumentName + " ' already registered" );
109
+ }
110
+ m_vParameterArguments.push_back (new WSJCppArgumentParameter (sArgumentName , sDescription ));
58
111
}
59
112
60
113
// ---------------------------------------------------------------------
61
114
62
- std::string WSJCppArgumentProcessor::help (const std::string &sProgramName , const std::string &sPrefix ) {
63
- std::string sRet = " " ;
64
- if (sProgramName == m_sName) {
65
- sRet = " Usage: " + m_sName + " <params> <command> <subcomands/args>\r\n " ;
115
+ WSJCppArgumentSingle *WSJCppArgumentProcessor::findRegisteredSingleArgument (const std::string &sArgumentName ) {
116
+ WSJCppArgumentSingle *pRet = nullptr ;
117
+ for (int i = 0 ; i < m_vSingleArguments.size (); i++) {
118
+ if (m_vSingleArguments[i]->getName () == sArgumentName ) {
119
+ if (pRet == nullptr ) {
120
+ pRet = m_vSingleArguments[i];
121
+ } else {
122
+ WSJCppLog::throw_err (TAG, " Single argument '" + sArgumentName + " ' already exists" );
123
+ }
124
+ }
66
125
}
67
- sRet += sPrefix + " <params>: \r\n " ;
68
- sRet += sPrefix + " [] - description \r\n " ; // TODO
126
+ return pRet ;
127
+ }
69
128
70
- if (m_vProcessors.size () > 0 ) {
71
- sRet += sPrefix + " <commands>: \r\n " ;
72
- for (int i = 0 ; i < m_vProcessors.size (); i++) {
73
- WSJCppArgumentProcessor *p = m_vProcessors[i];
74
- sRet += sPrefix + " " + p->getName () + " - " + p->getDescription () + " \r\n " ;
75
- sRet += p->help (sProgramName , sPrefix + " " );
129
+ // ---------------------------------------------------------------------
130
+
131
+ WSJCppArgumentParameter *WSJCppArgumentProcessor::findRegisteredParameterArgument (const std::string &sArgumentName ) {
132
+ WSJCppArgumentParameter *pRet = nullptr ;
133
+ for (int i = 0 ; i < m_vParameterArguments.size (); i++) {
134
+ if (m_vParameterArguments[i]->getName () == sArgumentName ) {
135
+ if (pRet == nullptr ) {
136
+ pRet = m_vParameterArguments[i];
137
+ } else {
138
+ WSJCppLog::throw_err (TAG, " Single argument '" + sArgumentName + " ' already exists" );
139
+ }
76
140
}
77
141
}
78
- sRet += " \r\n " ; // TODO
79
- return sRet ;
142
+ return pRet;
80
143
}
81
144
145
+
82
146
// ---------------------------------------------------------------------
83
147
84
- WSJCppArgumentProcessor *WSJCppArgumentProcessor::findProcessor (const std::vector<std:: string> &vSubParams ) {
148
+ WSJCppArgumentProcessor *WSJCppArgumentProcessor::findRegisteredProcessor (const std::string & sArgumentName ) {
85
149
WSJCppArgumentProcessor *pRet = nullptr ;
86
- bool bCanHandle = false ;
87
150
for (int i = 0 ; i < m_vProcessors.size (); i++) {
88
- if (m_vProcessors[i]->canHandle (vSubParams) ) {
151
+ if (m_vProcessors[i]->getName () == sArgumentName ) {
89
152
if (pRet == nullptr ) {
90
153
pRet = m_vProcessors[i];
91
154
} else {
@@ -98,44 +161,161 @@ WSJCppArgumentProcessor *WSJCppArgumentProcessor::findProcessor(const std::vecto
98
161
99
162
// ---------------------------------------------------------------------
100
163
101
- WSJCppArguments::WSJCppArguments (int argc, const char * argv[]) {
164
+ bool WSJCppArgumentProcessor::hasRegisteredArgumentName (const std::string &sArgumentName ) {
165
+ for (int i = 0 ; i < m_vParameterArguments.size (); i++) {
166
+ if (m_vParameterArguments[i]->getName () == sArgumentName ) {
167
+ return true ;
168
+ }
169
+ }
170
+
171
+ for (int i = 0 ; i < m_vProcessors.size (); i++) {
172
+ if (m_vProcessors[i]->getName () == sArgumentName ) {
173
+ return true ;
174
+ }
175
+ }
176
+
177
+ for (int i = 0 ; i < m_vSingleArguments.size (); i++) {
178
+ if (m_vSingleArguments[i]->getName () == sArgumentName ) {
179
+ return true ;
180
+ }
181
+ }
182
+ return false ;
183
+ }
184
+
185
+ // ---------------------------------------------------------------------
186
+
187
+ std::string WSJCppArgumentProcessor::help (const std::string &sProgramName , const std::string &sPrefix ) {
188
+ std::string sRet = " " ;
189
+ if (m_vSingleArguments.size () > 0 || m_vParameterArguments.size ()) {
190
+ sRet += " \r\n " + sPrefix + " Arguments: \r\n " ;
191
+
192
+ for (int i = 0 ; i < m_vSingleArguments.size (); i++) {
193
+ sRet += m_vSingleArguments[i]->help (sProgramName , sPrefix + " " ) + " \r\n " ;
194
+ }
195
+
196
+ for (int i = 0 ; i < m_vParameterArguments.size (); i++) {
197
+ sRet += m_vParameterArguments[i]->help (sProgramName , sPrefix + " " ) + " \r\n " ;
198
+ }
199
+ }
200
+
201
+ if (m_vProcessors.size () > 0 ) {
202
+ sRet += " \r\n " + sPrefix + " Commands: \r\n " ;
203
+ for (int i = 0 ; i < m_vProcessors.size (); i++) {
204
+ WSJCppArgumentProcessor *p = m_vProcessors[i];
205
+ // TODO need a previous Processors
206
+ sRet += sPrefix + " " + sProgramName + " <params> " + p->getName () + " - " + p->getDescription () + " \r\n " ;
207
+ sRet += p->help (sProgramName , sPrefix + " " );
208
+ }
209
+ }
210
+
211
+ sRet += " \r\n " ; // TODO
212
+ return sRet ;
213
+ }
214
+
215
+ // ---------------------------------------------------------------------
216
+
217
+ WSJCppArguments::WSJCppArguments (int argc, const char * argv[], WSJCppArgumentProcessor *pRoot) {
102
218
TAG = " WSJCppArguments" ;
103
219
for (int i = 0 ; i < argc; i++) {
104
220
m_vArguments.push_back (std::string (argv[i]));
105
221
}
106
222
m_sProgramName = m_vArguments[0 ];
107
223
m_vArguments.erase (m_vArguments.begin ());
108
- m_pRoot = new WSJCppArgumentProcessor (m_sProgramName, " " ) ;
224
+ m_pRoot = pRoot ;
109
225
}
110
226
111
227
// ---------------------------------------------------------------------
112
228
113
- int WSJCppArguments::handle () {
114
- WSJCppArgumentProcessor *pArgumentProcessor = m_pRoot->findProcessor (m_vArguments);
115
- if (pArgumentProcessor != nullptr ) {
116
- return pArgumentProcessor->handle (m_sProgramName, m_vArguments);
229
+ int WSJCppArguments::exec () {
230
+ if (m_pRoot == nullptr ) {
231
+ WSJCppLog::throw_err (TAG, " Root could not be nullptr" );
117
232
}
118
- WSJCppLog::err (TAG, " Not found argument processor " );
119
- return - 1 ;
233
+ std::vector<std::string> vArgs (m_vArguments );
234
+ return this -> recursiveExec (m_pRoot, vArgs) ;
120
235
}
121
236
122
237
// ---------------------------------------------------------------------
123
238
124
- bool WSJCppArguments::canHandle () {
125
- WSJCppArgumentProcessor *pArgumentProcessor = m_pRoot->findProcessor (m_vArguments);
126
- return pArgumentProcessor != nullptr ;
239
+ int WSJCppArguments::recursiveExec (WSJCppArgumentProcessor *pArgumentProcessor, std::vector<std::string> &vSubArguments) {
240
+
241
+ std::vector<WSJCppArgumentSingle *> vSingleArguments;
242
+ std::vector<WSJCppArgumentParameter *> vParameterArguments;
243
+ vSubArguments = extractSingleAndParameterArguments (pArgumentProcessor, vSubArguments, vSingleArguments, vParameterArguments);
244
+
245
+ // apply single arguments
246
+ for (int i = 0 ; i < vSingleArguments.size (); i++) {
247
+ WSJCppArgumentSingle *p = vSingleArguments[i];
248
+ if (!pArgumentProcessor->applySingleArgument (m_sProgramName, p->getName ())) {
249
+ WSJCppLog::err (TAG, " Could not apply single argument '" + p->getName () + " ' " );
250
+ return -1 ;
251
+ }
252
+ }
253
+
254
+ // apply parameter arguments
255
+ for (int i = 0 ; i < vParameterArguments.size (); i++) {
256
+ WSJCppArgumentParameter *p = vParameterArguments[i];
257
+ if (!pArgumentProcessor->applyParameterArgument (m_sProgramName, p->getName (), p->getValue ())) {
258
+ WSJCppLog::err (TAG, " Could not apply parameter argument '" + p->getName () + " ' for '" + pArgumentProcessor->getName () + " '" );
259
+ return -1 ;
260
+ }
261
+ }
262
+
263
+ if (vSubArguments.size () == 0 ) {
264
+ WSJCppLog::throw_err (TAG, " Could not find processor for execute with empty name" );
265
+ }
266
+
267
+ WSJCppArgumentProcessor *pNextProcessor = pArgumentProcessor->findRegisteredProcessor (vSubArguments[0 ]);
268
+ if (pNextProcessor != nullptr ) {
269
+ vSubArguments.erase (vSubArguments.begin ());
270
+ return this ->recursiveExec (pNextProcessor, vSubArguments);
271
+ }
272
+ return pArgumentProcessor->exec (m_sProgramName, vSubArguments);
127
273
}
128
274
129
275
// ---------------------------------------------------------------------
130
276
131
- WSJCppArgumentProcessor &WSJCppArguments::getRoot () {
132
- return *m_pRoot;
277
+ std::vector<std::string> WSJCppArguments::extractSingleAndParameterArguments (
278
+ WSJCppArgumentProcessor *pArgumentProcessor,
279
+ const std::vector<std::string> &vArguments,
280
+ std::vector<WSJCppArgumentSingle *> &vSingleArguments,
281
+ std::vector<WSJCppArgumentParameter *> &vParameterArguments
282
+ ) {
283
+ std::vector<std::string> vArgs (vArguments);
284
+ bool bFound = true ;
285
+ while (bFound) {
286
+ bFound = false ;
287
+ if (vArgs.size () > 0 ) {
288
+ std::string sFirst = vArgs[0 ];
289
+ WSJCppArgumentSingle *pSingle = pArgumentProcessor->findRegisteredSingleArgument (sFirst );
290
+ WSJCppArgumentParameter *pParameter = pArgumentProcessor->findRegisteredParameterArgument (sFirst );
291
+ if (pSingle != nullptr ) {
292
+ vArgs.erase (vArgs.begin ());
293
+ bFound = true ;
294
+ vSingleArguments.push_back (pSingle);
295
+ } else if (pParameter != nullptr ) {
296
+ bFound = true ;
297
+ vParameterArguments.push_back (pParameter);
298
+ vArgs.erase (vArgs.begin ());
299
+ if (vArgs.size () == 0 ) {
300
+ WSJCppLog::throw_err (TAG, " Expected value for '" + pParameter->getName () + " '" );
301
+ } else {
302
+ pParameter->setValue (vArgs[0 ]);
303
+ vArgs.erase (vArgs.begin ());
304
+ }
305
+ }
306
+ }
307
+ }
308
+ return vArgs;
133
309
}
134
310
135
311
// ---------------------------------------------------------------------
136
312
137
313
std::string WSJCppArguments::help () {
138
- return m_pRoot->help (m_sProgramName, " " );
314
+ std::string sRet = " \r\n " ;
315
+ sRet += " Usage: " + m_sProgramName + " <arguments> [<command> <arguments>] ... [<subcommand> <arguments>]\r\n\r\n " ;
316
+ sRet += " " + m_pRoot->getDescription () + " \r\n " ;
317
+
318
+ return sRet + m_pRoot->help (m_sProgramName, " " );
139
319
}
140
320
141
- // ---------------------------------------------------------------------
321
+ // ---------------------------------------------------------------------
0 commit comments