Click here to Skip to main content
15,893,904 members
Search within:


Articles / Programming Languages / C++
 

Writing Windows Services - Made easy

Rate me:
Please Sign up or sign in to vote.
1.83/5 (32 votes)
11 Jun 20012 min read 196.2K   3.7K   55  
A framework for developing Windows services.
 
#include "cxstring.h"
#include <crtdbg.h>
#define ASSERTSTRING _ASSERT(m_pszString != NULL );

// FOR FUNCTION DESCRIPTIONS PLEASE REFER THE HEADER. SINCE THE CODE IS SELF-EXPLANATORY I HAVE NOT
// WRITTEN ANY COMMENTS

CXString::CXString() // default constructor 
{ m_pszString = NULL; }

CXString::CXString(const CXString &xString)
{
	m_pszString = new char[xString.Length()];
	memset(m_pszString,NULL,xString.Length());
	strcpy(m_pszString,xString.GetCharString());
}

CXString::CXString(char ch,int nRepeat) // for repeating the character the 'nRepeat' times
{
	m_pszString = new char[nRepeat + 1];
	memset(m_pszString,NULL,(nRepeat+1));
	for(int nCount=0;nCount<nRepeat;nCount++)
		m_pszString[nCount] = ch;
	m_pszString[nCount] = '\0';
}

CXString::CXString(char *pszString)
{
	m_pszString = new char[strlen(pszString)];
	strcpy(m_pszString,pszString);
}


CXString::CXString(int nVal)
{
	m_pszString = new char[7]; // with the calculation that the number will +/-64500 and the base it 10
	memset(m_pszString,NULL,7);
	itoa(nVal,m_pszString,10);
}

CXString::CXString(long lVal)
{
	m_pszString = new char[15]; // since its always base 10 else the size has to be 33 bytes
	memset(m_pszString,NULL,15);
	ltoa(lVal,m_pszString,10); // with base 10 
}

CXString::CXString(float fVal,int nDec)
{
	m_pszString = new char[15 + nDec ];
	memset(m_pszString,NULL,( 15 + nDec ));
	gcvt(fVal,nDec,m_pszString);
}

CXString::CXString(double dblVal,int nDec)
{
	m_pszString = new char[15 + nDec ];
	memset(m_pszString,NULL,( 15 + nDec ));
	gcvt(dblVal,nDec,m_pszString);
}

CXString::CXString(wchar_t wcsVal)
{
	m_pszString = new char[wcslen(&wcsVal)];
	memset(m_pszString,NULL,wcslen(&wcsVal));
	wcstombs(m_pszString,&wcsVal,wcslen(&wcsVal));
}

int CXString::Length() const
{
	if(m_pszString != NULL)	return strlen(m_pszString);
	else return 0;
}

char CXString::GetAt(int nPos)
{	
	ASSERTSTRING;
	return m_pszString[nPos]; 
}

void CXString::Empty()
{
	ASSERTSTRING;
	memset(m_pszString,NULL,this->Length());
	delete[] m_pszString;
}

bool CXString::IsEmpty()
{
	if( this->Length() == 0 ) return true;  // returns true if the string is empty
	else return false; // returns false if there is something on the string
}

void CXString::SetAt(char nChar,int nPos)
{
	ASSERTSTRING;
	m_pszString[nPos] = nChar;
}

int CXString::Compare(CXString *cxsNewString)
{
	ASSERTSTRING;
	return strcmp(m_pszString,cxsNewString->GetCharString());
}

int CXString::Compare(char *pszNewString)
{
	ASSERTSTRING;
	return strcmp(m_pszString,pszNewString);
}

int CXString::CompareNoCase(CXString *cxsNewString)
{
	ASSERTSTRING;
	return stricmp(m_pszString,cxsNewString->GetCharString());
}

int CXString::CompareNoCase(char *pszNewString)
{
	ASSERTSTRING;
	return stricmp(m_pszString,pszNewString);
}


