vostring.cpp

MOBILE平台的PNG图片处理

	}
}

void CVOString::MakeUpper()
{
	for(int i = 0; i < (int)GetLength(); i++)
	{
		if(m_pBuffer[i] >= TCHAR('a') && m_pBuffer[i] <= TCHAR('z'))
			m_pBuffer[i] = m_pBuffer[i] - (TCHAR('a') - TCHAR('A'));
	}
}

int CVOString::CompareNoCase(LPCTSTR pcszValue) const
{
	if(!m_pBuffer && !pcszValue)
		return 0;

	if(!pcszValue)
		return 1;

	if(!m_pBuffer)
		return -1;

	return _tcsicmp(m_pBuffer, pcszValue);
}

int CVOString::FindOneOf(LPCTSTR pcszDelims)
{
	if(m_pBuffer == NULL || m_dwBufferSize == 0)
		return -1;

	if(!pcszDelims)
		return -1;

	int nDelim = _tcscspn((LPCTSTR)m_pBuffer, pcszDelims);

	if(nDelim == (int)GetLength())
		return -1;

	return nDelim;
}

DWORD CVOString::Replace(LPCTSTR pcszSearchFor, LPCTSTR pcszReplaceWith)
{
	CVOString	strSearchFor(pcszSearchFor);
	CVOString	strReplaceWith(pcszReplaceWith);
	CVOString	strRemain;

	if(strReplaceWith.Find(strSearchFor) != -1)
		return 0;	// Would be infinite loop

	DWORD	dwCount = 0;
	int		nMatch = -1;

	while((nMatch = Find(strSearchFor, nMatch + 1)) != -1)
	{
		strRemain = Mid(nMatch + strSearchFor.GetLength());
		*this = Left(nMatch);
		*this += strReplaceWith;
		*this += strRemain;

		nMatch += strReplaceWith.GetLength() - 1;
		dwCount++;
	}

	return dwCount;
}

#define SZ_QUOTE			TEXT("\"")
#define SZ_QUOTE_ENCODED	TEXT("%22")

CVOString CVOString::AddQuotes(LPCTSTR pcszValue, TCHAR chQuote)
{
	CVOString strValue(pcszValue);

	strValue.Replace(SZ_QUOTE, SZ_QUOTE_ENCODED);

	CVOString strNewValue;
	
	strNewValue += chQuote;
	strNewValue += strValue;
	strNewValue += chQuote;

	return strNewValue;
}

CVOString CVOString::RemoveQuotes(LPCTSTR pcszValue)
{
	CVOString strValue(pcszValue);

	if(strValue.GetLength() < 2)
		return strValue;

	if(	(strValue.GetAt(0) == CH_QUOTE) && 
		(strValue.GetAt(strValue.GetLength() - 1) == CH_QUOTE) )
		strValue = strValue.Mid(1, strValue.GetLength() - 2);

	strValue.Replace(SZ_QUOTE_ENCODED, SZ_QUOTE);

	return strValue;
}

CVOString CVOString::DescribeErrorMessage(DWORD dwError)
{   
	CVOString strDescription;
#ifdef WIN32
    LPVOID lpMsgBuf;
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,    
                  NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
                  (LPTSTR) &lpMsgBuf, 0, NULL);
	strDescription = (LPCTSTR) lpMsgBuf;
    LocalFree(lpMsgBuf);     
#endif

	return strDescription;
}

BOOL CVOString::ToSystemTime(SYSTEMTIME &st, DWORD dwFlags)
{
#ifdef WIN32_PLATFORM_WFSP
	return FALSE;
#else
	#ifdef WIN32
		USES_CONVERSION;

		DATE	dt;
		SCODE	sc;

		if (FAILED(sc = VarDateFromStr((LPOLESTR)T2COLE(m_pBuffer), LANG_USER_DEFAULT, dwFlags, &dt)))
		{
			if (sc == DISP_E_TYPEMISMATCH)
			{
				OutputDebugString(TEXT("CVOString::ToSystemTime() Failed - Type Mismatch\n"));
				
				return FALSE;
			}
			else if (sc == DISP_E_OVERFLOW)
			{
				OutputDebugString(TEXT("CVOString::ToSystemTime() Failed - Overflow\n"));

				return FALSE;
			}
			else
			{
				OutputDebugString(TEXT("CVOString::ToSystemTime() Failed\n"));

				return FALSE;
			}
		}

		VariantTimeToSystemTime(dt, &st);

		return TRUE;
	#else
		return FALSE;
	#endif
#endif
}

