최종완료보고 버전
This commit is contained in:
CodeTempla
@@ -0,0 +1,983 @@
|
||||
|
||||
#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_
|
||||
Reference in New Issue
Block a user