strex.h

一个基于字符串的封装类

#pragma once

#include <string>
#include <xstring>
#include <TCHAR.h>
#include <CSDBG.h>

#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS	// some CString constructors will be explicit
#include <atlbase.h>
#include <atlstr.h>

//---------------------------------------------------
// Summary:
//		字符串模板定义类
// Remarks:
//		内部使用std类的字符串处理类string或者wstring，
//		这里做一些包装，以便使用更加方便
//---------------------------------------------------
template <class CHAR_T>
class CSimpleStrImplT : public std::basic_string<CHAR_T, std::char_traits<CHAR_T>, std::allocator<CHAR_T> >
{
	typedef std::basic_string<CHAR_T, std::char_traits<CHAR_T>, std::allocator<CHAR_T> >CStdBasicString;
public:
	//---------------------------------------------------
	// Summary:
	// 模板类空构造函数
	//---------------------------------------------------
	CSimpleStrImplT()
		: CStdBasicString()
	{
	}

	//---------------------------------------------------
	// 析构函数，释放资源
	//---------------------------------------------------
	~CSimpleStrImplT()
	{
	}

	//---------------------------------------------------
	// Summary:
	//		带初始化值的构造函数
	// Parameters:
	//		psz - 初始化字符串指针
	//---------------------------------------------------
	CSimpleStrImplT(const CHAR_T* psz)
		: CStdBasicString(psz)
	{
	}

	//---------------------------------------------------
	// Summary:
	//		带初始化值的构造函数
	// Parameters:
	//		psz     - 初始化字符串指针
	//		nLength - 指定初始化长度
	//---------------------------------------------------
	CSimpleStrImplT(const CHAR_T* psz, INT32 nLength)
		: CStdBasicString(psz,nLength)
	{
	}

	//---------------------------------------------------
	// Summary:
	//		测试内容是否为空
	// Returns:
	//		如果为空返回TRUE，否则返回FALSE。
	//---------------------------------------------------
	BOOL IsEmpty()
	{
		return (BOOL)empty();
	}

	//---------------------------------------------------
	// Summary:
	//		获取内容的长度
	// Returns:
	//		返回字符串的长度
	//---------------------------------------------------
	INT32 GetLength()
	{
		return (INT32)size();
	}

	CHAR_T* GetData()
	{
		return (CHAR_T*)c_str();
	}

	operator const CHAR_T *() const throw()
	{
		return c_str();
	}

	operator const void *() const throw()
	{
		return (const void *)c_str();
	}

	CSimpleStrImplT Mid(INT32 nStart,INT32 nCount=-1) const
	{
		if(nCount == 0)	// 返回一个空字符串
		{
			return CSimpleStrImplT();
		}

		INT32 nLength = (INT32)size();
		if (nStart < 0)
		{
			nStart = 0;
		}
		else if( nStart >= nLength )
		{
			return CSimpleStrImplT();
		}

		if ( (nCount < 0) || (nStart+nCount > nLength) )	// 取从开始位置之后所有的数据
		{
			if(nStart == 0)
				return (*this);

			return CSimpleStrImplT( substr(nStart).c_str() );
		}

		return CSimpleStrImplT( (CHAR_T*)substr(nStart,nCount).c_str() );
	}

	CSimpleStrImplT Left(INT32 nCount)
	{
		// nCount is in XCHARs
		if (nCount <= 0)
		{
			return CSimpleStrImplT();
		}

		if( nCount >= (INT32)size() )
		{
			return( *this );
		}

		return CSimpleStrImplT( (CHAR_T*)substr(0,nCount).c_str() );
	}

	CSimpleStrImplT Right(INT32 nCount)
	{
		// nCount is in XCHARs
		if (nCount <= 0)
		{
			return CSimpleStrImplT();
		}

		INT32 nLength = (INT32)size();
		if( nCount >= nLength )
		{
			return( *this );
		}
		return CSimpleStrImplT( (CHAR_T*)substr(nLength-nCount,nCount).c_str() );
	}

	INT32 Find(CHAR_T* psz, INT32 nStartPos=0)
	{
		size_type pos = find(psz,(size_type)nStartPos);
		if(pos == npos)
			return -1;
		return (INT32)pos;
	}

	INT32 Find(CHAR_T ch, INT32 nStartPos=0)
	{
		size_type pos = find(ch,(size_type)nStartPos);
		if(pos == npos)
			return -1;
		return (INT32)pos;
	}

