nstring.cpp

EVC环境下用SDK开发WINCE的应用程序

int CNString::FindOneOf(LPCTSTR lpszCharSet) const
{
	LPTSTR lpsz = _tcspbrk(m_pszString, lpszCharSet);
	return (lpsz == NULL) ? -1 : (int)(lpsz - m_pszString);
}


//////////////////////////////////////////////////////////////////////
//
// Assignment Operations
//
//////////////////////////////////////////////////////////////////////

const CNString& CNString::operator=(CNString& strSrc)
{
	if (m_pszString != strSrc.GetString())
		StringCopy(strSrc.GetLength(), strSrc.GetString());
	return *this;
}

const CNString& CNString::operator=(LPCTSTR lpsz)
{
	ATLASSERT(lpsz != NULL);
	StringCopy(_tcslen(lpsz), lpsz);
	return *this;
}

const CNString& CNString::operator=(BSTR bstrStr)
{
	USES_CONVERSION;
	int nLen = _tcslen(OLE2T(bstrStr));
	StringCopy(nLen, OLE2T(bstrStr));
	return *this;
}


//////////////////////////////////////////////////////////////////////
//
// Concatenation
//
//////////////////////////////////////////////////////////////////////

CNString operator+(CNString& strSrc1, CNString& strSrc2)
{
	CNString s;
	s.ConcatCopy((LPCTSTR) strSrc1, (LPCTSTR) strSrc2);
	return s;
}

CNString operator+(CNString& strSrc, LPCTSTR lpsz)
{
	CNString s;
	s.ConcatCopy((LPCTSTR) strSrc, lpsz);
	return s;
}

CNString operator+(LPCTSTR lpsz, CNString& strSrc)
{
	CNString s;
	s.ConcatCopy(lpsz, (LPCTSTR) strSrc);
	return s;
}

CNString operator+(CNString& strSrc, BSTR bstrStr)
{
	USES_CONVERSION;
	CNString s;
	s.ConcatCopy((LPCTSTR) strSrc, OLE2T(bstrStr));
	return s;
}

CNString operator+(BSTR bstrStr, CNString& strSrc)
{
	USES_CONVERSION;
	CNString s;
	s.ConcatCopy(OLE2T(bstrStr), (LPCTSTR) strSrc);
	return s;
}

const CNString& CNString::operator+=(CNString& strSrc)
{
	ConcatCopy((LPCTSTR) strSrc);
	return *this;
}

const CNString& CNString::operator+=(LPCTSTR lpsz)
{
	ConcatCopy(lpsz);
	return *this;
}

const CNString& CNString::operator+=(BSTR bstrStr)
{
	USES_CONVERSION;
	ConcatCopy(OLE2T(bstrStr));
	return *this;
}

const CNString& CNString::operator+=(TCHAR ch)
{
	USES_CONVERSION;
	ConcatCopy(ch);
	return *this;
}


//////////////////////////////////////////////////////////////////////
//
// Extraction
//
//////////////////////////////////////////////////////////////////////

CNString CNString::Mid(int nFirst) const
{
	return Mid(nFirst, GetLength() - nFirst);	
}

CNString CNString::Mid(int nFirst, int nCount) const
{
	if (nFirst < 0)
		nFirst = 0;
	if (nCount < 0)
		nCount = 0;

	if (nFirst + nCount > GetLength())
		nCount = GetLength() - nFirst;
	if (nFirst > GetLength())
		nCount = 0;

	ATLASSERT(nFirst >= 0);
	ATLASSERT(nFirst + nCount <= GetLength());

	if (nFirst == 0 && nFirst + nCount == GetLength())
		return *this;

	CNString newStr;
	StringCopy(newStr, nCount, nFirst, 0);
	return newStr;
}

CNString CNString::Left(int nCount) const
{
	if (nCount < 0)
		nCount = 0;
	if (nCount >= GetLength())
		return *this;

	CNString newStr;
	StringCopy(newStr, nCount, 0, 0);
	return newStr;
}

CNString CNString::Right(int nCount) const
{
	if (nCount < 0)
		nCount = 0;
	if (nCount >= GetLength())
		return *this;

	CNString newStr;
	StringCopy(newStr, nCount, GetLength() - nCount, 0);
	return newStr;
}

CNString CNString::SpanIncluding(LPCTSTR lpszCharSet) const
{
	ATLASSERT(lpszCharSet != NULL);
	ATLASSERT(::IsBadReadPtr(lpszCharSet, _tcslen(lpszCharSet)*sizeof(TCHAR)) == 0);

	return Left(_tcsspn(m_pszString, lpszCharSet));
}

CNString CNString::SpanExcluding(LPCTSTR lpszCharSet) const
{
	ATLASSERT(lpszCharSet != NULL);
	ATLASSERT(::IsBadReadPtr(lpszCharSet, _tcslen(lpszCharSet)*sizeof(TCHAR)) == 0);

	return Left(_tcscspn(m_pszString, lpszCharSet));
}


//////////////////////////////////////////////////////////////////////
//
// Nparison
//
//////////////////////////////////////////////////////////////////////
	