CXString CXString::Mid(int nFirst,int nCount)
{
	ASSERTSTRING;
	char *pszTempString = new char[nCount + 1];
	memset(pszTempString,NULL,(nCount + 1));
	for(int nPos = 0; nPos <= nCount ; nPos++)
		pszTempString[nPos] = m_pszString[nPos + nFirst];
	pszTempString[nPos] = '\0';
	CXString xsTemp(pszTempString);
	//delete []pszTempString;
	return xsTemp;
}

CXString CXString::Left(int nCount)
{
	ASSERTSTRING;
	char *pszTempString = new char[nCount + 1];
	memset(pszTempString,NULL,(nCount + 1));
	for(int nPos = 0; nPos <= nCount; nPos++)
		pszTempString[nPos] = m_pszString[nPos];
	pszTempString[nPos] = '\0';
	CXString xsTemp(pszTempString);
	//delete pszTempString;
	return xsTemp;
}

CXString CXString::Right(int nCount)
{
	ASSERTSTRING;
	char *pszTempString = new char[nCount + 1];
	memset(pszTempString,NULL,(nCount + 1));
	for(int nPos = 0; nPos <= nCount; nPos++)
		pszTempString[nPos] = m_pszString[(this->Length() - nCount ) +  nPos];
	pszTempString[nPos] = '\0';
	CXString xsTemp(pszTempString);
	//delete []pszTempString;
	return xsTemp;
}


CXString CXString::MakeUpper(bool bFlag)
{
	ASSERTSTRING;
	if( false == bFlag )
	{
		char *pszTempString = new char[this->Length()];
		memset(pszTempString,NULL,this->Length());
		strcpy(pszTempString,m_pszString);
		strupr(pszTempString);
		CXString xsTemp(pszTempString);
		//delete []pszTempString;
		return xsTemp;
	}
	else 
	{
		strupr(m_pszString);
		return *this;
	}
}

CXString CXString::MakeLower(bool bFlag)
{
	ASSERTSTRING;
	if( false == bFlag )
	{
		char *pszTempString = new char[this->Length()];
		memset(pszTempString,NULL,this->Length());
		strcpy(pszTempString,m_pszString);
		strlwr(pszTempString);
		CXString xsTemp(pszTempString);
		//delete []pszTempString;
		return xsTemp;
	}
	else 
	{
		strlwr(m_pszString);
		return *this;
	}
}

CXString CXString::MakeReverse(bool bFlag)
{
	ASSERTSTRING;
	if( false == bFlag )
	{
		char *pszTempString = new char[this->Length()];
		memset(pszTempString,NULL,this->Length());
		strcpy(pszTempString,m_pszString);
		strrev(pszTempString);
		CXString xsTemp(pszTempString);
		//delete []pszTempString;
		return xsTemp;
	}
	else 
	{
		strrev(m_pszString);
		return *this;
	}
}

CXString CXString::Replace(char chOld,char chNew,bool bFlag,int nOccur)
{
	ASSERTSTRING;
	int nOccurCount = 0;
	int nPos = 0;
	if( false == bFlag )
	{
		char *pszTempString = new char[this->Length()];
		memset(pszTempString,NULL,this->Length());
		strcpy(pszTempString,m_pszString);

		while(!((nOccur == 0)?false:((nOccurCount<nOccur)?false:true)) && (nPos <= (int)strlen(pszTempString) ))
		{
			if( pszTempString[nPos] == chOld )
			{
				pszTempString[nPos] = chNew;
				if( nOccur != 0 ) nOccurCount++;
			}
			nPos++;
		}
		CXString xsTemp(pszTempString);
		//delete []pszTempString;
		return xsTemp;
	}
	else 
	{
		while((!((nOccur == 0)?false:((nOccurCount<nOccur)?false:true))) && (nPos <= (int)strlen(m_pszString) ))
		{
			if( m_pszString[nPos] == chOld )
			{
				m_pszString[nPos] = chNew;
				if( nOccur != 0 ) nOccurCount++;
			}
			nPos++;
		}
		return *this;
	}
}