BOOL CVOString::ParseSystemTime(SYSTEMTIME &st, DWORD dwFlags)
{
#ifdef WIN32_PLATFORM_WFSP
	return FALSE;
#else
	#ifdef WIN32
		USES_CONVERSION;

		DATE dt;

		SystemTimeToVariantTime(&st, &dt);

		CComBSTR bstrDate;

		if(VarBstrFromDate(dt, LANG_USER_DEFAULT, dwFlags, &bstrDate) != S_OK)
			return FALSE;

		*this = bstrDate;

		return TRUE;
	#else
		return FALSE;
	#endif
#endif
}

CVOString CVOString::EncodeHex(LPCTSTR pcszValue)
{
	if(!pcszValue)
		return CVOString(TEXT(""));

	static TCHAR hexChar[] = {	TCHAR('0'), TCHAR('1'), TCHAR('2'), TCHAR('3'),
								TCHAR('4'), TCHAR('5'), TCHAR('6'), TCHAR('7'),
								TCHAR('8'), TCHAR('9'), TCHAR('A'), TCHAR('B'),
								TCHAR('C'), TCHAR('D'), TCHAR('E'), TCHAR('F') };
	CVOString strValue;

	LPCTSTR pcszCur = pcszValue;

	unsigned char chCur;

	while(*pcszCur)
	{
		chCur = (unsigned char)(*pcszCur);
		strValue += hexChar[chCur >> 4];
		strValue += hexChar[chCur & 0xF];
		pcszCur++;
	}

	return strValue;
}

CVOString CVOString::DecodeHex(LPCTSTR pcszValue)
{
	CVOString strValue(pcszValue);
	CVOString strDecoded;

	strValue.MakeUpper();

	if(strValue.GetLength() % 2)	// Uneven hex pairs
		return CVOString(TEXT(""));

	unsigned char	ch;
	TCHAR			nibHigh, nibLow;

	for(int nChar = 0; nChar < (int)strValue.GetLength() / 2; nChar++)
	{
		ch = 0;

		nibHigh = strValue.GetAt(nChar * 2);
		nibLow = strValue.GetAt(nChar * 2 + 1);

		switch(nibHigh)
		{
		case TCHAR('0'):
		case TCHAR('1'):
		case TCHAR('2'):
		case TCHAR('3'):
		case TCHAR('4'):
		case TCHAR('5'):
		case TCHAR('6'):
		case TCHAR('7'):
		case TCHAR('8'):
		case TCHAR('9'):
			ch += (unsigned char)(nibHigh - TCHAR('0'));
			break;

		case TCHAR('A'):
		case TCHAR('B'):
		case TCHAR('C'):
		case TCHAR('D'):
		case TCHAR('E'):
		case TCHAR('F'):
			ch += (unsigned char)(nibHigh - TCHAR('A') + 10);
			break;
		}

		ch = ch << 4;

		switch(nibLow)
		{
		case TCHAR('0'):
		case TCHAR('1'):
		case TCHAR('2'):
		case TCHAR('3'):
		case TCHAR('4'):
		case TCHAR('5'):
		case TCHAR('6'):
		case TCHAR('7'):
		case TCHAR('8'):
		case TCHAR('9'):
			ch += (unsigned char)(nibLow - TCHAR('0'));
			break;

		case TCHAR('A'):
		case TCHAR('B'):
		case TCHAR('C'):
		case TCHAR('D'):
		case TCHAR('E'):
		case TCHAR('F'):
			ch += (unsigned char)(nibLow - TCHAR('A') + 10);
			break;
		}

		strDecoded += (TCHAR)ch;
	}

	return strDecoded;
}

