www.pudn.com > realtime.rar > Str.cpp, change:2000-05-26,size:7639b


#include <stdio.h> 
#include <assert.h> 
#include <math.h> 
#include <stdlib.h> 
#include "Str.h" 
 
CStr::CStr(const char* str) 
{ 
	if(str == 0) 
	{ 
		m_nLength = 0; 
		m_pString = 0; 
	} 
	else 
	{ 
		m_nLength = strlen(str); 
		m_pString = new char[m_nLength + 1]; 
		assert(m_pString != 0); 
		strcpy(m_pString, str); 
	} 
} 
 
CStr::CStr(const CStr& str) 
{  
	if(str == 0) 
	{ 
		m_nLength = 0; 
		m_pString = 0; 
	} 
	else 
	{ 
		m_nLength = str.m_nLength;  
		m_pString = new char[m_nLength + 1]; 
		assert(m_pString != 0); 
		strcpy(m_pString, str.m_pString);  
	} 
} 
 
CStr& CStr::operator +=(const CStr& str) 
{ 
	m_nLength += str.m_nLength; 
	char* pNew = new char[m_nLength + 1]; 
	assert(pNew != 0); 
	strcpy(pNew, m_pString); 
	strcat(pNew, str.m_pString); 
	delete m_pString; 
	m_pString = pNew; 
 
	return *this; 
} 
 
CStr& CStr::operator =(const char* str) 
{ 
	if (m_pString) delete m_pString; 
	m_nLength = strlen(str); 
	m_pString = new char[m_nLength + 1];  
	assert(m_pString != 0); 
	strcpy(m_pString, str); 
 
	return *this; 
} 
 
CStr& CStr::operator =(const CStr& str) 
{ 
	assert(str != 0); 
	if (m_pString) delete m_pString; 
	m_nLength = strlen(str.m_pString); 
	m_pString = new char[m_nLength + 1];  
	assert(m_pString != 0); 
	strcpy(m_pString, str.m_pString); 
 
	return *this; 
} 
 
void CStr::VarToString(const double var) 
{ 
	char str[32]; 
 
	gcvt(var, 16, str); 
	m_nLength = strlen(str); 
	if (str[m_nLength - 1] == '.') 
	{ 
		str[m_nLength - 1] = '\0'; 
		m_nLength --; 
	} 
	m_nLength = strlen(str); 
	m_pString = new char[m_nLength + 1]; 
	assert(m_pString != 0); 
	strcpy(m_pString, str); 
} 
 
int CStr::Format(const char* format, ...) 
{ 
	assert(format != 0); 
 
	int len; 
	char* MaxBuf; 
	for(int i = 5; ; i ++) 
	{ 
		len = (int)pow(2, i); 
		MaxBuf = new char[len]; 
		if (!MaxBuf) return 0; 
		// some UNIX's do not support vsnprintf and snprintf 
		len = _vsnprintf(MaxBuf, len, format, (char*)(&format + 1)); 
		if (len > 0) break; 
		delete []MaxBuf; 
		if (len == 0) return 0; 
	} 
 
	if (!m_pString) 
	{ 
		m_nLength = len; 
		m_pString = new char[m_nLength + 1]; 
	} 
	else if (m_nLength < len) 
	{ 
		delete m_pString; 
		m_nLength = len; 
		m_pString = new char[m_nLength + 1]; 
	} 
	if (m_pString)  
		strcpy(m_pString, MaxBuf); 
	else 
		len = 0; 
	delete []MaxBuf; 
 
	return len; 
} 
 
bool CStr::Match(char* Wildcards, char* str) 
{ 
	bool Yes = 1; 
 
	//iterate and delete '?' and '*' one by one 
	while(*Wildcards != '\0' && Yes && *str != '\0') 
	{ 
		if (*Wildcards == '?') str ++; 
		else if (*Wildcards == '*') 
		{ 
			Yes = Scan(Wildcards, str); 
			Wildcards --; 
		} 
		else 
		{ 
			Yes = (*Wildcards == *str); 
			str ++; 
		} 
		Wildcards ++; 
	} 
	while (*Wildcards == '*' && Yes)  Wildcards ++; 
 
	return Yes && *str == '\0' && *Wildcards == '\0'; 
} 
 
// scan '?' and '*' 
bool CStr::Scan(char*& Wildcards, char*& str) 
{ 
	// remove the '?' and '*' 
	for(Wildcards ++; *str != '\0' && (*Wildcards == '?' || *Wildcards == '*'); Wildcards ++) 
		if (*Wildcards == '?') str ++; 
	while ( *Wildcards == '*') Wildcards ++; 
	 
	// if str is empty and Wildcards has more characters or, 
	// Wildcards is empty, return  
	if (*str == '\0' && *Wildcards != '\0') return false; 
	if (*str == '\0' && *Wildcards == '\0')	return true;  
	// else search substring 
	else 
	{ 
		char* wdsCopy = Wildcards; 
		char* strCopy = str; 
		bool  Yes     = 1; 
		do  
		{ 
			if (!Match(Wildcards, str))	strCopy ++; 
			Wildcards = wdsCopy; 
			str		  = strCopy; 
			while ((*Wildcards != *str) && (*str != '\0')) str ++; 
			wdsCopy = Wildcards; 
			strCopy = str; 
		}while ((*str != '\0') ? !Match(Wildcards, str) : (Yes = false) != false); 
 
		if (*str == '\0' && *Wildcards == '\0')	return true; 
 
		return Yes; 
	} 
} 
 