	INT32 ReverseFind(CHAR_T ch, INT32 nStartPos=-1)
	{
		size_type pos = rfind(ch,nStartPos == -1 ? npos : (size_type)nStartPos);
		if(pos == npos)
			return -1;
		return (INT32)pos;
	}

	CHAR_T operator[](INT32 nIndex) const
	{
		return (CHAR_T)at(nIndex);
	}

	void ToUpper()
	{
		INT32 nLen = (INT32)size();
		if(nLen <= 0)
			return;

		CHAR_T* pBuf = GetData();
		for(INT32 i=0; i<nLen; i++)
		{
			if(pBuf[i] >= 'a' && pBuf[i] <= 'z')
			{
				pBuf[i] = (CHAR_T)(pBuf[i]-32);
			}
		}
	}

	void ToLower()
	{
		INT32 nLen = (INT32)size();
		if(nLen <= 0)
			return;

		CHAR_T* pBuf = GetData();
		for(INT32 i=0; i<nLen; i++)
		{
			if(pBuf[i] >= 'A' && pBuf[i] <= 'Z')
			{
				pBuf[i] = (CHAR_T)(pBuf[i]+32);
			}
		}
	}

	// Return the number of replaced instances of the character or substring. Zero if the string is not changed.
	int Replace(const CHAR_T *pszOld, const CHAR_T *pszNew)
	{
		int nOldLen = std_strlen(pszOld);
		int nNewLen = std_strlen(pszNew);

		int nRepCount = 0;
		size_type nStartPos = 0;
		size_type pos = find(pszOld, nStartPos);
		while(pos != npos)
		{
			nRepCount++;
			replace(pos,nOldLen,pszNew);
			nStartPos = pos+nNewLen;
			pos = find(pszOld, nStartPos);
		}

		return nRepCount;
	}

	int std_strlen(const char *pszString)	{return (int)strlen(pszString);}
	int std_strlen(const wchar_t *pszString)	{return (int)wcslen(pszString);}


	int std_vscprintf(const char * pszFormat, va_list ArgList)		{return _vscprintf(pszFormat, ArgList);}
	int std_vscprintf(const wchar_t * pszFormat, va_list ArgList)	{return _vscwprintf(pszFormat, ArgList);}


	int std_printf_s(char * pszDst, size_t nSizeInWords, const char * pszFormat, va_list ArgList)			{return vsprintf_s(pszDst, nSizeInWords, pszFormat, ArgList);}
	int std_printf_s(wchar_t * pszDst, size_t nSizeInWords, const wchar_t * pszFormat, va_list ArgList)		{return vswprintf_s(pszDst, nSizeInWords, pszFormat, ArgList);}
	
	void Format(const CHAR_T * pszFormat,...)
	{
		va_list args;
		va_start( args, pszFormat );
		INT32 nLength  = std_vscprintf(pszFormat,args);
		CHAR_T *szBuffer = new CHAR_T[nLength+1];
		if(szBuffer)
		{
			std_printf_s(szBuffer,nLength+1,pszFormat,args);
			assign(szBuffer);
			delete [] szBuffer;
		}
	}



	//----------------------------------------------------
	// Summary:
	//     Convert digit to char
	//----------------------------------------------------
	CHAR_T x2c(const CHAR_T *what)
	{
		CHAR_T digit;

	#ifndef CHARSET_EBCDIC
		digit = ((what[0] >= 'A') ? ((what[0] & 0xdf) - 'A') + 10 : (what[0] - '0'));
		digit *= 16;
		digit += (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A') + 10 : (what[1] - '0'));
	#else /*CHARSET_EBCDIC*/
		char xstr[5];
		xstr[0]='0';
		xstr[1]='x';
		xstr[2]=what[0];
		xstr[3]=what[1];
		xstr[4]='\0';
		digit = os_toebcdic[0xFF & ap_strtol(xstr, NULL, 16)];
	#endif /*CHARSET_EBCDIC*/
		return (digit);
	}

	//----------------------------------------------------
	// Summary:
	//     Unescapes a URL.
	// Returns:
	//     Return TRUE on success, FALSE on error
	// Failure is due to
	//    bad % escape
	// 
	//    decoding %00 -> \0  (the null character)
	//    decoding %2f -> /   (a special character)
	//----------------------------------------------------
	BOOL UnescapeUrl()
	{
		INT32 nLen = (INT32)size();
		if(nLen <= 0)
			return FALSE;

		CHAR_T* pBuf = GetData();

		int x, y;
		
		BOOL bBadEsc = FALSE;
		for (x = 0, y = 0; y<nLen && x<nLen; x++, y++)
		{
			if (pBuf[y] != '%')
				pBuf[x] = pBuf[y];
			else
			{
				if (!isxdigit(pBuf[y + 1]) || !isxdigit(pBuf[y + 2]))
				{
					bBadEsc = TRUE;
					pBuf[x] = '%';
				}
				else
				{
					pBuf[x] = x2c(&pBuf[y + 1]);
					y += 2;
				}
			}
		}
		resize(x);
		return bBadEsc;
	}
};

template <class CHAR_T>
class CStrImplT: public CSimpleStrImplT<CHAR_T>
{
public:
	CStrImplT() : CSimpleStrImplT()
	{
	}