CXString CXString::Replace(char *pszOld,char *pszNew,bool bFlag,int nOccur)
{
	ASSERTSTRING;
	int nPos		= 0;
	int nOccurCount = 0;
	if( false == bFlag )
	{
		char *pszTempString		= new char[strlen(m_pszString)];
		memset(pszTempString,NULL,this->Length());
		strcpy(pszTempString,m_pszString);

		while(!((nOccur == 0)?false:((nOccurCount<nOccur)?false:true)) && (nPos <= (int)strlen(pszTempString) ))
		{
			if( 0 == MidPrivate(pszTempString,nPos,int(strlen(pszOld))-1).Compare(pszOld) )
			{
				for(int nSubPos = 0;pszTempString[nPos + strlen(pszOld) + nSubPos ] != '\0' ;nSubPos++)
				{
					pszTempString[nPos + nSubPos ] = pszTempString[nPos + strlen(pszOld) + nSubPos ];
				}
				pszTempString[nSubPos + nPos] = '\0';
				InsertPrivate(pszTempString,pszNew,nPos);
				nPos = 0;
				if( nOccur != 0 ) nOccurCount++;
			}
			nPos++; 
		}
		CXString xsTemp(pszTempString);
		return xsTemp;
	}
	else 
	{
		while(!((nOccur == 0)?false:((nOccurCount<nOccur)?false:true)) && (nPos <= (int)strlen(m_pszString) ))
		{
			if( 0 == Mid(nPos,int(strlen(pszOld))-1).Compare(pszOld) )
			{
				for(int nSubPos = 0;m_pszString[nPos + strlen(pszOld) + nSubPos ] != '\0' ;nSubPos++)
				{
					m_pszString[nPos + nSubPos ] = m_pszString[nPos + strlen(pszOld) + nSubPos ];
				}
				m_pszString[nSubPos + nPos] = '\0';
				InsertPrivate(m_pszString,pszNew,nPos);
				nPos = 0;
				if( nOccur != 0 ) nOccurCount++;
			}
			nPos++; 
		}
		return *this;
	}
}

int CXString::ToInt()
{
	ASSERTSTRING;
	return atoi(m_pszString);
}

float CXString::ToFloat()
{
	ASSERTSTRING;
	return (float)atof(m_pszString);
}

double CXString::ToDouble()
{
	ASSERTSTRING;
	return atof(m_pszString);
}

wchar_t CXString::ToWideChar()
{
	ASSERTSTRING;
	wchar_t wcsString;
	mbstowcs(&wcsString,m_pszString,strlen(m_pszString));
	return wcsString;
}


void CXString::Insert(char chChar,int nPos)
{
	ASSERTSTRING;
	char *pszTemp = new char[strlen(m_pszString) + 1];
	memset(pszTemp,NULL,sizeof(pszTemp));
	strcpy(pszTemp,m_pszString);
	realloc(m_pszString,strlen(m_pszString) + 2);
	memset(m_pszString,NULL,sizeof(pszTemp) + 2);
	CXString xsTemp(pszTemp);
	CXString xsLeftTemp		=	xsTemp.Left(nPos -1 );
	CXString xsRightTemp	=	xsTemp.Right(int(strlen(pszTemp)) - (nPos) ); 
	memset(m_pszString,NULL,sizeof(pszTemp) + 2);
	strcat(m_pszString,xsLeftTemp.GetCharString());
	strcat(m_pszString,&chChar);
	strcat(m_pszString,xsRightTemp.GetCharString());
}

void CXString::Insert(char *pszString,int nPos)
{
	ASSERTSTRING;
	char *pszTemp = new char[strlen(m_pszString) + 1];
	memset(pszTemp,NULL,sizeof(pszTemp));
	strcpy(pszTemp,m_pszString);
	realloc(m_pszString,strlen(m_pszString) + strlen(pszString));
	memset(m_pszString,NULL,strlen(m_pszString) + strlen(pszString));
	CXString xsTemp(pszTemp);
	CXString xsLeftTemp		=	xsTemp.Left(nPos -1 );
	CXString xsRightTemp	=	xsTemp.Right(int(strlen(pszTemp)) - (nPos) ); 
	memset(m_pszString,NULL,strlen(m_pszString) + strlen(pszString));
	strcat(m_pszString,xsLeftTemp.GetCharString());
	strcat(m_pszString,pszString);
	strcat(m_pszString,xsRightTemp.GetCharString());
}

