|
|
|
@ -5,402 +5,501 @@ |
|
|
|
|
|
|
|
|
|
namespace cv |
|
|
|
|
{ |
|
|
|
|
bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2) |
|
|
|
|
|
|
|
|
|
struct CommandLineParserParams |
|
|
|
|
{ |
|
|
|
|
public: |
|
|
|
|
string help_message; |
|
|
|
|
string def_value; |
|
|
|
|
vector<string> keys; |
|
|
|
|
int number; |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct CommandLineParser::Impl |
|
|
|
|
{ |
|
|
|
|
bool error; |
|
|
|
|
string error_message; |
|
|
|
|
string about_message; |
|
|
|
|
|
|
|
|
|
string path_to_app; |
|
|
|
|
string app_name; |
|
|
|
|
|
|
|
|
|
vector<CommandLineParserParams> data; |
|
|
|
|
|
|
|
|
|
vector<string> split_range_string(const string& str, char fs, char ss) const; |
|
|
|
|
vector<string> split_string(const string& str, char symbol = ' ', bool create_empty_item = false) const; |
|
|
|
|
string cat_string(const string& str) const; |
|
|
|
|
|
|
|
|
|
void apply_params(const string& key, const string& value); |
|
|
|
|
void apply_params(int i, string value); |
|
|
|
|
|
|
|
|
|
void sort_params(); |
|
|
|
|
int refcount; |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static string get_type_name(int type) |
|
|
|
|
{ |
|
|
|
|
if( type == Param::INT ) |
|
|
|
|
return "int"; |
|
|
|
|
if( type == Param::UNSIGNED_INT ) |
|
|
|
|
return "unsigned"; |
|
|
|
|
if( type == Param::UINT64 ) |
|
|
|
|
return "unsigned long long"; |
|
|
|
|
if( type == Param::FLOAT ) |
|
|
|
|
return "float"; |
|
|
|
|
if( type == Param::REAL ) |
|
|
|
|
return "double"; |
|
|
|
|
if( type == Param::STRING ) |
|
|
|
|
return "string"; |
|
|
|
|
return "unknown"; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void from_str(const string& str, int type, void* dst) |
|
|
|
|
{ |
|
|
|
|
std::stringstream ss(str); |
|
|
|
|
if( type == Param::INT ) |
|
|
|
|
ss >> *(int*)dst; |
|
|
|
|
else if( type == Param::UNSIGNED_INT ) |
|
|
|
|
ss >> *(unsigned*)dst; |
|
|
|
|
else if( type == Param::UINT64 ) |
|
|
|
|
ss >> *(uint64*)dst; |
|
|
|
|
else if( type == Param::FLOAT ) |
|
|
|
|
ss >> *(float*)dst; |
|
|
|
|
else if( type == Param::REAL ) |
|
|
|
|
ss >> *(double*)dst; |
|
|
|
|
else if( type == Param::STRING ) |
|
|
|
|
ss >> *(string*)dst; |
|
|
|
|
|
|
|
|
|
if (ss.fail()) |
|
|
|
|
{ |
|
|
|
|
if (p1.number > p2.number) |
|
|
|
|
return false; |
|
|
|
|
string err_msg = "can not convert: [" + str + |
|
|
|
|
+ "] to [" + get_type_name(type) + "]"; |
|
|
|
|
|
|
|
|
|
CV_Error(CV_StsBadArg, err_msg); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (p1.number == -1 && p2.number == -1) |
|
|
|
|
void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const |
|
|
|
|
{ |
|
|
|
|
try |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
if (p1.keys[0].compare(p2.keys[0]) > 0) |
|
|
|
|
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
|
|
|
|
{ |
|
|
|
|
return false; |
|
|
|
|
if (name.compare(impl->data[i].keys[j]) == 0) |
|
|
|
|
{ |
|
|
|
|
string v = impl->data[i].def_value; |
|
|
|
|
if (space_delete) |
|
|
|
|
v = impl->cat_string(v); |
|
|
|
|
from_str(v, type, dst); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return true; |
|
|
|
|
impl->error = true; |
|
|
|
|
impl->error_message += "Unknown parametes " + name + "\n"; |
|
|
|
|
} |
|
|
|
|
catch (std::exception& e) |
|
|
|
|
{ |
|
|
|
|
impl->error = true; |
|
|
|
|
impl->error_message += "Exception: " + string(e.what()) + "\n"; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
CommandLineParser::CommandLineParser(int argc, const char * const argv[], const std::string keys) |
|
|
|
|
|
|
|
|
|
void CommandLineParser::getByIndex(int index, bool space_delete, int type, void* dst) const |
|
|
|
|
{ |
|
|
|
|
try |
|
|
|
|
{ |
|
|
|
|
// path to application
|
|
|
|
|
size_t pos_s = std::string(argv[0]).find_last_of("/\\"); |
|
|
|
|
if (pos_s == std::string::npos) |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
path_to_app = ""; |
|
|
|
|
app_name = std::string(argv[0]); |
|
|
|
|
if (impl->data[i].number == index) |
|
|
|
|
{ |
|
|
|
|
string v = impl->data[i].def_value; |
|
|
|
|
if (space_delete == true) v = impl->cat_string(v); |
|
|
|
|
from_str(v, type, dst); |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
impl->error = true; |
|
|
|
|
impl->error_message += "Unknown parametes #" + format("%d", index) + "\n"; |
|
|
|
|
} |
|
|
|
|
catch(std::exception & e) |
|
|
|
|
{ |
|
|
|
|
impl->error = true; |
|
|
|
|
impl->error_message += "Exception: " + string(e.what()) + "\n"; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2) |
|
|
|
|
{ |
|
|
|
|
if (p1.number > p2.number) |
|
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
if (p1.number == -1 && p2.number == -1) |
|
|
|
|
{ |
|
|
|
|
if (p1.keys[0].compare(p2.keys[0]) > 0) |
|
|
|
|
{ |
|
|
|
|
path_to_app = std::string(argv[0]).substr(0, pos_s); |
|
|
|
|
app_name = std::string(argv[0]).substr(pos_s + 1, std::string(argv[0]).length() - pos_s); |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
error = false; |
|
|
|
|
error_message = ""; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// parse keys
|
|
|
|
|
std::vector<std::string> k = split_range_string(keys, '{', '}'); |
|
|
|
|
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const string& keys) |
|
|
|
|
{ |
|
|
|
|
impl = new Impl; |
|
|
|
|
impl->refcount = 1; |
|
|
|
|
|
|
|
|
|
// path to application
|
|
|
|
|
size_t pos_s = string(argv[0]).find_last_of("/\\"); |
|
|
|
|
if (pos_s == string::npos) |
|
|
|
|
{ |
|
|
|
|
impl->path_to_app = ""; |
|
|
|
|
impl->app_name = string(argv[0]); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
impl->path_to_app = string(argv[0]).substr(0, pos_s); |
|
|
|
|
impl->app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
int jj = 0; |
|
|
|
|
for (size_t i = 0; i < k.size(); i++) |
|
|
|
|
{ |
|
|
|
|
std::vector<std::string> l = split_string(k[i], '|', true); |
|
|
|
|
CommandLineParserParams p; |
|
|
|
|
p.keys = split_string(l[0]); |
|
|
|
|
p.def_value = l[1]; |
|
|
|
|
p.help_message = cat_string(l[2]); |
|
|
|
|
p.number = -1; |
|
|
|
|
if (p.keys[0][0] == '@') |
|
|
|
|
{ |
|
|
|
|
p.number = jj; |
|
|
|
|
jj++; |
|
|
|
|
} |
|
|
|
|
impl->error = false; |
|
|
|
|
impl->error_message = ""; |
|
|
|
|
|
|
|
|
|
data.push_back(p); |
|
|
|
|
} |
|
|
|
|
// parse keys
|
|
|
|
|
vector<string> k = impl->split_range_string(keys, '{', '}'); |
|
|
|
|
|
|
|
|
|
// parse argv
|
|
|
|
|
jj = 0; |
|
|
|
|
for (int i = 1; i < argc; i++) |
|
|
|
|
int jj = 0; |
|
|
|
|
for (size_t i = 0; i < k.size(); i++) |
|
|
|
|
{ |
|
|
|
|
vector<string> l = impl->split_string(k[i], '|', true); |
|
|
|
|
CommandLineParserParams p; |
|
|
|
|
p.keys = impl->split_string(l[0]); |
|
|
|
|
p.def_value = l[1]; |
|
|
|
|
p.help_message = impl->cat_string(l[2]); |
|
|
|
|
p.number = -1; |
|
|
|
|
if (p.keys[0][0] == '@') |
|
|
|
|
{ |
|
|
|
|
std::string s = std::string(argv[i]); |
|
|
|
|
|
|
|
|
|
if (s.find('=') != std::string::npos && s.find('=') < s.length()) |
|
|
|
|
{ |
|
|
|
|
std::vector<std::string> k_v = split_string(s, '=', true); |
|
|
|
|
for (int h = 0; h < 2; h++) |
|
|
|
|
{ |
|
|
|
|
if (k_v[0][0] == '-') |
|
|
|
|
k_v[0] = k_v[0].substr(1, k_v[0].length() -1); |
|
|
|
|
} |
|
|
|
|
apply_params(k_v[0], k_v[1]); |
|
|
|
|
} |
|
|
|
|
else if (s.length() > 1 && s[0] == '-') |
|
|
|
|
{ |
|
|
|
|
for (int h = 0; h < 2; h++) |
|
|
|
|
{ |
|
|
|
|
if (s[0] == '-') |
|
|
|
|
s = s.substr(1, s.length() - 1); |
|
|
|
|
} |
|
|
|
|
apply_params(s, "true"); |
|
|
|
|
} |
|
|
|
|
else if (s[0] != '-') |
|
|
|
|
{ |
|
|
|
|
apply_params(jj, s); |
|
|
|
|
jj++; |
|
|
|
|
} |
|
|
|
|
p.number = jj; |
|
|
|
|
jj++; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
sort_params(); |
|
|
|
|
impl->data.push_back(p); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::about(std::string message) |
|
|
|
|
// parse argv
|
|
|
|
|
jj = 0; |
|
|
|
|
for (int i = 1; i < argc; i++) |
|
|
|
|
{ |
|
|
|
|
about_message = message; |
|
|
|
|
} |
|
|
|
|
string s = string(argv[i]); |
|
|
|
|
|
|
|
|
|
void CommandLineParser::apply_params(std::string key, std::string value) |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
if (s.find('=') != string::npos && s.find('=') < s.length()) |
|
|
|
|
{ |
|
|
|
|
for (size_t k = 0; k < data[i].keys.size(); k++) |
|
|
|
|
vector<string> k_v = impl->split_string(s, '=', true); |
|
|
|
|
for (int h = 0; h < 2; h++) |
|
|
|
|
{ |
|
|
|
|
if (key.compare(data[i].keys[k]) == 0) |
|
|
|
|
{ |
|
|
|
|
data[i].def_value = value; |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
if (k_v[0][0] == '-') |
|
|
|
|
k_v[0] = k_v[0].substr(1, k_v[0].length() -1); |
|
|
|
|
} |
|
|
|
|
impl->apply_params(k_v[0], k_v[1]); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::apply_params(int i, std::string value) |
|
|
|
|
{ |
|
|
|
|
for (size_t j = 0; j < data.size(); j++) |
|
|
|
|
else if (s.length() > 1 && s[0] == '-') |
|
|
|
|
{ |
|
|
|
|
if (data[j].number == i) |
|
|
|
|
for (int h = 0; h < 2; h++) |
|
|
|
|
{ |
|
|
|
|
data[j].def_value = value; |
|
|
|
|
break; |
|
|
|
|
if (s[0] == '-') |
|
|
|
|
s = s.substr(1, s.length() - 1); |
|
|
|
|
} |
|
|
|
|
impl->apply_params(s, "true"); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::sort_params() |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
else if (s[0] != '-') |
|
|
|
|
{ |
|
|
|
|
sort(data[i].keys.begin(), data[i].keys.end()); |
|
|
|
|
impl->apply_params(jj, s); |
|
|
|
|
jj++; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
sort (data.begin(), data.end(), cmp_params); |
|
|
|
|
impl->sort_params(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CommandLineParser::CommandLineParser(const CommandLineParser& parser) |
|
|
|
|
{ |
|
|
|
|
impl = parser.impl; |
|
|
|
|
CV_XADD(&impl->refcount, 1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
CommandLineParser& CommandLineParser::operator = (const CommandLineParser& parser) |
|
|
|
|
{ |
|
|
|
|
if( this != &parser ) |
|
|
|
|
{ |
|
|
|
|
if(CV_XADD(&impl->refcount, -1) == 1) |
|
|
|
|
delete impl; |
|
|
|
|
impl = parser.impl; |
|
|
|
|
CV_XADD(&impl->refcount, 1); |
|
|
|
|
} |
|
|
|
|
return *this; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::about(const string& message) |
|
|
|
|
{ |
|
|
|
|
impl->about_message = message; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
std::string CommandLineParser::cat_string(std::string str) |
|
|
|
|
void CommandLineParser::Impl::apply_params(const string& key, const string& value) |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
while (!str.empty() && str[0] == ' ') |
|
|
|
|
for (size_t k = 0; k < data[i].keys.size(); k++) |
|
|
|
|
{ |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
if (key.compare(data[i].keys[k]) == 0) |
|
|
|
|
{ |
|
|
|
|
data[i].def_value = value; |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
while (!str.empty() && str[str.length() - 1] == ' ') |
|
|
|
|
void CommandLineParser::Impl::apply_params(int i, string value) |
|
|
|
|
{ |
|
|
|
|
for (size_t j = 0; j < data.size(); j++) |
|
|
|
|
{ |
|
|
|
|
if (data[j].number == i) |
|
|
|
|
{ |
|
|
|
|
str = str.substr(0, str.length() - 1); |
|
|
|
|
data[j].def_value = value; |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return str; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
std::string CommandLineParser::getPathToApplication() |
|
|
|
|
void CommandLineParser::Impl::sort_params() |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
return path_to_app; |
|
|
|
|
sort(data[i].keys.begin(), data[i].keys.end()); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool CommandLineParser::has(const std::string& name) |
|
|
|
|
sort (data.begin(), data.end(), cmp_params); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string CommandLineParser::Impl::cat_string(const string& str) const |
|
|
|
|
{ |
|
|
|
|
int left = 0, right = (int)str.length(); |
|
|
|
|
while( left <= right && str[left] == ' ' ) |
|
|
|
|
left++; |
|
|
|
|
while( right > left && str[right-1] == ' ' ) |
|
|
|
|
right--; |
|
|
|
|
return left >= right ? string("") : str.substr(left, right-left); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string CommandLineParser::getPathToApplication() const |
|
|
|
|
{ |
|
|
|
|
return impl->path_to_app; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool CommandLineParser::has(const string& name) const |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
|
|
|
|
{ |
|
|
|
|
for (size_t j = 0; j < data[i].keys.size(); j++) |
|
|
|
|
if (name.compare(impl->data[i].keys[j]) == 0 && string("true").compare(impl->data[i].def_value) == 0) |
|
|
|
|
{ |
|
|
|
|
if (name.compare(data[i].keys[j]) == 0 && std::string("true").compare(data[i].def_value) == 0) |
|
|
|
|
{ |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool CommandLineParser::check() |
|
|
|
|
{ |
|
|
|
|
return error == false; |
|
|
|
|
} |
|
|
|
|
bool CommandLineParser::check() const |
|
|
|
|
{ |
|
|
|
|
return impl->error == false; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::printErrors() |
|
|
|
|
void CommandLineParser::printErrors() const |
|
|
|
|
{ |
|
|
|
|
if (impl->error) |
|
|
|
|
{ |
|
|
|
|
if (error) |
|
|
|
|
{ |
|
|
|
|
std::cout << std::endl << "ERRORS:" << std::endl << error_message << std::endl; |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl << "ERRORS:" << std::endl << impl->error_message << std::endl; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CommandLineParser::printMessage() |
|
|
|
|
{ |
|
|
|
|
if (about_message != "") |
|
|
|
|
std::cout << about_message << std::endl; |
|
|
|
|
void CommandLineParser::printMessage() const |
|
|
|
|
{ |
|
|
|
|
if (impl->about_message != "") |
|
|
|
|
std::cout << impl->about_message << std::endl; |
|
|
|
|
|
|
|
|
|
std::cout << "Usage: " << app_name << " [params] "; |
|
|
|
|
std::cout << "Usage: " << impl->app_name << " [params] "; |
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
if (impl->data[i].number > -1) |
|
|
|
|
{ |
|
|
|
|
if (data[i].number > -1) |
|
|
|
|
{ |
|
|
|
|
std::string name = data[i].keys[0].substr(1, data[i].keys[0].length() - 1); |
|
|
|
|
std::cout << name << " "; |
|
|
|
|
} |
|
|
|
|
string name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1); |
|
|
|
|
std::cout << name << " "; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
std::cout << std::endl << std::endl; |
|
|
|
|
std::cout << std::endl << std::endl; |
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
if (impl->data[i].number == -1) |
|
|
|
|
{ |
|
|
|
|
if (data[i].number == -1) |
|
|
|
|
std::cout << "\t"; |
|
|
|
|
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
|
|
|
|
{ |
|
|
|
|
std::cout << "\t"; |
|
|
|
|
for (size_t j = 0; j < data[i].keys.size(); j++) |
|
|
|
|
string k = impl->data[i].keys[j]; |
|
|
|
|
if (k.length() > 1) |
|
|
|
|
{ |
|
|
|
|
std::string k = data[i].keys[j]; |
|
|
|
|
if (k.length() > 1) |
|
|
|
|
{ |
|
|
|
|
std::cout << "--"; |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
std::cout << "-"; |
|
|
|
|
} |
|
|
|
|
std::cout << k; |
|
|
|
|
|
|
|
|
|
if (j != data[i].keys.size() - 1) |
|
|
|
|
{ |
|
|
|
|
std::cout << ", "; |
|
|
|
|
} |
|
|
|
|
std::cout << "--"; |
|
|
|
|
} |
|
|
|
|
std::string dv = cat_string(data[i].def_value); |
|
|
|
|
if (dv.compare("") != 0) |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
std::cout << " (value:" << dv << ")"; |
|
|
|
|
std::cout << "-"; |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl << "\t\t" << data[i].help_message << std::endl; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl; |
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
if (data[i].number != -1) |
|
|
|
|
{ |
|
|
|
|
std::cout << "\t"; |
|
|
|
|
std::string k = data[i].keys[0]; |
|
|
|
|
k = k.substr(1, k.length() - 1); |
|
|
|
|
|
|
|
|
|
std::cout << k; |
|
|
|
|
|
|
|
|
|
std::string dv = cat_string(data[i].def_value); |
|
|
|
|
if (dv.compare("") != 0) |
|
|
|
|
if (j != impl->data[i].keys.size() - 1) |
|
|
|
|
{ |
|
|
|
|
std::cout << " (value:" << dv << ")"; |
|
|
|
|
std::cout << ", "; |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl << "\t\t" << data[i].help_message << std::endl; |
|
|
|
|
} |
|
|
|
|
string dv = impl->cat_string(impl->data[i].def_value); |
|
|
|
|
if (dv.compare("") != 0) |
|
|
|
|
{ |
|
|
|
|
std::cout << " (value:" << dv << ")"; |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl; |
|
|
|
|
|
|
|
|
|
std::vector<std::string> CommandLineParser::split_range_string(std::string str, char fs, char ss) |
|
|
|
|
for (size_t i = 0; i < impl->data.size(); i++) |
|
|
|
|
{ |
|
|
|
|
std::vector<std::string> vec; |
|
|
|
|
std::string word = ""; |
|
|
|
|
bool begin = false; |
|
|
|
|
|
|
|
|
|
while (!str.empty()) |
|
|
|
|
if (impl->data[i].number != -1) |
|
|
|
|
{ |
|
|
|
|
if (str[0] == fs) |
|
|
|
|
{ |
|
|
|
|
if (begin == true) |
|
|
|
|
{ |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
std::string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, fs) |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, ss) |
|
|
|
|
+ std::string(")") |
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
begin = true; |
|
|
|
|
word = ""; |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
} |
|
|
|
|
std::cout << "\t"; |
|
|
|
|
string k = impl->data[i].keys[0]; |
|
|
|
|
k = k.substr(1, k.length() - 1); |
|
|
|
|
|
|
|
|
|
std::cout << k; |
|
|
|
|
|
|
|
|
|
if (str[0] == ss) |
|
|
|
|
string dv = impl->cat_string(impl->data[i].def_value); |
|
|
|
|
if (dv.compare("") != 0) |
|
|
|
|
{ |
|
|
|
|
if (begin == false) |
|
|
|
|
{ |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
std::string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, fs) |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, ss) |
|
|
|
|
+ std::string(")") |
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
begin = false; |
|
|
|
|
vec.push_back(word); |
|
|
|
|
std::cout << " (value:" << dv << ")"; |
|
|
|
|
} |
|
|
|
|
std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
vector<string> CommandLineParser::Impl::split_range_string(const string& _str, char fs, char ss) const |
|
|
|
|
{ |
|
|
|
|
string str = _str; |
|
|
|
|
vector<string> vec; |
|
|
|
|
string word = ""; |
|
|
|
|
bool begin = false; |
|
|
|
|
|
|
|
|
|
while (!str.empty()) |
|
|
|
|
{ |
|
|
|
|
if (str[0] == fs) |
|
|
|
|
{ |
|
|
|
|
if (begin == true) |
|
|
|
|
{ |
|
|
|
|
word += str[0]; |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, fs) |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, ss) |
|
|
|
|
+ string(")") |
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
begin = true; |
|
|
|
|
word = ""; |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (begin == true) |
|
|
|
|
if (str[0] == ss) |
|
|
|
|
{ |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
std::string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, fs) |
|
|
|
|
+ std::string(", ") |
|
|
|
|
+ std::string(1, ss) |
|
|
|
|
+ std::string(")") |
|
|
|
|
); |
|
|
|
|
if (begin == false) |
|
|
|
|
{ |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, fs) |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, ss) |
|
|
|
|
+ string(")") |
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
begin = false; |
|
|
|
|
vec.push_back(word); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return vec; |
|
|
|
|
if (begin == true) |
|
|
|
|
{ |
|
|
|
|
word += str[0]; |
|
|
|
|
} |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
std::vector<std::string> CommandLineParser::split_string(std::string str, char symbol, bool create_empty_item) |
|
|
|
|
if (begin == true) |
|
|
|
|
{ |
|
|
|
|
std::vector<std::string> vec; |
|
|
|
|
std::string word = ""; |
|
|
|
|
CV_Error(CV_StsParseError, |
|
|
|
|
string("error in split_range_string(") |
|
|
|
|
+ str |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, fs) |
|
|
|
|
+ string(", ") |
|
|
|
|
+ string(1, ss) |
|
|
|
|
+ string(")") |
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return vec; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
while (!str.empty()) |
|
|
|
|
vector<string> CommandLineParser::Impl::split_string(const string& _str, char symbol, bool create_empty_item) const |
|
|
|
|
{ |
|
|
|
|
string str = _str; |
|
|
|
|
vector<string> vec; |
|
|
|
|
string word = ""; |
|
|
|
|
|
|
|
|
|
while (!str.empty()) |
|
|
|
|
{ |
|
|
|
|
if (str[0] == symbol) |
|
|
|
|
{ |
|
|
|
|
if (str[0] == symbol) |
|
|
|
|
{ |
|
|
|
|
if (!word.empty() || create_empty_item) |
|
|
|
|
{ |
|
|
|
|
vec.push_back(word); |
|
|
|
|
word = ""; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
if (!word.empty() || create_empty_item) |
|
|
|
|
{ |
|
|
|
|
word += str[0]; |
|
|
|
|
vec.push_back(word); |
|
|
|
|
word = ""; |
|
|
|
|
} |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (word != "" || create_empty_item) |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
vec.push_back(word); |
|
|
|
|
word += str[0]; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return vec; |
|
|
|
|
str = str.substr(1, str.length() - 1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#undef clp_get |
|
|
|
|
#define clp_get(T) template<> T CommandLineParser::get<T>(const std::string& name, bool space_delete); |
|
|
|
|
|
|
|
|
|
clp_get(int) |
|
|
|
|
clp_get(unsigned int) |
|
|
|
|
clp_get(long) |
|
|
|
|
clp_get(unsigned long) |
|
|
|
|
clp_get(long long) |
|
|
|
|
clp_get(unsigned long long) |
|
|
|
|
clp_get(size_t) |
|
|
|
|
clp_get(float) |
|
|
|
|
clp_get(double) |
|
|
|
|
clp_get(uint64) |
|
|
|
|
clp_get(int64) |
|
|
|
|
clp_get(std::string) |
|
|
|
|
|
|
|
|
|
#undef clp_from_str |
|
|
|
|
#define clp_from_str(T) template<> T from_str<T>(const std::string & str); |
|
|
|
|
|
|
|
|
|
clp_from_str(int) |
|
|
|
|
clp_from_str(unsigned int) |
|
|
|
|
clp_from_str(long) |
|
|
|
|
clp_from_str(unsigned long) |
|
|
|
|
clp_from_str(long long) |
|
|
|
|
clp_from_str(unsigned long long) |
|
|
|
|
clp_from_str(size_t) |
|
|
|
|
clp_from_str(uint64) |
|
|
|
|
clp_from_str(int64) |
|
|
|
|
clp_from_str(float) |
|
|
|
|
clp_from_str(double) |
|
|
|
|
|
|
|
|
|
template<> |
|
|
|
|
std::string from_str(const std::string & str) |
|
|
|
|
if (word != "" || create_empty_item) |
|
|
|
|
{ |
|
|
|
|
return str; |
|
|
|
|
vec.push_back(word); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#undef clp_type_name |
|
|
|
|
#define clp_type_name(type, name) template<> std::string get_type_name<type>() { return std::string(name);} |
|
|
|
|
|
|
|
|
|
clp_type_name(int, "int") |
|
|
|
|
clp_type_name(unsigned int, "unsigned int") |
|
|
|
|
clp_type_name(long, "long") |
|
|
|
|
clp_type_name(long long, "long long") |
|
|
|
|
clp_type_name(unsigned long long, "unsigned long long") |
|
|
|
|
clp_type_name(size_t, "size_t") |
|
|
|
|
clp_type_name(float, "float") |
|
|
|
|
clp_type_name(double, "double") |
|
|
|
|
return vec; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|