int CNString::Compare(CNString& str) const
{
	ATLASSERT((LPCTSTR) str != NULL);
	ATLASSERT(::IsBadReadPtr((LPCTSTR) str, str.GetLength()*sizeof(TCHAR)) == 0);

	return _tcscmp(m_pszString, (LPCTSTR) str);	
}

int CNString::Compare(LPCTSTR lpsz) const
{
	ATLASSERT(lpsz != NULL);
	ATLASSERT(::IsBadReadPtr(lpsz, _tcslen(lpsz)*sizeof(TCHAR)) == 0);

	return _tcscmp(m_pszString, lpsz);	
}

int CNString::CompareNoCase(CNString& str) const
{
	ATLASSERT((LPCTSTR) str != NULL);
	ATLASSERT(::IsBadReadPtr((LPCTSTR) str, str.GetLength()*sizeof(TCHAR)) == 0);

	return _tcsicmp(m_pszString, (LPCTSTR) str);	
}

int CNString::CompareNoCase(LPCTSTR lpsz) const
{
	ATLASSERT(lpsz != NULL);
	ATLASSERT(::IsBadReadPtr(lpsz, _tcslen(lpsz)*sizeof(TCHAR)) == 0);

	return _tcsicmp(m_pszString, lpsz);	
}
/*
int CNString::Collate(LPCTSTR lpsz) const
{
	ATLASSERT(lpsz != NULL);
	ATLASSERT(::IsBadReadPtr(lpsz, _tcslen(lpsz)*sizeof(TCHAR)) == 0);

	return _tcscoll(m_pszString, lpsz);	
}

int CNString::Collate(CNString &str) const
{
	ATLASSERT((LPCTSTR) str != NULL);
	ATLASSERT(::IsBadReadPtr((LPCTSTR) str, str.GetLength()*sizeof(TCHAR)) == 0);

	return _tcscoll(m_pszString, (LPCTSTR) str);	
}
*/

//////////////////////////////////////////////////////////////////////
//
// Formatting
//
//////////////////////////////////////////////////////////////////////
	
void CNString::Format(LPCTSTR pszCharSet, ...)
{
	va_list vl;
	va_start(vl, pszCharSet);

	TCHAR* pszTemp = NULL;
	int nBufferSize = 0;
	int nRetVal = -1;

	do {
		nBufferSize += 100;
		delete [] pszTemp;
		pszTemp = new TCHAR[nBufferSize];
		nRetVal = _vsntprintf(pszTemp, nBufferSize, pszCharSet, vl);
	} while (nRetVal < 0);

	int nNewLen = _tcslen(pszTemp);
	AllocString(nNewLen);
	_tcscpy(m_pszString, pszTemp);
	delete [] pszTemp;

	va_end(vl);
}


//////////////////////////////////////////////////////////////////////
//
// Replacing
//
//////////////////////////////////////////////////////////////////////

int CNString::Replace(TCHAR chOld, TCHAR chNew)
{
	int nCount = 0;

	if (chOld != chNew)
	{
		LPTSTR psz = m_pszString;
		LPTSTR pszEnd = psz + GetLength();
		while(psz < pszEnd)
		{
			if (*psz == chOld)
			{
				*psz = chNew;
				nCount++;
			}
			psz++; // = _tcsinc(psz);
		}
	}

	return nCount;
}

int CNString::Replace(LPCTSTR lpszOld, LPCTSTR lpszNew)
{
	int nSourceLen = _tcslen(lpszOld);
	if (nSourceLen == 0)
		return 0;
	int nReplaceLen = _tcslen(lpszNew);

	int nCount = 0;
	LPTSTR lpszStart = m_pszString;
	LPTSTR lpszEnd = lpszStart + GetLength();
	LPTSTR lpszTarget;

	// Check to see if any changes need to be made
	while (lpszStart < lpszEnd)
	{
		while ((lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
		{
			lpszStart = lpszTarget + nSourceLen;
			nCount++;
		}
		lpszStart += _tcslen(lpszStart) + 1;
	}

	// Do the actual work
	if (nCount > 0)
	{
		int nOldLen = GetLength();
		int nNewLen = nOldLen + (nReplaceLen - nSourceLen) * nCount;
		if (GetLength() < nNewLen)
		{
			CNString szTemp = m_pszString;
			ReAllocString(nNewLen);
			memcpy(m_pszString, (LPCTSTR) szTemp, nOldLen * sizeof(TCHAR));
		}

		lpszStart = m_pszString;
		lpszEnd = lpszStart + GetLength();

		while (lpszStart < lpszEnd)
		{
			while ((lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
			{
				int nBalance = nOldLen - (lpszTarget - m_pszString + nSourceLen);
				memmove(lpszTarget + nReplaceLen, lpszTarget + nSourceLen, nBalance * sizeof(TCHAR));
				memcpy(lpszTarget, lpszNew, nReplaceLen * sizeof(TCHAR));
				lpszStart = lpszTarget + nReplaceLen;
				lpszStart[nBalance] = '\0';
				nOldLen += (nReplaceLen - nSourceLen);
			}
			lpszStart += _tcslen(lpszStart) + 1;
		}
		ATLASSERT(m_pszString[GetLength()] == '\0');
	}
	return nCount;
}