|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Tools
|
|
// 24.IV.2010 ??????
|
|
// <cTools.h>
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "cTools.h"
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Trim Left String - deletes spaces from the left
|
|
string NFuncConverter::TrimLeft(string str)
|
|
{
|
|
::setlocale(LC_ALL, ""); // Includes locale settings for UNICODE conversion
|
|
bool isZero = false;
|
|
unsigned i;
|
|
string newStr("");
|
|
for (i=0; i<str.size(); i++)
|
|
if ( (!isZero) && (str.substr(i,1).compare(" ") == 0) )
|
|
isZero = false;
|
|
else
|
|
{
|
|
isZero = true;
|
|
newStr+= str.substr(i,1);
|
|
}
|
|
if (!isZero)
|
|
newStr.empty();
|
|
return newStr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Trim Right String - deletes spaces on the right
|
|
string NFuncConverter::TrimRight(string str)
|
|
{
|
|
::setlocale(LC_ALL, ""); // Includes locale settings for UNICODE conversion
|
|
bool isZero = false;
|
|
unsigned i;
|
|
string newStr("");
|
|
for (i=str.size(); i>0; i--)
|
|
if ( (!isZero) && (str.substr(i-1,1).compare(" ") == 0) )
|
|
{
|
|
isZero = false;
|
|
newStr = str.erase(i-1,1);
|
|
}
|
|
else
|
|
isZero = true;
|
|
// if (!isZero)
|
|
// newStr.empty();
|
|
|
|
return newStr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Trim String - deletes spaces from both ends
|
|
string NFuncConverter::Trim(string str)
|
|
{
|
|
::setlocale(LC_ALL, ""); // Includes locale settings for UNICODE conversion
|
|
bool isZero = false;
|
|
unsigned i;
|
|
string newStr("");
|
|
for (i=0; i<str.size(); i++)
|
|
if ( (!isZero) && (str.substr(i,1).compare(" ") == 0) )
|
|
isZero = false;
|
|
else
|
|
{
|
|
isZero = true;
|
|
newStr+= str.substr(i,1);
|
|
}
|
|
if (!isZero)
|
|
return "";
|
|
isZero = false;
|
|
str = newStr;
|
|
for (i=str.size(); i>0; i--)
|
|
if ( (!isZero) && (str.substr(i-1,1).compare(" ") == 0) )
|
|
{
|
|
isZero = false;
|
|
newStr = str.erase(i-1,1);
|
|
}
|
|
else
|
|
isZero = true;
|
|
|
|
return newStr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Trim WString - deletes spaces from both ends
|
|
wstring NFuncConverter::Trim(wstring str)
|
|
{
|
|
bool isZero = false;
|
|
unsigned i;
|
|
wstring newStr(L"");
|
|
for (i=0; i<str.size(); i++)
|
|
if ( (!isZero) && (str.substr(i,1).compare(L" ") == 0) )
|
|
isZero = false;
|
|
else
|
|
{
|
|
isZero = true;
|
|
newStr+= str.substr(i,1);
|
|
}
|
|
if (!isZero)
|
|
return L"";
|
|
isZero = false;
|
|
str = newStr;
|
|
for (i=str.size(); i>0; i--)
|
|
if ( (!isZero) && (str.substr(i-1,1).compare(L" ") == 0) )
|
|
{
|
|
isZero = false;
|
|
newStr = str.erase(i-1,1);
|
|
}
|
|
else
|
|
isZero = true;
|
|
|
|
return newStr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Trim Left zero - deletes leading zeros
|
|
string NFuncConverter::TrimLeftZero(string str) // Trim zero from left of string 000123456
|
|
{
|
|
::setlocale(LC_ALL, ""); // Includes locale settings for UNICODE conversion
|
|
bool isZero = false;
|
|
unsigned i;
|
|
string newStr("");
|
|
for (i=0; i<str.size(); i++)
|
|
if ( (!isZero) && (str.substr(i,1).compare("0") == 0) )
|
|
isZero = false;
|
|
else
|
|
{
|
|
isZero = true;
|
|
newStr+= str.substr(i,1);
|
|
}
|
|
if (!isZero)
|
|
newStr = "";
|
|
return newStr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Tokenize string - ",,aa,bb,,,cc,," -> "aa","bb","cc"
|
|
bool NFuncConverter::Tokenize(const string str, vector<string> &tokens, const string delimiters)
|
|
{
|
|
// Skip delimiters at beginning.
|
|
string::size_type lastPos = str.find_first_not_of(delimiters, 0);
|
|
// Find first "non-delimiter".
|
|
string::size_type pos = str.find_first_of(delimiters, lastPos);
|
|
|
|
tokens.clear();
|
|
|
|
while (string::npos != pos || string::npos != lastPos)
|
|
{
|
|
// Found a token, add it to the vector.
|
|
tokens.push_back(str.substr(lastPos, pos - lastPos));
|
|
// Skip delimiters. Note the "not_of"
|
|
lastPos = str.find_first_not_of(delimiters, pos);
|
|
// Find next "non-delimiter"
|
|
pos = str.find_first_of(delimiters, lastPos);
|
|
}
|
|
return true;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Tokenize string - ",,aa,bb,,,cc,," -> "","","aa","","","cc",""
|
|
bool NFuncConverter::TokenizeNull(const string str, vector<string> &tokens, const string delimiters)
|
|
{
|
|
// Skip delimiters at beginning.
|
|
size_t lastPos = str.find_first_not_of(delimiters, 0);
|
|
// Find first "non-delimiter".
|
|
size_t pos = str.find_first_of(delimiters, 0);
|
|
tokens.clear();
|
|
while (std::string::npos != pos || std::string::npos != lastPos)
|
|
{
|
|
if(pos<lastPos)
|
|
{
|
|
tokens.push_back("");
|
|
}
|
|
else
|
|
{
|
|
tokens.push_back(str.substr(lastPos, pos - lastPos));
|
|
lastPos = str.find_first_not_of(delimiters, pos);
|
|
}
|
|
if(std::string::npos != pos)
|
|
pos = str.find_first_of(delimiters, pos+1);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Double precision real number to string
|
|
string NFuncConverter::ToString(double val, unsigned short width, unsigned short precision)
|
|
{
|
|
std::stringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
if (precision != NULL)
|
|
strm.precision(precision);
|
|
strm<<fixed;
|
|
strm<<val;
|
|
return strm.str();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Real number to string
|
|
string NFuncConverter::ToString(float val, unsigned short width, unsigned short precision)
|
|
{
|
|
std::stringstream strm;
|
|
if (precision != NULL)
|
|
strm.precision(precision);
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm<<fixed;
|
|
strm<<val;
|
|
return strm.str();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Integer to fixed-length string
|
|
string NFuncConverter::ToString(long val, unsigned short width)
|
|
{
|
|
std::stringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Integer to fixed-length string
|
|
string NFuncConverter::ToString(int val, unsigned short width)
|
|
{
|
|
std::stringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Double precision real number to wide string
|
|
wstring NFuncConverter::ToWString(double val, unsigned short width, unsigned short precision)
|
|
{
|
|
std::wstringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
if (precision != NULL)
|
|
strm.precision(precision);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Real number to wide string
|
|
wstring NFuncConverter::ToWString(float val, unsigned short width, unsigned short precision)
|
|
{
|
|
std::wstringstream strm;
|
|
if (precision != NULL)
|
|
strm.precision(precision);
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Integer to fixed-length string
|
|
wstring NFuncConverter::ToWString(long val, unsigned short width)
|
|
{
|
|
std::wstringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Integer to fixed-length string
|
|
wstring NFuncConverter::ToWString(int val, unsigned short width)
|
|
{
|
|
std::wstringstream strm;
|
|
if (width != NULL)
|
|
strm.width(width);
|
|
strm << fixed;
|
|
strm << val;
|
|
return strm.str();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Checks whether a file with the specified name and path exists.
|
|
bool FileExist(LPCTSTR szFileName ) //Checking if the file exists
|
|
{
|
|
ifstream ifile(szFileName);
|
|
return ((ifile)?true:false);
|
|
/* CFileStatus status; // GetStatus returns 0 if the specified file does not exist
|
|
if (CFile::GetStatus( szFileName, status ) == 0)
|
|
return false;
|
|
return true; */
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// ASSISTANT Procedure & Function
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Convert string to wstring
|
|
wstring NFuncConverter::SToWString(string str) // Convert string to wstring
|
|
{
|
|
// std::string -> std::wstring
|
|
std::wstring wstr;
|
|
wstr.assign(str.begin(), str.end());
|
|
return wstr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Convert WString To String
|
|
string NFuncConverter::WToString(wstring wstr) // Convert wstring to string
|
|
{
|
|
// std::string -> std::wstring
|
|
std::string str;
|
|
str.assign(wstr.begin(), wstr.end());
|
|
return str;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// End Of Line
|
|
char NFuncConverter::eoln(fstream &stream) // C++ code Return End of Line
|
|
{
|
|
if (stream.eof()) return 1; // True end of file
|
|
long curpos; char ch;
|
|
curpos = stream.tellp(); // Get current position
|
|
while (!stream.eof())
|
|
{
|
|
stream.get(ch); // Get next char
|
|
if ((int)ch != 32 ) // Skips spaces (ASCII code 32) or ASCII code 255?
|
|
break;
|
|
curpos = stream.tellp(); // Get current position
|
|
}
|
|
stream.clear(); // Fix bug in VC 6.0
|
|
stream.seekp(curpos); // Return to prev position
|
|
if ((int)ch != 10) // if (ch) eq 10
|
|
return 0; // False not end of row (line)
|
|
else // (if have spaces?)
|
|
stream.get(ch); // Go to next row
|
|
return 1; // True end of row (line)
|
|
} // End function
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// UTF-8 encoding adds markers to each bytes
|
|
// and so it?s possible to write a reliable algorithm
|
|
// to check if a byte string is encoded to UTF-8.
|
|
char NFuncConverter::isUTF8(const char* data, size_t size)
|
|
{
|
|
const unsigned char* str = (unsigned char*)data;
|
|
const unsigned char* end = str + size;
|
|
unsigned char byte;
|
|
unsigned int code_length, i;
|
|
uint32_t ch;
|
|
while (str != end) {
|
|
byte = *str;
|
|
if (byte <= 0x7F) {
|
|
/* 1 byte sequence: U+0000..U+007F */
|
|
str += 1;
|
|
continue;
|
|
}
|
|
|
|
if (0xC2 <= byte && byte <= 0xDF)
|
|
/* 0b110xxxxx: 2 bytes sequence */
|
|
code_length = 2;
|
|
else if (0xE0 <= byte && byte <= 0xEF)
|
|
/* 0b1110xxxx: 3 bytes sequence */
|
|
code_length = 3;
|
|
else if (0xF0 <= byte && byte <= 0xF4)
|
|
/* 0b11110xxx: 4 bytes sequence */
|
|
code_length = 4;
|
|
else {
|
|
/* invalid first byte of a multibyte character */
|
|
return 0;
|
|
}
|
|
|
|
if (str + (code_length - 1) >= end) {
|
|
/* truncated string or invalid byte sequence */
|
|
return 0;
|
|
}
|
|
|
|
/* Check continuation bytes: bit 7 should be set, bit 6 should be
|
|
* unset (b10xxxxxx). */
|
|
for (i = 1; i < code_length; i++) {
|
|
if ((str[i] & 0xC0) != 0x80)
|
|
return 0;
|
|
}
|
|
|
|
if (code_length == 2) {
|
|
/* 2 bytes sequence: U+0080..U+07FF */
|
|
ch = ((str[0] & 0x1f) << 6) + (str[1] & 0x3f);
|
|
/* str[0] >= 0xC2, so ch >= 0x0080.
|
|
str[0] <= 0xDF, (str[1] & 0x3f) <= 0x3f, so ch <= 0x07ff */
|
|
}
|
|
else if (code_length == 3) {
|
|
/* 3 bytes sequence: U+0800..U+FFFF */
|
|
ch = ((str[0] & 0x0f) << 12) + ((str[1] & 0x3f) << 6) +
|
|
(str[2] & 0x3f);
|
|
/* (0xff & 0x0f) << 12 | (0xff & 0x3f) << 6 | (0xff & 0x3f) = 0xffff,
|
|
so ch <= 0xffff */
|
|
if (ch < 0x0800)
|
|
return 0;
|
|
|
|
/* surrogates (U+D800-U+DFFF) are invalid in UTF-8:
|
|
test if (0xD800 <= ch && ch <= 0xDFFF) */
|
|
if ((ch >> 11) == 0x1b)
|
|
return 0;
|
|
}
|
|
else if (code_length == 4) {
|
|
/* 4 bytes sequence: U+10000..U+10FFFF */
|
|
ch = ((str[0] & 0x07) << 18) + ((str[1] & 0x3f) << 12) +
|
|
((str[2] & 0x3f) << 6) + (str[3] & 0x3f);
|
|
if ((ch < 0x10000) || (0x10FFFF < ch))
|
|
return 0;
|
|
}
|
|
str += code_length;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// UTF to ANSI
|
|
string NFuncConverter::UTF8ToANSI(string s) // UTF to ANSI
|
|
{
|
|
BSTR bstrWide;
|
|
char* pszAnsi;
|
|
int nLength;
|
|
const char* pszCode = s.c_str();
|
|
|
|
nLength = MultiByteToWideChar(CP_UTF8, 0, pszCode, strlen(pszCode) + 1, NULL, NULL);
|
|
bstrWide = SysAllocStringLen(NULL, nLength);
|
|
|
|
MultiByteToWideChar(CP_UTF8, 0, pszCode, strlen(pszCode) + 1, bstrWide, nLength);
|
|
|
|
nLength = WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, NULL, 0, NULL, NULL);
|
|
pszAnsi = new char[nLength];
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, pszAnsi, nLength, NULL, NULL);
|
|
SysFreeString(bstrWide);
|
|
|
|
string r(pszAnsi);
|
|
// delete pszAnsi;
|
|
// delete pszCode;
|
|
//AfxMessageBox(L"delete bull");
|
|
return r;
|
|
}
|