char* CXString::GetCharString() const
{
	ASSERTSTRING;
	return m_pszString;
}

void CXString::InsertPrivate(char *pszOldString,char *pszNewString,int nPos)
{
	char *pszTemp = new char[strlen(pszOldString) + 1];
	memset(pszTemp,NULL,sizeof(pszTemp));
	strcpy(pszTemp,pszOldString);
	realloc(pszOldString,strlen(pszOldString) + strlen(pszNewString));
	memset(pszOldString,NULL,strlen(pszOldString) + strlen(pszNewString));
	CXString xsTemp(pszTemp);
	CXString xsLeftTemp		=	xsTemp.Left(nPos -1 );
	CXString xsRightTemp	=	xsTemp.Right(int(strlen(pszTemp)) - (nPos) ); 
	memset(pszOldString,NULL,strlen(m_pszString) + strlen(pszNewString));
	strcat(pszOldString,xsLeftTemp.GetCharString());
	strcat(pszOldString,pszNewString);
	strcat(pszOldString,xsRightTemp.GetCharString());
}

CXString CXString::MidPrivate(char *pszString,int nFirst,int nCount)
{
	char *pszTempString = new char[nCount + 1];
	memset(pszTempString,NULL,(nCount + 1));
	for(int nPos = 0; nPos <= nCount ; nPos++)
		pszTempString[nPos] = pszString[nPos + nFirst];
	pszTempString[nPos] = '\0';
	CXString xsTemp(pszTempString);
	return xsTemp;
}


int CXString::Find(char chChar,int nPos)
{
	ASSERTSTRING;
	for(int nCount = nPos;nCount<(int)strlen(m_pszString);nCount++)
	{
		if( m_pszString[nCount] == chChar )
			return nCount;
	}
	return 0;
}

int CXString::Find(char *pszString,int nPos)
{
	ASSERTSTRING;
	char *szTemp = new char[int(strlen(pszString)+1)];
	for(int nCount = nPos;nCount<(int)strlen(m_pszString);nCount++)
	{
		for(int nSubCount =0;nSubCount<(int)strlen(pszString);nSubCount++)
			szTemp[nSubCount] = m_pszString[nSubCount + nCount];
		szTemp[nSubCount] = '\0';
		if( 0 == strcmp(szTemp,pszString) )
			return nCount;
	}
	return 0;
}

int CXString::ReverseFind(char chChar,int nPos)
{
	ASSERTSTRING;
	for(int nCount = (int(strlen(m_pszString)) - nPos);nCount>0;nCount--)
	{
		if( m_pszString[nCount] == chChar )
			return nCount;
	}
	return 0;
}

int CXString::ReverseFind(char *pszString,int nPos)
{
	ASSERTSTRING;
	char *szTemp = new char[int(strlen(pszString)+1)];
	for(int nCount = (int(strlen(m_pszString)) - nPos);nCount>0;nCount--)
	{
		for(int nSubCount =0;nSubCount<(int)strlen(pszString);nSubCount++)
			szTemp[nSubCount] = m_pszString[nCount - strlen(pszString) + nSubCount];
		szTemp[nSubCount] = '\0';
		if( 0 == strcmp(szTemp,pszString) )
			return nCount;
	}
	return 0;
}


CXString CXString::operator =( CXString xString)
{
	m_pszString = new char[xString.Length()+1];
	memset(m_pszString,NULL,sizeof(m_pszString));
	strcpy(m_pszString,xString.GetCharString());
	return *this;
}

CXString CXString::operator =(char *pszString)
{
	m_pszString = new char[strlen(pszString)+1];
	memset(m_pszString,NULL,sizeof(m_pszString));
	strcpy(m_pszString,pszString);
	return *this;
}