	//---------------------------------------------------
	// Summary:
	//		带初始化值的构造函数
	// Parameters:
	//		psz - 初始化字符串指针
	//---------------------------------------------------
	CStrImplT(const CHAR_T* psz)
		: CSimpleStrImplT(psz)
	{
	}

	//---------------------------------------------------
	// Summary:
	//		带初始化值的构造函数
	// Parameters:
	//		psz     - 初始化字符串指针
	//		nLength - 指定初始化长度
	//---------------------------------------------------
	CStrImplT(const CHAR_T* psz, INT32 nLength)
		: CSimpleStrImplT(psz,nLength)
	{
	}

	//---------------------------------------------------
	// Summary:
	//		赋值操作符
	//---------------------------------------------------
	CStrImplT& operator=( const CHAR_T* psz)
	{
		assign(psz);
		return (*this);
	}


	//---------------------------------------------------
	// Summary:
	//		赋值UTF8字符串
	//---------------------------------------------------
	BOOL AssignUTF8(const char * /*pszUtf8String*/)
	{
		return FALSE;
	}
};

//---------------------------------------------------
// Summary:
//	A specialization of a class template CStrImplT for ANSI string
//---------------------------------------------------
template <>
class CStrImplT<char> : public CSimpleStrImplT<char>
{
public:
	CStrImplT(){}

public:
	CStrImplT(const char* psz)
	{
		Assign(psz);
	}

	CStrImplT(const char* psz, INT32 nLength)
	{
		if(nLength >= (INT32)strlen(psz))
			Assign(psz);
		else
			Assign(psz, nLength);
	}

	CStrImplT(const wchar_t* psz)
	{
		CW2A str(psz);
		Assign(str);
	}


	CStrImplT& operator=( const char* psz)
	{
		Assign(psz);
		return (*this);
	}

	CStrImplT& operator=( const wchar_t* psz)
	{
		CW2A str(psz);
		Assign(str);
		return (*this);
	}

	void Assign(const char* psz, INT32 nLength=-1)
	{
		if(psz != NULL)
		{
			if(nLength == -1)
				assign(psz);
			else
				assign(psz, nLength);
		}
		else
		{
			assign("");
		}
	}

	//---------------------------------------------------
	// Summary:
	//		赋值UTF8字符串 (UTF8 String to Ansi String)
	//---------------------------------------------------
	BOOL AssignUTF8(const char *pszUtf8String)
	{
		int nLength = MultiByteToWideChar(CP_UTF8,0,pszUtf8String,-1,NULL,0);
		wchar_t *pData = new wchar_t[nLength+1];
		if(pData == NULL)
			return FALSE;
		int nDataLen = MultiByteToWideChar(CP_UTF8, 0, pszUtf8String, -1, pData, nLength);
		if(nDataLen > nLength)
		{
			delete [] pData;
			return FALSE;
		}
		pData[nDataLen] = 0;
		CW2A str(pData);
		assign(str);
		delete [] pData;
		return TRUE;
	}
};


//---------------------------------------------------
// Summary:
//	A specialization of a class template CStrImplT for Unicode string
//---------------------------------------------------
template <>
class CStrImplT<wchar_t> : public CSimpleStrImplT<wchar_t>
{
public:
	CStrImplT(){}

public:
	CStrImplT(const wchar_t* psz)
	{
		Assign(psz);
	}