BOOL CVOString::PopElement(CVOString& strValue, CVOString& strSource, const CVOString& strDelim)
{
	BOOL			fDoubleQuote = FALSE;
	BOOL			fSingleQuote = FALSE;
	int				nOffset = 0;

	strSource.TrimLeft();

	if(strSource.GetLength() == 0)
		return FALSE;

	if(strSource.GetAt(nOffset) == TCHAR('\"'))	// Double quoted element
	{
		fDoubleQuote = TRUE;
		nOffset++;
	}
	else if(strSource.GetAt(nOffset) == TCHAR('\''))	// Single quoted element
	{
		fSingleQuote = TRUE;
		nOffset++;
	}

	while(nOffset < (int)strSource.GetLength())
	{
		if( (fSingleQuote && (strSource.GetAt(nOffset) == TCHAR('\''))) ||
			(fDoubleQuote && (strSource.GetAt(nOffset) == TCHAR('\"'))) )
		{
			strValue = strSource.Mid(1, nOffset - 1);
			strSource = strSource.Mid(nOffset + 2);
			strValue.TrimLeft();
			strValue.TrimRight();
			return TRUE;
		}
		else if((!fSingleQuote && !fDoubleQuote) && (strDelim.Find(strSource.GetAt(nOffset)) != -1) )
		{
			strValue = strSource.Left(nOffset);
			strSource = strSource.Mid(nOffset + 1);
			strValue.TrimLeft();
			strValue.TrimRight();
			return TRUE;
		}

		nOffset++;
	}

	// Reached the end of the string.  Return remainder
	strValue = strSource;
	strSource = TEXT("");
	strValue.TrimLeft();
	strValue.TrimRight();

	return TRUE;
}

BOOL CVOString::StartsWith(LPCTSTR pcszValue, BOOL fMatchCase)
{
	if(!pcszValue)
		return FALSE;

	CVOString strValue(pcszValue);

	if(fMatchCase)
		return Left(strValue.GetLength()) == strValue;

	return (Left(strValue.GetLength()).CompareNoCase(strValue) == 0);
}

BOOL CVOString::EndsWith(LPCTSTR pcszValue, BOOL fMatchCase)
{
	if(!pcszValue)
		return FALSE;

	CVOString strValue(pcszValue);

	if(fMatchCase)
		return Right(strValue.GetLength()) == strValue;

	return (Right(strValue.GetLength()).CompareNoCase(strValue) == 0);
}

BOOL CVOString::Contains(LPCTSTR pcszValue, BOOL fMatchCase)
{
	if(!pcszValue)
		return FALSE;

	CVOString strValue(pcszValue);

	if(fMatchCase)
		return(Find(pcszValue) != -1);

	// Case insensitive search
	static CVOString strLast;
	static CVOString strUpper;

	if(strLast != *this)	// The UC buffer is stored because it is not uncommon to call this repeatedly on the same string
	{
		strLast = *this;
		strUpper = *this;
		strUpper.MakeUpper();
	}

	strValue.MakeUpper();

	return(strUpper.Find(strValue) != -1);
}

BOOL CVOString::LoadString(HINSTANCE hInstance, DWORD dwResourceID)
{     
#ifdef _DOS
	return FALSE;
#else
	int nBytesCopied = ::LoadString(hInstance, dwResourceID, GetBuffer(1024), 1024);

	ReleaseBuffer();

	return (nBytesCopied > 0);
#endif
}

CVOString CVOString::ToHTML()
{
	CVOString	strHTML;
	TCHAR		ch;
	int			nStartRawSeq = -1, nEndRawSeq = -1;
	CVOString	strEncodedChar;

	strHTML.GetBuffer(GetLength() * 2);	// So that buffer doesn't keep being resized as appended

	for(DWORD dwOffset = 0; dwOffset < GetLength(); dwOffset++)
	{
		ch = GetAt(dwOffset);

		if( (ch >= 'A' && ch <= 'Z') ||
			(ch >= 'a' && ch <= 'z') ||
			(ch >= '0' && ch <= '9'))
		{
			if(nStartRawSeq == -1)
				nStartRawSeq = dwOffset;
			nEndRawSeq = dwOffset;
		}
		else
		{
			if(nStartRawSeq != -1)
			{
				strHTML += Mid(nStartRawSeq, nEndRawSeq - nStartRawSeq + 1);
				nStartRawSeq = -1;
			}

			strEncodedChar.Format(TEXT("%%%02x"), ch);
			strHTML += strEncodedChar;
		}
	}

	if(nStartRawSeq != -1)
	{
		strHTML += Mid(nStartRawSeq, nEndRawSeq - nStartRawSeq + 1);
		nStartRawSeq = -1;
	}

	strHTML.ReleaseBuffer();

	return strHTML;
}

BOOL CVOString::ParseHTML(CVOString strHTML)
{
	strHTML.Replace(TEXT("&quot;"), TEXT("\""));
	strHTML.Replace(TEXT("&gt;"), TEXT(">"));
	strHTML.Replace(TEXT("&lt;"), TEXT("<"));

/*	int nStart = 0;

	while((nStart = strHTML.Find(TCHAR('%'), nStart)) != -1)
*/

	*this = strHTML;
	return TRUE;
}