Skip to content

Commit 04728c8

Browse files
sea5kgsea5kg
committed
Fixed tests
1 parent 618f217 commit 04728c8

File tree

6 files changed

+500
-128
lines changed

6 files changed

+500
-128
lines changed

‎src/wsjcpp_arguments.cpp‎

Lines changed: 227 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -1,91 +1,154 @@
11
#include "wsjcpp_arguments.h"
22
#include <wsjcpp_core.h>
33

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+
410
// ---------------------------------------------------------------------
511

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;
832
m_sName = sName;
933
m_sDescription = sDescription;
1034
}
1135

1236
// ---------------------------------------------------------------------
1337

14-
std::string WSJCppArgumentProcessor::getName() {
38+
std::string WSJCppArgumentParameter::getName() {
1539
return m_sName;
1640
}
1741

1842
// ---------------------------------------------------------------------
1943

20-
std::string WSJCppArgumentProcessor::getDescription() {
44+
std::string WSJCppArgumentParameter::getDescription() {
2145
return m_sDescription;
2246
}
2347

2448
// ---------------------------------------------------------------------
2549

26-
int WSJCppArgumentProcessor::handle(const std::string &sProgramName, const std::vector<std::string> &vSubParams) {
50+
std::string WSJCppArgumentParameter::getValue() {
51+
return m_sValue;
52+
}
2753

28-
return -1;
54+
// ---------------------------------------------------------------------
55+
56+
void WSJCppArgumentParameter::setValue(const std::string &sValue) {
57+
m_sValue = sValue;
2958
}
3059

3160
// ---------------------------------------------------------------------
3261

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;
3584
}
3685

3786
// ---------------------------------------------------------------------
3887

3988
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");
4491
}
4592
m_vProcessors.push_back(p);
4693
}
4794

4895
// ---------------------------------------------------------------------
4996

5097
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));
52102
}
53103

54104
// ---------------------------------------------------------------------
55105

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));
58111
}
59112

60113
// ---------------------------------------------------------------------
61114

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+
}
66125
}
67-
sRet += sPrefix + " <params>: \r\n";
68-
sRet += sPrefix + " [] - description \r\n"; // TODO
126+
return pRet;
127+
}
69128

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+
}
76140
}
77141
}
78-
sRet += "\r\n"; // TODO
79-
return sRet;
142+
return pRet;
80143
}
81144

145+
82146
// ---------------------------------------------------------------------
83147

84-
WSJCppArgumentProcessor *WSJCppArgumentProcessor::findProcessor(const std::vector<std::string> &vSubParams) {
148+
WSJCppArgumentProcessor *WSJCppArgumentProcessor::findRegisteredProcessor(const std::string &sArgumentName) {
85149
WSJCppArgumentProcessor *pRet = nullptr;
86-
bool bCanHandle = false;
87150
for (int i = 0; i < m_vProcessors.size(); i++) {
88-
if (m_vProcessors[i]->canHandle(vSubParams)) {
151+
if (m_vProcessors[i]->getName() == sArgumentName) {
89152
if (pRet == nullptr) {
90153
pRet = m_vProcessors[i];
91154
} else {
@@ -98,44 +161,161 @@ WSJCppArgumentProcessor *WSJCppArgumentProcessor::findProcessor(const std::vecto
98161

99162
// ---------------------------------------------------------------------
100163

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) {
102218
TAG = "WSJCppArguments";
103219
for (int i = 0; i < argc; i++) {
104220
m_vArguments.push_back(std::string(argv[i]));
105221
}
106222
m_sProgramName = m_vArguments[0];
107223
m_vArguments.erase(m_vArguments.begin());
108-
m_pRoot = new WSJCppArgumentProcessor(m_sProgramName, "");
224+
m_pRoot = pRoot;
109225
}
110226

111227
// ---------------------------------------------------------------------
112228

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");
117232
}
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);
120235
}
121236

122237
// ---------------------------------------------------------------------
123238

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);
127273
}
128274

129275
// ---------------------------------------------------------------------
130276

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;
133309
}
134310

135311
// ---------------------------------------------------------------------
136312

137313
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, " ");
139319
}
140320

141-
// ---------------------------------------------------------------------
321+
// ---------------------------------------------------------------------

0 commit comments

Comments
 (0)