CXString CXString::operator =(char chChar)
{
	m_pszString = new char[2];
	m_pszString[0] = chChar;
	m_pszString[1] = '\0';
	return *this;
}

int CXString::operator ==(CXString xString)
{
	ASSERTSTRING;
	return strcmp(m_pszString,xString.GetCharString());
}

int CXString::operator ==(char *pszString)
{
	ASSERTSTRING;
	return strcmp(m_pszString,pszString);
}

int CXString::operator ==(char chChar)
{
	ASSERTSTRING;
	return strcmp(m_pszString,&chChar);
}

CXString CXString::operator +(CXString xString)
{
	ASSERTSTRING;
	strcat(m_pszString,xString.GetCharString());
	return *this;
}

CXString CXString::operator +(char *pszString)
{
	ASSERTSTRING;
	strcat(m_pszString,pszString);
	return *this;
}

CXString CXString::operator +(char chChar)
{
	ASSERTSTRING;
	strcat(m_pszString,&chChar);
	return *this;
}

CXString CXString::TrimLeft(char chChar,bool bFlag)
{
	ASSERTSTRING;
	bool bComplete	=	false;
	if( m_pszString[0] != chChar )
		return *this;

	if( bFlag == false )
	{
		char *pszString = new char[strlen(m_pszString)];
		memset(pszString,NULL,strlen(m_pszString));
		strcpy(pszString,m_pszString);
		while( bComplete == false )
		{
			if( pszString[0] == chChar )
			{
				for(int nSubPos = 0;nSubPos < (int)strlen(pszString);nSubPos++)
				{
					pszString[nSubPos] = pszString[nSubPos +  1];
				}
				pszString[nSubPos] = '\0';
			}
			else
				bComplete = true;
		}
		CXString xsTemp(pszString);
		return xsTemp;
	}
	else
	{
		while( bComplete == false )
		{
			if( m_pszString[0] == chChar )
			{
				for(int nSubPos = 0;nSubPos < (int)strlen(m_pszString);nSubPos++)
				{
					m_pszString[nSubPos] = m_pszString[nSubPos +  1];
				}
				m_pszString[nSubPos] = '\0';
			}
			else
				bComplete = true;
		}
		return *this;
	}
}

CXString CXString::TrimRight(char chChar, bool bFlag)
{
	ASSERTSTRING;
	bool bComplete	=	false;
	if( m_pszString[strlen(m_pszString) - 1] != chChar )
		return *this;

	if( bFlag == false )
	{
		char *pszString = new char[strlen(m_pszString)];
		memset(pszString,NULL,strlen(m_pszString));
		strcpy(pszString,m_pszString);
		while( bComplete == false )
		{
			if( pszString[strlen(pszString) - 1] == chChar )
			{
				pszString[strlen(pszString) - 1] = '\0';
			}
			else
				bComplete = true;
		}
		CXString xsTemp(pszString);
		return xsTemp;
	}
	else
	{
		while( bComplete == false )
		{
			if( m_pszString[strlen(m_pszString)] == chChar )
			{
				m_pszString[strlen(m_pszString)] = '\0';
			}
			else
				bComplete = true;
		}
		return *this;
	}
}

CXString CXString::Remove(char chChar)
{
	ASSERTSTRING;
	for(int nPos = 0;nPos < this->Length();nPos++)
	{
		if( m_pszString[nPos] == chChar )
		{
			for(int nSubPos = 0;nSubPos < this->Length();nSubPos++)
				m_pszString[nSubPos + nPos] = m_pszString[nSubPos + nPos + 1];
			m_pszString[nSubPos] = '\0';

		}
	}
	return *this;
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


Written By
Ganesh Ramaswamy
India India
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.

Comments and Discussions

Permalink
Advertise
Privacy
Cookies
Terms of Use
Layout: fixed | fluid

Posted 11 Jun 2001

Article Copyright 2001 by Ganesh Ramaswamy
Everything else Copyright © CodeProject, 1999-2024

Web04 2.8:2024-04-02:1