	CStrImplT(const wchar_t* psz, INT32 nLength)
	{
		if(nLength >= (INT32)wcslen(psz))
			Assign(psz);
		else
			Assign(psz);
	}

	CStrImplT(const char* psz)
	{
		CA2W str(psz);
		Assign(str);
	}

	CStrImplT& operator=( const wchar_t* psz)
	{
		Assign(psz);
		return (*this);
	}

	CStrImplT& operator=( const char* psz)
	{
		CA2W str(psz);
		Assign(str);
		return (*this);
	}

	void Assign(const wchar_t* psz, INT32 nLength=-1)
	{
		if(psz != NULL)
		{
			if(nLength == -1)
				assign(psz);
			else
				assign(psz, nLength);
		}
		else
		{
			assign(L"");
		}
	}

	//---------------------------------------------------
	// Summary:
	//		赋值UTF8字符串 (UTF8 String to Unicode String)
	//---------------------------------------------------
	BOOL AssignUTF8(const char *pszUtf8String)
	{
		int nLength = MultiByteToWideChar(CP_UTF8,0,pszUtf8String,-1,NULL,0);
		wchar_t *pData = new wchar_t[nLength+1];
		if(pData == NULL)
			return FALSE;
		int nDataLen = MultiByteToWideChar(CP_UTF8, 0, pszUtf8String, -1, pData, nLength);
		if(nDataLen > nLength)
		{
			delete [] pData;
			return FALSE;
		}
		pData[nDataLen] = 0;
		assign(pData);
		delete [] pData;
		return TRUE;
	}
};

//---------------------------------------------------
// Summary:
//	A class template for UTF8 string
//---------------------------------------------------
template <class T>
class CStrUTF8ImplT: public T
{
public:
	CStrUTF8ImplT() : T(),m_pUTF8Data(NULL)
	{
	}

	~CStrUTF8ImplT()
	{
		if(m_pUTF8Data)
		{
			delete m_pUTF8Data;
			m_pUTF8Data = NULL;
		}
	}
	//---------------------------------------------------
	// Summary:
	//		赋值Unicode字符串
	//---------------------------------------------------
	CStrUTF8ImplT(const wchar_t* pszUnicode) : m_pUTF8Data(NULL)
	{
		Assign(pszUnicode);
	}

	//---------------------------------------------------
	// Summary:
	//		赋值UTF8字符串 (UTF8 String to Unicode String)
	//---------------------------------------------------
	CStrUTF8ImplT(const char* pszUTF8) : m_pUTF8Data(NULL)
	{
		AssignUTF8(pszUTF8);
	}

	//---------------------------------------------------
	// Summary:
	//		赋值Unicode字符串
	//---------------------------------------------------
	CStrUTF8ImplT& operator=( const wchar_t* pszUnicode)
	{
		Assign(pszUnicode);
		return (*this);
	}

	//---------------------------------------------------
	// Summary:
	//		赋值UTF8字符串 (UTF8 String to Unicode String)
	//---------------------------------------------------
	CStrUTF8ImplT& operator=( const char* pszUTF8)
	{
		AssignUTF8(pszUTF8);
		return (*this);
	}

	//---------------------------------------------------
	// Summary:
	//     Return unicode string
	//---------------------------------------------------
	operator const wchar_t *() const throw()
	{
		return c_str();
	}

	//---------------------------------------------------
	// Summary:
	//     Unicode to UTF-8
	//---------------------------------------------------
	operator const char *() throw()
	{
		if(m_pUTF8Data)
		{
			delete m_pUTF8Data;
			m_pUTF8Data = NULL;
		}

		int nLength = WideCharToMultiByte(CP_UTF8,0,c_str(),-1,NULL,0,NULL,NULL);
		m_pUTF8Data = new char[nLength+1];
		if(m_pUTF8Data == NULL)
		{
			CSASSERT(FALSE);
			return "[NULL]";
		}
		int nDataLen = WideCharToMultiByte(CP_UTF8, 0, c_str(), -1, m_pUTF8Data, nLength,NULL,NULL);
		if(nDataLen > nLength)
		{
			delete [] m_pUTF8Data;
			m_pUTF8Data = NULL;
			CSASSERT(FALSE);
			return "[NULL]";
		}
		m_pUTF8Data[nDataLen] = 0;
		return m_pUTF8Data;
	}
protected:
	char *m_pUTF8Data;
};