bool CStr::NumericParse(void* pvar, char flag) 
{ 
	assert(m_pString != 0); 
	char* pTmpStr = m_pString; 
 
	// remove the leading ' ' and '\t' at the beginning 
	while (*pTmpStr == ' ' || *pTmpStr == '\t') 
		pTmpStr++; 
 
	// no desired character found 
	if (strlen(pTmpStr) == 0) 
		return false; 
 
	char a = pTmpStr[0]; 
	if ((flag == 'b' || flag == 'C' || flag == 'S' ||  
		flag == 'I' || flag == 'L') && a == '-') 
		return false; 
 
	if (flag == 'b') 
	{ 
		bool var; 
		if (strcmp(pTmpStr, "true") == 0 || strcmp(pTmpStr, "1") == 0 || 
			strcmp(pTmpStr, "TRUE") == 0) var = true; 
		else if (strcmp(pTmpStr, "false") == 0 || strcmp(pTmpStr, "0") == 0 || 
			strcmp(pTmpStr, "FALSE") == 0) var = false; 
		else // failed 
			return false; 
		memcpy(pvar, &var, sizeof(bool)); 
		return true; 
	} 
	else 
	{ 
		double tmpvar = strtod(pTmpStr, (char**)&pTmpStr); 
		if (tmpvar == 0.0 && a != '0') 
			return false;   // convertion wrong 
 
		if (flag == 'f' || flag == 'd') 
		{ 
			// allow any float value with one 'f' or 'F' terminated 
			if (*pTmpStr == 'f' || *pTmpStr == 'F')  
				pTmpStr++; 
		} 
		else if (flag == 'l' || flag == 'L') 
		{ 
			// allow any float value with one 'l' or 'L terminated 
			if (*pTmpStr == 'l' || *pTmpStr == 'L')  
				pTmpStr++; 
		} 
 
		switch(flag) 
		{ 
		case 'c': 
			{ 
				//if (tmpvar < -(0xff / 2 + 1) || tmpvar > 0xff / 2) 
				if (tmpvar < -128 || tmpvar > 127) 
					return false;   // onerflow 
				char var = (char)tmpvar; 
				memcpy(pvar, &var, sizeof(char)); 
			} 
			break; 
		case 's': 
			{ 
				//if (tmpvar < -(0xffff / 2 + 1) || tmpvar > 0xffff / 2) 
				if (tmpvar < -32768.0 || tmpvar > 32768.0) 
					return false;   // onerflow 
				short var = (short)tmpvar; 
				memcpy(pvar, &var, sizeof(short)); 
			} 
			break; 
		case 'i': 
			{ 
				//if (tmpvar < -(0xffffffff / 2 + 1) || tmpvar > 0xffffffff / 2) 
				if (tmpvar < -2147483648.0 || tmpvar > 2147483647.0) 
					return false;   // onerflow 
				int var = (int)tmpvar; 
				memcpy(pvar, &var, sizeof(int)); 
			} 
			break; 
		case 'l': 
			{ 
				//if (tmpvar < -(0xffffffff / 2 + 1) || tmpvar > 0xffffffff / 2) 
				if (tmpvar < -2147483648.0 || tmpvar > 2147483647.0) 
					return false;   // onerflow 
				long var = (long)tmpvar; 
				memcpy(pvar, &var, sizeof(long)); 
 
			} 
			break; 
		case 'C': 
			{ 
				//if (tmpvar < 0 || tmpvar > 0xff) 
				if (tmpvar < 0.0 || tmpvar > 255) 
					return false;   // onerflow 
				unsigned char var = (unsigned char)tmpvar; 
				memcpy(pvar, &var, sizeof(unsigned char)); 
			} 
			break; 
		case 'S': 
			{ 
				//if (tmpvar < 0 || tmpvar > 0xffff) 
				if (tmpvar < 0.0 || tmpvar > 65535.0) 
					return false;   // onerflow 
				unsigned short var = (unsigned short)tmpvar; 
				memcpy(pvar, &var, sizeof(unsigned short)); 
			} 
			break; 
		case 'I': 
			{ 
				//if (tmpvar < 0 || tmpvar > 0xffffffff) 
				if (tmpvar < 0.0 || tmpvar > 4294967295.0) 
					return false;   // onerflow 
				unsigned int var = (unsigned int)tmpvar; 
				memcpy(pvar, &var, sizeof(unsigned int)); 
			} 
			break; 
		case 'L': 
			{ 
				//if (tmpvar < 0 || tmpvar > 0xffffffff) 
				if (tmpvar < 0.0 || tmpvar > 4294967295.0) 
					return false;   // onerflow 
				unsigned long var = (unsigned long)tmpvar; 
				memcpy(pvar, &var, sizeof(unsigned long)); 
			} 
			break; 
		case 'f': 
			{ 
				if (tmpvar < -3.402823466e+38 || tmpvar > 3.402823466e+38) 
					return false;   // onerflow 
				float var = (float)tmpvar; 
				memcpy(pvar, &var, sizeof(float)); 
			} 
			break; 
		case 'd': 
			memcpy(pvar, &tmpvar, sizeof(double)); 
			break; 
		} 
 
		// remove the leading ' ' and '\t' at the end 
		while (*pTmpStr == ' ' || *pTmpStr == '\t') 
			pTmpStr++; 
 
		if (*pTmpStr != '\0') 
			return false;   // non digital character detected 
 
		return true; 
	} 
}