// TString.cpp: implementation of the TString class. //
//////////////////////////////////////////////////////////////////////
#include "TString.h"
int SafeStrlen(_PCTSTR psz)
{
if (psz == NULL)
return 0;
else
return strlen(psz);
}
char * _tcsinc(const char * psz)
{
if (psz == NULL)
return NULL;
psz = psz + 1;
return (char *)psz;
}
int StrtoInt(const char * psz)
{
if (psz == NULL)
return 0;
return atoi(psz);
}
bool _isdigit(_TCHAR ch)
{
if (ch >= '0' && ch <= '9')
return true;
return false;
}
size_t _mbclen(const unsigned char *s)
{
return strlen((const char *)s);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
TString::TString()
{
}
TString::~TString()
{
}
TString::TString(std::string& stringSrc)
{
m_string = stringSrc;
}
TString::TString(_PCTSTR psz)
{
m_string = (psz != NULL)?psz:"";
}
TString::TString(_TCHAR ch, int Repeat)
{
for(int i=0; i< Repeat; i++)
{
m_string += ch;
}
}
TString::TString(int nMaxSize)
{
m_string.resize(nMaxSize);
}
// ref-counted copy from another CString
TString & TString::operator=(TString &str)
{
m_string = str.getInstance();
return *this;
}
TString & TString::operator =(std::string & stringSrc)
{
m_string = stringSrc;
return *this;
}
// copy string content from ANSI string (converts to _TCHAR)
TString & TString::operator =(_PCTSTR psz)
{
m_string = (psz != NULL)?psz:"";
return *this;
}
// set string content to single character
TString & TString::operator =(_TCHAR ch)
{
char cTemp[2];
cTemp[0] = ch;
cTemp[1] = '\0';
m_string = cTemp;
return *this;
}
TString & TString::operator<<(TString &str)
{
m_string += str.getInstance();
return *this;
}
TString & TString::operator<<(std::string& stringSrc)
{
m_string += stringSrc;
return *this;
}
TString & TString::operator<<(_PCTSTR psz)
{
m_string += (psz != NULL)?psz:"";
return *this;
}
TString & TString::operator<<(_TCHAR ch)
{
char cTemp[2];
cTemp[0] = ch;
cTemp[1] = '\0';
m_string += cTemp;
return *this;
}
TString & TString::operator<<(_UINT iValue)
{
char cTemp[64];
sprintf(cTemp, "%d", iValue);
m_string += cTemp;
return *this;
}
TString & TString::operator<<(long lValue)
{
char cTemp[64];
sprintf(cTemp, "%ld", lValue);
m_string += cTemp;
return *this;
}
TString & TString::operator<<(double fValue)
{
char cTemp[512];
sprintf(cTemp, "%f", fValue);
m_string += cTemp;
return *this;
}
int TString::Compare(_PCTSTR psz) const
{
if (psz == NULL)
return 1;
return m_string.compare(psz);
}
// ref-counted compare from another String
bool TString::operator==(TString &str)
{
return Compare(str.getstr()) == 0;
}
bool TString::operator==(std::string & stringSrc)
{
return Compare(stringSrc.c_str()) == 0;
}
bool TString::operator==(_PCTSTR psz)
{
return Compare(psz) == 0;
}
int TString::CompareNoCase(_PCTSTR psz) const
{
if (psz == NULL)
return 1;
for(int i=0; i<m_string.size(); i++)
{
if( toupper(m_string[i]) == toupper(psz[i]))
continue;
else
return -1;
}
return 0;
}
_TCHAR TString::GetAt(int nIndex) const
{
if (nIndex >= 0 && nIndex < m_string.size())
return m_string[nIndex];
else {
return '\0';
}
}
void TString::SetAt(int nIndex, _TCHAR ch)
{
if (nIndex >= 0 && nIndex < m_string.size())
m_string[nIndex] = ch;
}
_TCHAR TString::operator[](int nIndex) const
{
if (nIndex >= 0 && nIndex < m_string.size())
return m_string[nIndex];
else
return '\0';
}
// return nCount characters starting at zero-based nFirst
std::string TString::Mid(int nFirst, int nCount) const
{
if (nFirst < 0)
nFirst = 0;
if (nCount < 0)
nCount = 0;
if (nFirst + nCount > m_string.size())
nCount = m_string.size() - nFirst;
if (nFirst > m_string.size())
nCount = 0;
// optimize case of returning entire string
if (nFirst == 0 && nFirst + nCount == m_string.size())
return m_string;
std::string s;
s = m_string.substr(nFirst, nCount);
return s;
}
// return all characters starting at zero-based nFirst
std::string TString::Mid(int nFirst) const
{
std::string s;
s = m_string.substr(nFirst, m_string.size()-nFirst);
return s;
}
// return first nCount characters in string
std::string TString::Left(int nCount) const
{
if (nCount < 0)
nCount = 0;
if (nCount >= m_string.size())
return m_string;
std::string s;
s = m_string.substr(0, nCount);
return s;
}
// return nCount characters from end of string
std::string TString::Right(int nCount) const
{
if (nCount < 0)
nCount = 0;
if (nCount >= m_string.size())
return m_string;
std::string s;
s = m_string.substr(m_string.size()-nCount, nCount);
return s;
}
// NLS aware conversion to uppercase
TString & TString::MakeUpper()
{
int c = m_string.size();
for(int i=0; i<c; i++) m_string[i] = toupper(m_string[i]);
return *this;
}
// NLS aware conversion to lowercase
TString & TString::MakeLower()
{
int c = m_string.size();
for(int i=0; i<c; i++) m_string[i] = tolower(m_string[i]);
return *this;
}
// trimming whitespace (either side)
// remove whitespace starting from right edge
TString & TString::TrimRight()
{
// if we're not trimming anything, we're not doing any work
size_t size = m_string.size();
if(size == 0) return *this;
while(m_string.size() != 0 &&
(m_string[m_string.size() - 1] == ' ' ||
m_string[m_string.size() - 1] == '\t' ||
m_string[m_string.size() - 1] == '\n'))
m_string.erase(m_string.size() - 1, 1);
return *this;
}
// remove whitespace starting from left side
TString & TString::TrimLeft()
{
size_t size = m_string.size();
if(size == 0) return *this;
while(m_string.size() != 0 &&
(m_string[0] == ' ' ||
m_string[0] == '\t' ||
m_string[0] == '\n'))
m_string.erase(0, 1);
return *this;
}
TString & TString::Trim()
{
size_t size = m_string.size();
if(size == 0) return *this;
while(m_string.size() != 0 &&
(m_string[m_string.size() - 1] == ' ' ||
m_string[m_string.size() - 1] == '\t' ||
m_string[m_string.size() - 1] == '\n'))
m_string.erase(m_string.size() - 1, 1);
while(m_string.size() != 0 &&
(m_string[0] == ' ' ||
m_string[0] == '\t' ||
m_string[0] == '\n'))
m_string.erase(0, 1);
return *this;
}
// replace occurrences of chOld with chNew
int TString::Replace(_TCHAR chOld, _TCHAR chNew)
{
//m_string.replace(chOld, chNew);
for(int i=0; i<m_string.size(); i++)
{
if (m_string[i] == chOld)
m_string[i] = chNew;
}
return m_string.size();
}
// replace occurrences of substring pszOld with pszNew;
// empty pszNew removes instances of pszOld
int TString::Replace(_PCTSTR pszOld, _PCTSTR pszNew)
{
if (pszOld == NULL || pszNew == NULL)
return m_string.size();
int pos = -1;
int len = SafeStrlen(pszOld);
int len1= SafeStrlen(pszNew);
pos = m_string.find_first_of(pszOld);
while (pos >= 0)
{
m_string.replace(pos, len, pszNew);
pos = m_string.find(pszOld, pos + len1);
}
return m_string.size();
}
// remove occurrences of chRemove
int TString::Remove(_TCHAR chRemove)
{
m_string.erase(chRemove);
return m_string.size();
}
// if index is past end of string
int TString::Insert(int nIndex, _TCHAR ch)
{
if (nIndex < 0)
nIndex = 0;
m_string.insert(nIndex, &ch);
return m_string.size();
}
// insert substring at zero-based index; concatenates
// if index is past end of string
int TString::Insert(int nIndex, _PCTSTR pstr)
{
if (nIndex < 0)
nIndex = 0;
m_string.insert(nIndex, pstr, SafeStrlen(pstr));
return m_string.size();
}
// delete nCount characters starting at zero-based index
int TString::Delete(int nIndex, int nCount)
{
if (nIndex < 0)
nIndex = 0;
m_string.erase(nIndex, nCount);
return m_string.size();
}
// searching
// find character starting at left, -1 if not found
int TString::Find(_TCHAR ch) const
{
int index = -1;
index = (int)m_string.find(ch);
return index;
}
// find character starting at right
int TString::ReverseFind(_TCHAR ch) const
{
int index = -1;
index =