Andrey Kamaev
13 years ago
parent
d566c6bc86
commit
ebac3a02aa
10 changed files with 560 additions and 599 deletions
@ -0,0 +1,43 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other GpuMaterials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "opencv2/core/cuda_devptrs.hpp" |
||||
@ -0,0 +1,382 @@ |
||||
#include "precomp.hpp" |
||||
|
||||
#include <iostream> |
||||
#include <iomanip> |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
namespace { |
||||
void helpParser() |
||||
{ |
||||
printf("\nThe CommandLineParser class is designed for command line arguments parsing\n" |
||||
"Keys map: \n" |
||||
"Before you start to work with CommandLineParser you have to create a map for keys.\n" |
||||
" It will look like this\n" |
||||
" const char* keys =\n" |
||||
" {\n" |
||||
" { s| string| 123asd |string parameter}\n" |
||||
" { d| digit | 100 |digit parameter }\n" |
||||
" { c|noCamera|false |without camera }\n" |
||||
" { 1| |some text|help }\n" |
||||
" { 2| |333 |another help }\n" |
||||
" };\n" |
||||
"Usage syntax: \n" |
||||
" \"{\" - start of parameter string.\n" |
||||
" \"}\" - end of parameter string\n" |
||||
" \"|\" - separator between short name, full name, default value and help\n" |
||||
"Supported syntax: \n" |
||||
" --key1=arg1 <If a key with '--' must has an argument\n" |
||||
" you have to assign it through '=' sign.> \n" |
||||
"<If the key with '--' doesn't have any argument, it means that it is a bool key>\n" |
||||
" -key2=arg2 <If a key with '-' must has an argument \n" |
||||
" you have to assign it through '=' sign.> \n" |
||||
"If the key with '-' doesn't have any argument, it means that it is a bool key\n" |
||||
" key3 <This key can't has any parameter> \n" |
||||
"Usage: \n" |
||||
" Imagine that the input parameters are next:\n" |
||||
" -s=string_value --digit=250 --noCamera lena.jpg 10000\n" |
||||
" CommandLineParser parser(argc, argv, keys) - create a parser object\n" |
||||
" parser.get<string>(\"s\" or \"string\") will return you first parameter value\n" |
||||
" parser.get<string>(\"s\", false or \"string\", false) will return you first parameter value\n" |
||||
" without spaces in end and begin\n" |
||||
" parser.get<int>(\"d\" or \"digit\") will return you second parameter value.\n" |
||||
" It also works with 'unsigned int', 'double', and 'float' types>\n" |
||||
" parser.get<bool>(\"c\" or \"noCamera\") will return you true .\n" |
||||
" If you enter this key in commandline>\n" |
||||
" It return you false otherwise.\n" |
||||
" parser.get<string>(\"1\") will return you the first argument without parameter (lena.jpg) \n" |
||||
" parser.get<int>(\"2\") will return you the second argument without parameter (10000)\n" |
||||
" It also works with 'unsigned int', 'double', and 'float' types \n" |
||||
); |
||||
} |
||||
|
||||
vector<string> split_string(const string& str, const string& delimiters) |
||||
{ |
||||
vector<string> res; |
||||
|
||||
string split_str = str; |
||||
size_t pos_delim = split_str.find(delimiters); |
||||
|
||||
while ( pos_delim != string::npos) |
||||
{ |
||||
if (pos_delim == 0) |
||||
{ |
||||
res.push_back(""); |
||||
split_str.erase(0, 1); |
||||
} |
||||
else |
||||
{ |
||||
res.push_back(split_str.substr(0, pos_delim)); |
||||
split_str.erase(0, pos_delim + 1); |
||||
} |
||||
|
||||
pos_delim = split_str.find(delimiters); |
||||
} |
||||
|
||||
res.push_back(split_str); |
||||
|
||||
return res; |
||||
} |
||||
|
||||
string del_space(string name) |
||||
{ |
||||
while ((name.find_first_of(' ') == 0) && (name.length() > 0)) |
||||
name.erase(0, 1); |
||||
|
||||
while ((name.find_last_of(' ') == (name.length() - 1)) && (name.length() > 0)) |
||||
name.erase(name.end() - 1, name.end()); |
||||
|
||||
return name; |
||||
} |
||||
|
||||
}//namespace
|
||||
|
||||
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const char* keys) |
||||
{ |
||||
std::string keys_buffer; |
||||
std::string values_buffer; |
||||
std::string buffer; |
||||
std::string curName; |
||||
std::vector<string> keysVector; |
||||
std::vector<string> paramVector; |
||||
std::map<std::string, std::vector<std::string> >::iterator it; |
||||
size_t flagPosition; |
||||
int currentIndex = 1; |
||||
//bool isFound = false;
|
||||
bool withNoKey = false; |
||||
bool hasValueThroughEq = false; |
||||
|
||||
keys_buffer = keys; |
||||
while (!keys_buffer.empty()) |
||||
{ |
||||
|
||||
flagPosition = keys_buffer.find_first_of('}'); |
||||
flagPosition++; |
||||
buffer = keys_buffer.substr(0, flagPosition); |
||||
keys_buffer.erase(0, flagPosition); |
||||
|
||||
flagPosition = buffer.find('{'); |
||||
if (flagPosition != buffer.npos) |
||||
buffer.erase(flagPosition, (flagPosition + 1)); |
||||
|
||||
flagPosition = buffer.find('}'); |
||||
if (flagPosition != buffer.npos) |
||||
buffer.erase(flagPosition); |
||||
|
||||
paramVector = split_string(buffer, "|"); |
||||
while (paramVector.size() < 4) paramVector.push_back(""); |
||||
|
||||
buffer = paramVector[0]; |
||||
buffer += '|' + paramVector[1]; |
||||
|
||||
//if (buffer == "") CV_ERROR(CV_StsBadArg, "In CommandLineParser need set short and full name");
|
||||
|
||||
paramVector.erase(paramVector.begin(), paramVector.begin() + 2); |
||||
data[buffer] = paramVector; |
||||
} |
||||
|
||||
buffer.clear(); |
||||
keys_buffer.clear(); |
||||
paramVector.clear(); |
||||
for (int i = 1; i < argc; i++) |
||||
{ |
||||
if (!argv[i]) |
||||
break; |
||||
curName = argv[i]; |
||||
if (curName.find('-') == 0 && ((curName[1] < '0') || (curName[1] > '9'))) |
||||
{ |
||||
while (curName.find('-') == 0) |
||||
curName.erase(curName.begin(), (curName.begin() + 1)); |
||||
} |
||||
else |
||||
withNoKey = true; |
||||
if (curName.find('=') != curName.npos) |
||||
{ |
||||
hasValueThroughEq = true; |
||||
buffer = curName; |
||||
curName.erase(curName.find('=')); |
||||
buffer.erase(0, (buffer.find('=') + 1)); |
||||
} |
||||
|
||||
values_buffer = del_space(values_buffer); |
||||
|
||||
for(it = data.begin(); it != data.end(); it++) |
||||
{ |
||||
keys_buffer = it->first; |
||||
keysVector = split_string(keys_buffer, "|"); |
||||
|
||||
for (size_t j = 0; j < keysVector.size(); j++) keysVector[j] = del_space(keysVector[j]); |
||||
|
||||
values_buffer = it->second[0]; |
||||
if (((curName == keysVector[0]) || (curName == keysVector[1])) && hasValueThroughEq) |
||||
{ |
||||
it->second[0] = buffer; |
||||
//isFound = true;
|
||||
break; |
||||
} |
||||
|
||||
if (!hasValueThroughEq && ((curName == keysVector[0]) || (curName == keysVector[1])) |
||||
&& ( |
||||
values_buffer.find("false") != values_buffer.npos ||
|
||||
values_buffer == "" |
||||
)) |
||||
{ |
||||
it->second[0] = "true"; |
||||
//isFound = true;
|
||||
break; |
||||
} |
||||
|
||||
if (!hasValueThroughEq && (values_buffer.find("false") == values_buffer.npos) && |
||||
((curName == keysVector[0]) || (curName == keysVector[1]))) |
||||
{ |
||||
it->second[0] = argv[++i]; |
||||
//isFound = true;
|
||||
break; |
||||
} |
||||
|
||||
|
||||
if (withNoKey) |
||||
{ |
||||
std::string noKeyStr = it->first; |
||||
if(atoi(noKeyStr.c_str()) == currentIndex) |
||||
{ |
||||
it->second[0] = curName; |
||||
currentIndex++; |
||||
//isFound = true;
|
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
withNoKey = false; |
||||
hasValueThroughEq = false; |
||||
//isFound = false;
|
||||
} |
||||
} |
||||
|
||||
bool CommandLineParser::has(const std::string& keys) |
||||
{ |
||||
std::map<std::string, std::vector<std::string> >::iterator it; |
||||
std::vector<string> keysVector; |
||||
|
||||
for(it = data.begin(); it != data.end(); it++) |
||||
{ |
||||
keysVector = split_string(it->first, "|"); |
||||
for (size_t i = 0; i < keysVector.size(); i++) keysVector[i] = del_space(keysVector[i]); |
||||
|
||||
if (keysVector.size() == 1) keysVector.push_back(""); |
||||
|
||||
if ((del_space(keys).compare(keysVector[0]) == 0) ||
|
||||
(del_space(keys).compare(keysVector[1]) == 0)) |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
std::string CommandLineParser::getString(const std::string& keys) |
||||
{ |
||||
std::map<std::string, std::vector<std::string> >::iterator it; |
||||
std::vector<string> valueVector; |
||||
|
||||
for(it = data.begin(); it != data.end(); it++) |
||||
{ |
||||
valueVector = split_string(it->first, "|"); |
||||
for (size_t i = 0; i < valueVector.size(); i++) valueVector[i] = del_space(valueVector[i]); |
||||
|
||||
if (valueVector.size() == 1) valueVector.push_back(""); |
||||
|
||||
if ((del_space(keys).compare(valueVector[0]) == 0) ||
|
||||
(del_space(keys).compare(valueVector[1]) == 0)) |
||||
return it->second[0]; |
||||
} |
||||
return string(); |
||||
} |
||||
|
||||
template<typename _Tp> |
||||
_Tp CommandLineParser::fromStringNumber(const std::string& str)//the default conversion function for numbers
|
||||
{ |
||||
return getData<_Tp>(str); |
||||
} |
||||
|
||||
void CommandLineParser::printParams() |
||||
{ |
||||
int col_p = 30; |
||||
int col_d = 50; |
||||
|
||||
std::map<std::string, std::vector<std::string> >::iterator it; |
||||
std::vector<string> keysVector; |
||||
std::string buf; |
||||
for(it = data.begin(); it != data.end(); it++) |
||||
{ |
||||
keysVector = split_string(it->first, "|"); |
||||
for (size_t i = 0; i < keysVector.size(); i++) keysVector[i] = del_space(keysVector[i]); |
||||
|
||||
cout << " "; |
||||
buf = ""; |
||||
if (keysVector[0] != "") |
||||
{ |
||||
buf = "-" + keysVector[0]; |
||||
if (keysVector[1] != "") buf += ", --" + keysVector[1]; |
||||
} |
||||
else if (keysVector[1] != "") buf += "--" + keysVector[1]; |
||||
if (del_space(it->second[0]) != "") buf += "=[" + del_space(it->second[0]) + "]"; |
||||
|
||||
cout << setw(col_p-2) << left << buf; |
||||
|
||||
if ((int)buf.length() > col_p-2)
|
||||
{ |
||||
cout << endl << " "; |
||||
cout << setw(col_p-2) << left << " "; |
||||
} |
||||
|
||||
buf = ""; |
||||
if (del_space(it->second[1]) != "") buf += del_space(it->second[1]); |
||||
|
||||
for(;;) |
||||
{ |
||||
bool tr = ((int)buf.length() > col_d-2) ? true: false; |
||||
std::string::size_type pos = 0; |
||||
|
||||
if (tr) |
||||
{ |
||||
pos = buf.find_first_of(' '); |
||||
for(;;) |
||||
{ |
||||
if (buf.find_first_of(' ', pos + 1 ) < (std::string::size_type)(col_d-2) && |
||||
buf.find_first_of(' ', pos + 1 ) != std::string::npos) |
||||
pos = buf.find_first_of(' ', pos + 1); |
||||
else |
||||
break; |
||||
} |
||||
pos++; |
||||
cout << setw(col_d-2) << left << buf.substr(0, pos) << endl; |
||||
} |
||||
else |
||||
{ |
||||
cout << setw(col_d-2) << left << buf<< endl; |
||||
break; |
||||
} |
||||
|
||||
buf.erase(0, pos); |
||||
cout << " "; |
||||
cout << setw(col_p-2) << left << " "; |
||||
} |
||||
} |
||||
} |
||||
|
||||
template<> |
||||
bool CommandLineParser::get<bool>(const std::string& name, bool space_delete) |
||||
{ |
||||
std::string str_buf = getString(name); |
||||
|
||||
if (space_delete && str_buf != "") |
||||
{ |
||||
str_buf = del_space(str_buf); |
||||
} |
||||
|
||||
if (str_buf == "true") |
||||
return true; |
||||
|
||||
return false; |
||||
} |
||||
template<> |
||||
std::string CommandLineParser::analyzeValue<std::string>(const std::string& str, bool space_delete) |
||||
{ |
||||
if (space_delete) |
||||
{ |
||||
return del_space(str); |
||||
}
|
||||
return str; |
||||
} |
||||
|
||||
template<> |
||||
int CommandLineParser::analyzeValue<int>(const std::string& str, bool /*space_delete*/) |
||||
{ |
||||
return fromStringNumber<int>(str); |
||||
} |
||||
|
||||
template<> |
||||
unsigned int CommandLineParser::analyzeValue<unsigned int>(const std::string& str, bool /*space_delete*/) |
||||
{ |
||||
return fromStringNumber<unsigned int>(str); |
||||
} |
||||
|
||||
template<> |
||||
uint64 CommandLineParser::analyzeValue<uint64>(const std::string& str, bool /*space_delete*/) |
||||
{ |
||||
return fromStringNumber<uint64>(str); |
||||
} |
||||
|
||||
template<> |
||||
float CommandLineParser::analyzeValue<float>(const std::string& str, bool /*space_delete*/) |
||||
{ |
||||
return fromStringNumber<float>(str); |
||||
} |
||||
|
||||
template<> |
||||
double CommandLineParser::analyzeValue<double>(const std::string& str, bool /*space_delete*/) |
||||
{ |
||||
return fromStringNumber<double>(str); |
||||
} |
||||
@ -1,540 +0,0 @@ |
||||
|
||||
#include "precomp.hpp" |
||||
|
||||
#include <iostream> |
||||
|
||||
namespace cv |
||||
{ |
||||
|
||||
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; |
||||
|
||||
Impl() { refcount = 1; } |
||||
Impl(int argc, const char* const argv[], const char* keys); |
||||
|
||||
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 trim_spaces(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; |
||||
else |
||||
throw cv::Exception(CV_StsBadArg, "unknown/unsupported parameter type", "", __FILE__, __LINE__); |
||||
|
||||
if (ss.fail()) |
||||
{ |
||||
string err_msg = "can not convert: [" + str + |
||||
+ "] to [" + get_type_name(type) + "]"; |
||||
|
||||
throw cv::Exception(CV_StsBadArg, err_msg, "", __FILE__, __LINE__); |
||||
} |
||||
} |
||||
|
||||
string CommandLineParser::getString(const string& name) |
||||
{ |
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
||||
{ |
||||
if (name.compare(impl->data[i].keys[j]) == 0) |
||||
{ |
||||
string v = impl->data[i].def_value; |
||||
return v; |
||||
} |
||||
} |
||||
} |
||||
return string(); |
||||
} |
||||
|
||||
void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const |
||||
{ |
||||
try |
||||
{ |
||||
string v = ((CommandLineParser*)this)->getString(name); |
||||
if( v.empty() ) |
||||
{ |
||||
impl->error = true; |
||||
impl->error_message += "Unknown parametes " + name + "\n"; |
||||
} |
||||
else |
||||
{ |
||||
if (space_delete) |
||||
v = impl->trim_spaces(v); |
||||
from_str(v, type, dst); |
||||
return; |
||||
} |
||||
} |
||||
catch (std::exception& e) |
||||
{ |
||||
impl->error = true; |
||||
impl->error_message += "Exception: " + string(e.what()) + "\n"; |
||||
} |
||||
} |
||||
|
||||
|
||||
void CommandLineParser::getByIndex(int index, bool space_delete, int type, void* dst) const |
||||
{ |
||||
try |
||||
{ |
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
if (impl->data[i].number == index) |
||||
{ |
||||
string v = impl->data[i].def_value; |
||||
if (space_delete == true) v = impl->trim_spaces(v); |
||||
from_str(v, type, dst); |
||||
return; |
||||
} |
||||
} |
||||
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) |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const string& keys) |
||||
{ |
||||
impl = new Impl(argc, argv, keys.c_str()); |
||||
} |
||||
|
||||
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const char* keys) |
||||
{ |
||||
impl = new Impl(argc, argv, keys); |
||||
} |
||||
|
||||
CommandLineParser::Impl::Impl(int argc, const char* const argv[], const char* keys) |
||||
{ |
||||
refcount = 1; |
||||
|
||||
// path to application
|
||||
size_t pos_s = string(argv[0]).find_last_of("/\\"); |
||||
if (pos_s == string::npos) |
||||
{ |
||||
path_to_app = ""; |
||||
app_name = string(argv[0]); |
||||
} |
||||
else |
||||
{ |
||||
path_to_app = string(argv[0]).substr(0, pos_s); |
||||
app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s); |
||||
} |
||||
|
||||
error = false; |
||||
error_message = ""; |
||||
|
||||
// parse keys
|
||||
vector<string> k = split_range_string(keys, '{', '}'); |
||||
|
||||
int jj = 0; |
||||
for (size_t i = 0; i < k.size(); i++) |
||||
{ |
||||
vector<string> l = split_string(k[i], '|', true); |
||||
CommandLineParserParams p; |
||||
p.keys = split_string(l[0]); |
||||
p.def_value = l[1]; |
||||
p.help_message = trim_spaces(l[2]); |
||||
p.number = -1; |
||||
if (p.keys[0][0] == '@') |
||||
{ |
||||
p.number = jj; |
||||
jj++; |
||||
} |
||||
|
||||
data.push_back(p); |
||||
} |
||||
|
||||
// parse argv
|
||||
jj = 0; |
||||
for (int i = 1; i < argc; i++) |
||||
{ |
||||
string s = string(argv[i]); |
||||
|
||||
if (s.find('=') != string::npos && s.find('=') < s.length()) |
||||
{ |
||||
vector<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++; |
||||
} |
||||
} |
||||
|
||||
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; |
||||
} |
||||
|
||||
void CommandLineParser::Impl::apply_params(const string& key, const string& value) |
||||
{ |
||||
for (size_t i = 0; i < data.size(); i++) |
||||
{ |
||||
for (size_t k = 0; k < data[i].keys.size(); k++) |
||||
{ |
||||
if (key.compare(data[i].keys[k]) == 0) |
||||
{ |
||||
data[i].def_value = value; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
void CommandLineParser::Impl::apply_params(int i, string value) |
||||
{ |
||||
for (size_t j = 0; j < data.size(); j++) |
||||
{ |
||||
if (data[j].number == i) |
||||
{ |
||||
data[j].def_value = value; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void CommandLineParser::Impl::sort_params() |
||||
{ |
||||
for (size_t i = 0; i < data.size(); i++) |
||||
{ |
||||
sort(data[i].keys.begin(), data[i].keys.end()); |
||||
} |
||||
|
||||
sort (data.begin(), data.end(), cmp_params); |
||||
} |
||||
|
||||
string CommandLineParser::Impl::trim_spaces(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) |
||||
{ |
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
||||
{ |
||||
if (name.compare(impl->data[i].keys[j]) == 0 && string("true").compare(impl->data[i].def_value) == 0) |
||||
{ |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool CommandLineParser::check() const |
||||
{ |
||||
return impl->error == false; |
||||
} |
||||
|
||||
void CommandLineParser::printErrors() const |
||||
{ |
||||
if (impl->error) |
||||
{ |
||||
std::cout << std::endl << "ERRORS:" << std::endl << impl->error_message << std::endl; |
||||
} |
||||
} |
||||
|
||||
void CommandLineParser::printParams() |
||||
{ |
||||
printMessage(); |
||||
} |
||||
|
||||
void CommandLineParser::printMessage() const |
||||
{ |
||||
if (impl->about_message != "") |
||||
std::cout << impl->about_message << std::endl; |
||||
|
||||
std::cout << "Usage: " << impl->app_name << " [params] "; |
||||
|
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
if (impl->data[i].number > -1) |
||||
{ |
||||
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; |
||||
|
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
if (impl->data[i].number == -1) |
||||
{ |
||||
std::cout << "\t"; |
||||
for (size_t j = 0; j < impl->data[i].keys.size(); j++) |
||||
{ |
||||
string k = impl->data[i].keys[j]; |
||||
if (k.length() > 1) |
||||
{ |
||||
std::cout << "--"; |
||||
} |
||||
else |
||||
{ |
||||
std::cout << "-"; |
||||
} |
||||
std::cout << k; |
||||
|
||||
if (j != impl->data[i].keys.size() - 1) |
||||
{ |
||||
std::cout << ", "; |
||||
} |
||||
} |
||||
string dv = impl->trim_spaces(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; |
||||
|
||||
for (size_t i = 0; i < impl->data.size(); i++) |
||||
{ |
||||
if (impl->data[i].number != -1) |
||||
{ |
||||
std::cout << "\t"; |
||||
string k = impl->data[i].keys[0]; |
||||
k = k.substr(1, k.length() - 1); |
||||
|
||||
std::cout << k; |
||||
|
||||
string dv = impl->trim_spaces(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; |
||||
} |
||||
} |
||||
} |
||||
|
||||
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) |
||||
{ |
||||
throw cv::Exception(CV_StsParseError, |
||||
string("error in split_range_string(") |
||||
+ str |
||||
+ string(", ") |
||||
+ string(1, fs) |
||||
+ string(", ") |
||||
+ string(1, ss) |
||||
+ string(")"), |
||||
"", __FILE__, __LINE__ |
||||
); |
||||
} |
||||
begin = true; |
||||
word = ""; |
||||
str = str.substr(1, str.length() - 1); |
||||
} |
||||
|
||||
if (str[0] == ss) |
||||
{ |
||||
if (begin == false) |
||||
{ |
||||
throw cv::Exception(CV_StsParseError, |
||||
string("error in split_range_string(") |
||||
+ str |
||||
+ string(", ") |
||||
+ string(1, fs) |
||||
+ string(", ") |
||||
+ string(1, ss) |
||||
+ string(")"), |
||||
"", __FILE__, __LINE__ |
||||
); |
||||
} |
||||
begin = false; |
||||
vec.push_back(word); |
||||
} |
||||
|
||||
if (begin == true) |
||||
{ |
||||
word += str[0]; |
||||
} |
||||
str = str.substr(1, str.length() - 1); |
||||
} |
||||
|
||||
if (begin == true) |
||||
{ |
||||
throw cv::Exception(CV_StsParseError, |
||||
string("error in split_range_string(") |
||||
+ str |
||||
+ string(", ") |
||||
+ string(1, fs) |
||||
+ string(", ") |
||||
+ string(1, ss) |
||||
+ string(")"), |
||||
"", __FILE__, __LINE__ |
||||
); |
||||
} |
||||
|
||||
return vec; |
||||
} |
||||
|
||||
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 (!word.empty() || create_empty_item) |
||||
{ |
||||
vec.push_back(word); |
||||
word = ""; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
word += str[0]; |
||||
} |
||||
str = str.substr(1, str.length() - 1); |
||||
} |
||||
|
||||
if (word != "" || create_empty_item) |
||||
{ |
||||
vec.push_back(word); |
||||
} |
||||
|
||||
return vec; |
||||
} |
||||
|
||||
} |
||||
Loading…
Reference in new issue