CodeTempla
984 lines
19 KiB
C++
984 lines
19 KiB
C++
|
|
#ifndef STRING__H_
|
|
#define STRING__H_
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <algorithm>
|
|
|
|
#ifndef _WIN32
|
|
#include <iconv.h>
|
|
#endif
|
|
|
|
|
|
|
|
|
|
class HString : public std::string
|
|
{
|
|
public:
|
|
static int ReadOneLine(HString * pstrDst, const char * pszSrc, int nStartOffset)
|
|
{
|
|
const char * p = pszSrc + nStartOffset;
|
|
|
|
int i, nResult = -1;
|
|
for (i = 0; *p != '\0' ; i++)
|
|
{
|
|
if (*p == '\r')
|
|
{
|
|
nResult = nStartOffset + i + 1;
|
|
if (*(p + 1) == '\n')
|
|
nResult++;
|
|
|
|
pstrDst->Assign(pszSrc + nStartOffset, i);
|
|
break;
|
|
}
|
|
else if (*p == '\n')
|
|
{
|
|
nResult = nStartOffset + i + 1;
|
|
pstrDst->Assign(pszSrc + nStartOffset, i);
|
|
break;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
if (nResult == -1 && i > 0)
|
|
{
|
|
nResult = nStartOffset + i;
|
|
pstrDst->Assign(pszSrc + nStartOffset, i);
|
|
}
|
|
|
|
return nResult;
|
|
}
|
|
|
|
public:
|
|
HString() {}
|
|
HString(char ch) { operator=(ch); }
|
|
//HString(const char * psz) : std::string(psz) {}
|
|
HString(const char * psz) { if (psz) std::string::operator=(psz); }
|
|
HString(const char * p, size_t nSize) : std::string(p, nSize) {}
|
|
HString(const std::string & str) : std::string(str) {}
|
|
|
|
HString(short num) { operator=(num); } //??? HString * pstr = NULL; pstr ? *pstr : NULL
|
|
HString(unsigned short num) { operator=(num); }
|
|
HString(int num) { operator=(num); }
|
|
HString(unsigned int num) { operator=(num); }
|
|
HString(long num) { operator=(num); }
|
|
HString(unsigned long num) { operator=(num); }
|
|
HString(float num) { operator=(num); }
|
|
HString(double num) { operator=(num); }
|
|
#ifdef _WIN32
|
|
HString(time_t num) { operator=(num); }
|
|
#endif
|
|
~HString() {}
|
|
|
|
inline std::string & operator=(char ch)
|
|
{
|
|
return std::string::operator=(ch);
|
|
}
|
|
|
|
inline std::string & operator=(const char * psz)
|
|
{
|
|
if (psz)
|
|
return std::string::operator=(psz);
|
|
|
|
return std::string::operator=("");
|
|
}
|
|
|
|
inline std::string & operator=(short num) //...
|
|
{
|
|
char szBuf[16]; sprintf(szBuf, "%d", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(unsigned short num) //...
|
|
{
|
|
char szBuf[16]; sprintf(szBuf, "%hd", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(int num) //...
|
|
{
|
|
char szBuf[32]; sprintf(szBuf, "%d", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(unsigned int num) //...
|
|
{
|
|
char szBuf[32]; sprintf(szBuf, "%u", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(long num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%ld", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(unsigned long num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lu", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(float num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%f", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
inline std::string & operator=(double num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lf", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
inline std::string & operator=(time_t num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lld", num);
|
|
return std::string::operator=(szBuf);
|
|
}
|
|
#endif
|
|
|
|
inline std::string & operator+=(char ch)
|
|
{
|
|
return std::string::operator+=(ch);
|
|
}
|
|
|
|
inline std::string & operator+=(const char * psz)
|
|
{
|
|
if (psz == NULL)
|
|
return *this;
|
|
|
|
return std::string::operator+=(psz);
|
|
}
|
|
|
|
inline std::string & operator+=(const std::string & str)
|
|
{
|
|
return std::string::operator+=(str);
|
|
}
|
|
|
|
inline std::string & operator+=(short num) //...
|
|
{
|
|
char szBuf[16]; sprintf(szBuf, "%d", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(unsigned short num) //...
|
|
{
|
|
char szBuf[16]; sprintf(szBuf, "%hd", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(int num) //...
|
|
{
|
|
char szBuf[32]; sprintf(szBuf, "%d", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(unsigned int num) //...
|
|
{
|
|
char szBuf[32]; sprintf(szBuf, "%u", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(long num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%ld", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(unsigned long num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lu", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(float num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%f", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
inline std::string & operator+=(double num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lf", num);
|
|
return append(szBuf);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
inline std::string & operator+=(time_t num) //...
|
|
{
|
|
char szBuf[64]; sprintf(szBuf, "%lld", num);
|
|
return append(szBuf);
|
|
}
|
|
#endif
|
|
|
|
inline operator const char *() const
|
|
{
|
|
return c_str();
|
|
}
|
|
|
|
inline operator short() const
|
|
{
|
|
return atoi(c_str());
|
|
}
|
|
|
|
inline operator unsigned short() const
|
|
{
|
|
return atoi(c_str());
|
|
}
|
|
|
|
inline operator int() const
|
|
{
|
|
return atoi(c_str());
|
|
}
|
|
|
|
inline operator unsigned int() const
|
|
{
|
|
return atoi(c_str());
|
|
}
|
|
|
|
inline operator long() const
|
|
{
|
|
return atol(c_str());
|
|
}
|
|
|
|
inline operator unsigned long() const
|
|
{
|
|
return atol(c_str());
|
|
}
|
|
|
|
inline const char * psz() const
|
|
{
|
|
return c_str();
|
|
}
|
|
|
|
inline size_t GetLength() const
|
|
{
|
|
return length();
|
|
}
|
|
|
|
inline bool IsEmpty() const
|
|
{
|
|
return empty();
|
|
}
|
|
|
|
inline void Reserve(size_t nSize)
|
|
{
|
|
reserve(nSize);
|
|
}
|
|
|
|
inline std::string & Assign(const char * psz, size_t nOffset)
|
|
{
|
|
return assign(psz, nOffset);
|
|
}
|
|
|
|
inline size_t Copy(char * psz, size_t len, size_t pos = 0) const
|
|
{
|
|
return copy(psz, len, pos);
|
|
}
|
|
|
|
inline HString SubStr(const size_t pos, size_t len) const
|
|
{
|
|
return substr(pos, len);
|
|
}
|
|
|
|
inline int StrNCmp(const char * psz, unsigned int nCount)
|
|
{
|
|
return ::strncmp(c_str(), psz, nCount);
|
|
}
|
|
|
|
inline int StrNICmp(const char * psz, unsigned int nCount)
|
|
{
|
|
return ::strnicmp(c_str(), psz, nCount);
|
|
}
|
|
|
|
inline const char * StrNStr(const char * psz, int nCount = -1) const
|
|
{
|
|
return ::StrNStr(c_str(), psz, nCount);
|
|
}
|
|
|
|
inline const char * StrNIStr(const char * psz, int nCount = -1) const
|
|
{
|
|
return ::StrNIStr(c_str(), psz, nCount);
|
|
}
|
|
|
|
inline const char * ToUpper()
|
|
{
|
|
char * pszDst = (char *)malloc(GetLength() + 1);
|
|
char * pszOffset = pszDst;
|
|
const char * pszSrc = psz();
|
|
|
|
while (*pszSrc)
|
|
{
|
|
*pszOffset++ = toupper(*pszSrc++);
|
|
}
|
|
*pszOffset = '\0';
|
|
|
|
std::string::operator=(pszDst);
|
|
free(pszDst);
|
|
|
|
return c_str();
|
|
}
|
|
|
|
inline const char * ToLower()
|
|
{
|
|
char * pszDst = (char *)malloc(GetLength() + 1);
|
|
char * pszOffset = pszDst;
|
|
const char * pszSrc = psz();
|
|
|
|
while (*pszSrc)
|
|
{
|
|
*pszOffset++ = tolower(*pszSrc++);
|
|
}
|
|
*pszOffset = '\0';
|
|
|
|
std::string::operator=(pszDst);
|
|
free(pszDst);
|
|
|
|
return c_str();
|
|
}
|
|
|
|
inline int CompareNoCase(const char * p) const
|
|
{
|
|
return stricmp(psz(), p);
|
|
}
|
|
|
|
inline char GetLast() const
|
|
{
|
|
if (empty())
|
|
return -1;
|
|
|
|
return psz()[GetLength() - 1];
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
#pragma warning(disable:4267)
|
|
#endif
|
|
inline long Find(const HString & str, size_t pos = 0) const
|
|
{
|
|
size_t nResult = find(str, pos);
|
|
if (nResult == std::string::npos)
|
|
return -1;
|
|
return nResult;
|
|
}
|
|
|
|
inline long Find(const char * psz, size_t pos = 0) const
|
|
{
|
|
size_t nResult = find(psz, pos);
|
|
if (nResult == std::string::npos)
|
|
return -1;
|
|
return nResult;
|
|
}
|
|
|
|
inline long Find(const char * psz, size_t pos, size_t n) const
|
|
{
|
|
size_t nResult = find(psz, pos, n);
|
|
if (nResult == std::string::npos)
|
|
return -1;
|
|
return nResult;
|
|
}
|
|
|
|
inline long Find(char c, size_t pos = 0) const
|
|
{
|
|
size_t nResult = find(c, pos);
|
|
if (nResult == std::string::npos)
|
|
return -1;
|
|
return nResult;
|
|
}
|
|
#ifdef _WIN32
|
|
#pragma warning(default:4267)
|
|
#endif
|
|
|
|
void Trim(bool bRemoveFront, bool bRemoveRear)
|
|
{
|
|
char * pszBuffer = (char *)malloc(GetLength() + 1);
|
|
char * pszDst = pszBuffer;
|
|
strcpy(pszDst, psz());
|
|
StrTrim(&pszDst, GetLength(), bRemoveFront, bRemoveRear);
|
|
std::string::operator=(pszDst);
|
|
free(pszBuffer);
|
|
}
|
|
|
|
bool Replace(const char * pszKeyword, const char * pszReplace, int nMode = 0, int nCount = -1) // nMode : 0 = case sensitive, 1 = no case, 2 = keyword
|
|
{
|
|
if (nCount == 0)
|
|
return false;
|
|
|
|
const char * (*fnStrStr)(const char *, const char *);
|
|
if (nMode == 0)
|
|
fnStrStr = (const char*(*)(const char*, const char*))strstr;
|
|
else if (nMode == 1)
|
|
fnStrStr = stristr;
|
|
else
|
|
fnStrStr = StrIKeyword;
|
|
|
|
int nRepeatCount = nCount;
|
|
size_t nKeywordLength = strlen(pszKeyword);
|
|
const char * pszNext = psz();
|
|
int nKeywordCount = 0;
|
|
for (;;)
|
|
{
|
|
if ((pszNext = fnStrStr(pszNext, pszKeyword)) == NULL)
|
|
break;
|
|
|
|
nKeywordCount++;
|
|
|
|
if (nRepeatCount > -1 && --nRepeatCount == 0)
|
|
break;
|
|
|
|
pszNext += nKeywordLength;
|
|
}
|
|
|
|
if (nKeywordCount == 0)
|
|
return false;
|
|
|
|
size_t nReplaceLength = strlen(pszReplace);
|
|
size_t nTextLength = GetLength();
|
|
size_t nNewTextLength = nTextLength + (nReplaceLength - nKeywordLength) * nKeywordCount;
|
|
char * pszNewText = (char *)malloc(nNewTextLength + 1);
|
|
|
|
size_t nCopySize;
|
|
size_t nRemainSize = nTextLength;
|
|
char * pszNewTextOffset = pszNewText;
|
|
const char * pszTextOffset = psz();
|
|
|
|
nRepeatCount = nCount;
|
|
for (;;)
|
|
{
|
|
if ((pszNext = fnStrStr(pszTextOffset, pszKeyword)) == NULL)
|
|
break;
|
|
|
|
nCopySize = pszNext - pszTextOffset;
|
|
|
|
memcpy(pszNewTextOffset, pszTextOffset, nCopySize);
|
|
memcpy(pszNewTextOffset + nCopySize, pszReplace, nReplaceLength);
|
|
|
|
pszTextOffset += nCopySize + nKeywordLength;
|
|
pszNewTextOffset += nCopySize + nReplaceLength;
|
|
|
|
nRemainSize -= nCopySize + nKeywordLength;
|
|
|
|
if (nRepeatCount > -1 && --nRepeatCount == 0)
|
|
break;
|
|
}
|
|
|
|
if (nRemainSize > 0)
|
|
memcpy(pszNewTextOffset, pszTextOffset, nRemainSize);
|
|
|
|
pszNewText[nNewTextLength] = '\0';
|
|
std::string::operator=(pszNewText);
|
|
free(pszNewText);
|
|
|
|
return true;
|
|
}
|
|
|
|
// " a b c " --> " a b c "
|
|
void RemoveRedundancyChar(const char * pszSrc, size_t nLength, char ch)
|
|
{
|
|
*this = "";
|
|
|
|
if (pszSrc == NULL || nLength == 0)
|
|
return;
|
|
|
|
for (size_t i = 0; i < nLength; i++)
|
|
{
|
|
if (pszSrc[i] == ch && pszSrc[i + 1] == ch)
|
|
continue;
|
|
|
|
*this += pszSrc[i];
|
|
}
|
|
}
|
|
|
|
void RemoveRedundancyRow(const char * pszSrc, size_t nLength)
|
|
{
|
|
*this = "";
|
|
|
|
if (pszSrc == NULL || nLength == 0)
|
|
return;
|
|
|
|
for (size_t i = 0; i < nLength; i++)
|
|
{
|
|
if (pszSrc[i] == '\r' && pszSrc[i + 1] == '\n' && pszSrc[i + 2] == '\r' && pszSrc[i + 3] == '\n')
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
*this += pszSrc[i];
|
|
}
|
|
}
|
|
|
|
void Cut(char chDelimiter)
|
|
{
|
|
char * p = (char *)psz();
|
|
size_t nLength = GetLength();
|
|
|
|
for (size_t i = 0; i < nLength; i++)
|
|
{
|
|
if (p[i] == chDelimiter)
|
|
{
|
|
p[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PartAssign(const char * psz, char chDelimiter)
|
|
{
|
|
size_t i = 0;
|
|
for (; psz[i]; i++)
|
|
{
|
|
if (psz[i] == chDelimiter)
|
|
break;
|
|
}
|
|
|
|
if (i == 0)
|
|
return;
|
|
|
|
Assign(psz, i);
|
|
}
|
|
|
|
/*int Tokenize(const char * psz, size_t nSize, char chDelimiter)
|
|
{
|
|
for (size_t i = 0; i < nSize; i++)
|
|
{
|
|
if (psz[i] == ' ')
|
|
{
|
|
if (i > 0)
|
|
Assign(psz, i);
|
|
|
|
return (int)(i + 1);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}*/
|
|
|
|
// 2019-11-01 0:02 -> YYYY-MM-DD HH:MM
|
|
void ConvertDateTime()
|
|
{
|
|
if (GetLength() == 15)
|
|
{
|
|
HString str(psz(), 11);
|
|
str += "0";
|
|
str += this->SubStr(11, 4);
|
|
*this = str;
|
|
}
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////
|
|
|
|
class HStringTokenizer : public HObject
|
|
{
|
|
public:
|
|
HStringTokenizer(const HString & str, const char cDelimiter)
|
|
{
|
|
Tokenize(str, cDelimiter);
|
|
}
|
|
|
|
HStringTokenizer(const char * psz, const char cDelimiter)
|
|
{
|
|
HString str = psz;
|
|
Tokenize(str, cDelimiter);
|
|
}
|
|
|
|
~HStringTokenizer()
|
|
{
|
|
if (m_arr)
|
|
delete [] m_arr;
|
|
}
|
|
|
|
inline size_t GetCount() { return m_nCount; }
|
|
|
|
//inline HString & operator [] (int nIndex)
|
|
inline HString & operator [] (size_t nIndex)
|
|
{
|
|
return m_arr[nIndex];
|
|
}
|
|
|
|
protected:
|
|
// |a|b - fail
|
|
inline void Tokenize(const HString & str, const char cDelimiter)
|
|
{
|
|
if (str.IsEmpty())
|
|
{
|
|
m_arr = NULL;
|
|
m_nCount = 0;
|
|
return;
|
|
}
|
|
|
|
m_nCount = std::count(str.begin(), str.end(), cDelimiter) + 1;
|
|
m_arr = new HString[m_nCount];
|
|
|
|
std::istringstream stream(str);
|
|
std::string token;
|
|
int i = 0;
|
|
while (std::getline(stream, token, cDelimiter))
|
|
{
|
|
m_arr[i++] = token;
|
|
}
|
|
}
|
|
|
|
private:
|
|
HString * m_arr;
|
|
size_t m_nCount;
|
|
};
|
|
|
|
///////////////////////////////////////
|
|
|
|
class HUtf16ToUtf8
|
|
{
|
|
public:
|
|
HUtf16ToUtf8()
|
|
{
|
|
#ifndef _WIN32
|
|
m_iconv = iconv_open("UTF-8", "UTF-16LE");
|
|
#endif
|
|
m_pUtf8 = NULL;
|
|
}
|
|
|
|
~HUtf16ToUtf8()
|
|
{
|
|
if (m_pUtf8)
|
|
free(m_pUtf8);
|
|
|
|
#ifndef _WIN32
|
|
iconv_close(m_iconv);
|
|
#endif
|
|
}
|
|
|
|
char * Convert(const char * pSrc, int nLen)
|
|
{
|
|
if (m_pUtf8)
|
|
free(m_pUtf8);
|
|
|
|
#ifndef _WIN32
|
|
size_t nDstLen = nLen * 2;
|
|
m_pUtf8 = (char *)calloc(nDstLen + 1, 1);
|
|
char * pSrc2 = (char *)calloc(nLen + 1, 1);
|
|
memcpy(pSrc2, pSrc, nLen + 1);
|
|
|
|
char * pUtf16 = pSrc2;
|
|
char * pDst = m_pUtf8;
|
|
|
|
iconv(m_iconv, &pUtf16, (size_t *)&nLen, &pDst, &nDstLen);
|
|
|
|
free(pSrc2);
|
|
#else
|
|
int nDstLen = WideCharToMultiByte(CP_UTF8, 0, (const wchar_t *)pSrc, (int)nLen, NULL, 0, NULL, NULL);
|
|
|
|
if (nDstLen > 0)
|
|
{
|
|
m_pUtf8 = (char *)malloc(nDstLen + 1);
|
|
WideCharToMultiByte(CP_UTF8, 0, (const wchar_t *)pSrc, (int)nLen, m_pUtf8, nDstLen, NULL, NULL);
|
|
m_pUtf8[nDstLen] = '\0';
|
|
}
|
|
#endif
|
|
return m_pUtf8;
|
|
}
|
|
|
|
protected:
|
|
#ifndef _WIN32
|
|
iconv_t m_iconv;
|
|
#endif
|
|
char * m_pUtf8;
|
|
};
|
|
|
|
class HUtf8ToEucKr
|
|
{
|
|
public:
|
|
HUtf8ToEucKr()
|
|
{
|
|
#ifndef _WIN32
|
|
m_iconv = iconv_open("EUC-KR", "UTF-8");
|
|
#endif
|
|
m_pEucKr = NULL;
|
|
}
|
|
|
|
~HUtf8ToEucKr()
|
|
{
|
|
if (m_pEucKr)
|
|
free(m_pEucKr);
|
|
|
|
#ifndef _WIN32
|
|
iconv_close(m_iconv);
|
|
#endif
|
|
}
|
|
|
|
char * Convert(const char * pSrc, int nLen)
|
|
{
|
|
if (pSrc == NULL || pSrc[0] == '\0' || nLen <= 0)
|
|
return "";
|
|
|
|
if (m_pEucKr)
|
|
free(m_pEucKr);
|
|
|
|
#ifndef _WIN32
|
|
size_t nDstLen = nLen * 2;
|
|
m_pEucKr = (char *)calloc(nDstLen + 1, 1);
|
|
char * pSrc2 = (char *)calloc(nLen + 1, 1);
|
|
strcpy(pSrc2, pSrc);
|
|
|
|
char * pUtf8 = pSrc2;
|
|
char * pDst = m_pEucKr;
|
|
|
|
iconv(m_iconv, &pUtf8, (size_t *)&nLen, &pDst, &nDstLen);
|
|
|
|
free(pSrc2);
|
|
#else
|
|
int nLength = MultiByteToWideChar(CP_UTF8, 0, pSrc, nLen + 1, NULL, NULL);
|
|
BSTR bstrWide = SysAllocStringLen(NULL, nLength);
|
|
|
|
MultiByteToWideChar(CP_UTF8, 0, pSrc, nLen + 1, bstrWide, nLength);
|
|
|
|
nLength = WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, NULL, 0, NULL, NULL);
|
|
|
|
m_pEucKr = (char *)malloc(nLength);
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, m_pEucKr, nLength, NULL, NULL);
|
|
SysFreeString(bstrWide);
|
|
#endif
|
|
return m_pEucKr;
|
|
}
|
|
|
|
protected:
|
|
#ifndef _WIN32
|
|
iconv_t m_iconv;
|
|
#endif
|
|
char * m_pEucKr;
|
|
};
|
|
|
|
class HEucKrToUtf8
|
|
{
|
|
public:
|
|
HEucKrToUtf8()
|
|
{
|
|
#ifndef _WIN32
|
|
m_iconv = iconv_open("UTF-8", "EUC-KR");
|
|
#endif
|
|
m_pUtf8 = NULL;
|
|
}
|
|
|
|
~HEucKrToUtf8()
|
|
{
|
|
if (m_pUtf8)
|
|
free(m_pUtf8);
|
|
|
|
#ifndef _WIN32
|
|
iconv_close(m_iconv);
|
|
#endif
|
|
}
|
|
|
|
char * Convert(const char * pSrc, int nLen)
|
|
{
|
|
if (m_pUtf8)
|
|
free(m_pUtf8);
|
|
|
|
#ifndef _WIN32
|
|
size_t nDstLen = nLen * 4;
|
|
m_pUtf8 = (char *)calloc(nDstLen + 1, 1);
|
|
char * pSrc2 = (char *)calloc(nLen + 1, 1);
|
|
strcpy(pSrc2, pSrc);
|
|
|
|
char * pUtf16 = pSrc2;
|
|
char * pDst = m_pUtf8;
|
|
|
|
iconv(m_iconv, &pUtf16, (size_t *)&nLen, &pDst, &nDstLen);
|
|
|
|
free(pSrc2);
|
|
#else
|
|
int nLength = MultiByteToWideChar(CP_ACP, 0, pSrc, nLen, NULL, NULL);
|
|
BSTR bstrCode = SysAllocStringLen(NULL, nLength);
|
|
MultiByteToWideChar(CP_ACP, 0, pSrc, nLen, bstrCode, nLength);
|
|
|
|
int nLength2 = WideCharToMultiByte(CP_UTF8, 0, bstrCode, -1, m_pUtf8, 0, NULL, NULL);
|
|
m_pUtf8 = (char*)malloc(nLength2 + 1);
|
|
WideCharToMultiByte(CP_UTF8, 0, bstrCode, -1, m_pUtf8, nLength2, NULL, NULL);
|
|
SysFreeString(bstrCode);
|
|
#endif
|
|
return m_pUtf8;
|
|
}
|
|
|
|
protected:
|
|
#ifndef _WIN32
|
|
iconv_t m_iconv;
|
|
#endif
|
|
char * m_pUtf8;
|
|
};
|
|
|
|
///////////////////////////////////////
|
|
|
|
extern inline void RemoveTagElement(HString * pstrDst, const char * pszSrc, size_t nLength, const char * pszTag)
|
|
{
|
|
*pstrDst = "";
|
|
|
|
if (pszSrc == NULL || nLength == 0)
|
|
return;
|
|
|
|
HString strFrontTag = "<"; strFrontTag += pszTag;
|
|
HString strRearTag = "</"; strRearTag += pszTag; strRearTag += ">";
|
|
|
|
bool bSkip = false;
|
|
for (size_t i = 0; i < nLength; i++, pszSrc++)
|
|
{
|
|
if (bSkip)
|
|
{
|
|
if (strnicmp(pszSrc, strRearTag, strRearTag.GetLength()) == 0)
|
|
{
|
|
bSkip = false;
|
|
i += strRearTag.GetLength() - 1;
|
|
pszSrc += strRearTag.GetLength() - 1;
|
|
}
|
|
continue;
|
|
}
|
|
else if (strnicmp(pszSrc, strFrontTag, strFrontTag.GetLength()) == 0)
|
|
{
|
|
bSkip = true;
|
|
i += strFrontTag.GetLength() - 1;
|
|
pszSrc += strFrontTag.GetLength() - 1;
|
|
continue;
|
|
}
|
|
|
|
*pstrDst += *pszSrc;
|
|
}
|
|
}
|
|
|
|
extern inline void RemoveMarkupTag(HString * pstrDst, const char * pszSrc, size_t nLength)
|
|
{
|
|
*pstrDst = "";
|
|
|
|
if (pszSrc == NULL || nLength == 0)
|
|
return;
|
|
|
|
int nSkipMode = 0; // 0 : no skip, 1 : normal tag, 2 : comment tag
|
|
for (size_t i = 0; i < nLength; i++)
|
|
{
|
|
if (nSkipMode == 1)
|
|
{
|
|
if (pszSrc[i] == '>')
|
|
nSkipMode = 0;
|
|
|
|
continue;
|
|
}
|
|
else if (nSkipMode == 2)
|
|
{
|
|
if (pszSrc[i] == '-' && pszSrc[i + 1] == '-' && pszSrc[i + 2] == '>')
|
|
{
|
|
i += 2;
|
|
nSkipMode = 0;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
else if (pszSrc[i] == '<')
|
|
{
|
|
if (pszSrc[i + 1] == '!' && pszSrc[i + 2] == '-' && pszSrc[i + 3] == '-')
|
|
{
|
|
i += 2;
|
|
nSkipMode = 2;
|
|
}
|
|
else
|
|
nSkipMode = 1;
|
|
|
|
continue;
|
|
}
|
|
|
|
*pstrDst += pszSrc[i];
|
|
}
|
|
}
|
|
|
|
extern inline size_t ClearSpaceAndRow(HString * pstrDst, const char * pszSrc, size_t nLength, bool bRemoveRow)
|
|
{
|
|
size_t nRowCount = 0;
|
|
*pstrDst = "";
|
|
|
|
if (pszSrc == NULL || nLength == 0)
|
|
return nRowCount;
|
|
|
|
char * pNextLine = (char *)pszSrc;
|
|
char * pOneLine;
|
|
do
|
|
{
|
|
pOneLine = pNextLine;
|
|
pNextLine = StrSlice(pOneLine);
|
|
|
|
StrTrim(&pOneLine, strlen(pOneLine), true, true);
|
|
if (pOneLine[0] == '\0')
|
|
continue;
|
|
|
|
*pstrDst += pOneLine;
|
|
|
|
nRowCount++;
|
|
|
|
if (bRemoveRow == false)
|
|
*pstrDst += "\r\n";
|
|
|
|
} while (pNextLine);
|
|
|
|
return nRowCount;
|
|
}
|
|
|
|
extern inline void StrRemoveRow(HString * pstrDst, const char * pszSrc, const char * pszKeyword)
|
|
{
|
|
*pstrDst = "";
|
|
|
|
if (pszSrc == NULL || pszKeyword == NULL)
|
|
return;
|
|
|
|
char * pNextLine = (char *)pszSrc;
|
|
char * pOneLine;
|
|
do
|
|
{
|
|
pOneLine = pNextLine;
|
|
pNextLine = StrSlice(pOneLine);
|
|
|
|
StrTrim(&pOneLine, strlen(pOneLine), true, true);
|
|
if (pOneLine[0] == '\0' || stristr(pOneLine, pszKeyword))
|
|
continue;
|
|
|
|
*pstrDst += pOneLine;
|
|
*pstrDst += "\r\n";
|
|
|
|
} while (pNextLine);
|
|
}
|
|
|
|
// nMode = 0 : between, 1 : with front, 2 : with rear, 3 : both remove
|
|
extern inline void StrBetweenRemove(HString * pstrDst, const char * pszSrc, const char * pszFront, const char * pszRear, int nMode)
|
|
{
|
|
*pstrDst = "";
|
|
|
|
if (pszSrc == NULL || pszFront == NULL || pszRear == NULL)
|
|
return;
|
|
|
|
char * pszStart, * pszEnd;
|
|
|
|
if ((pszStart = (char *)strstr(pszSrc, pszFront)) == NULL)
|
|
return;
|
|
size_t nFrontSize = strlen(pszFront);
|
|
pszStart += nFrontSize;
|
|
|
|
if ((pszEnd = strstr(pszStart, pszRear)) == NULL)
|
|
return;
|
|
|
|
if (nMode == 1 || nMode == 3)
|
|
pszStart -= nFrontSize;
|
|
|
|
pstrDst->Assign(pszSrc, pszStart - pszSrc);
|
|
|
|
if (nMode == 2 || nMode == 3)
|
|
*pstrDst += (pszEnd + strlen(pszRear));
|
|
else
|
|
*pstrDst += pszEnd;
|
|
}
|
|
|
|
#endif // STRING__H_
|