//-------------------------------------------------------------------------------------------------
//
//	IBSL Technologies (c) 2000
//	BrainTree Development Ltd(c) 2000
//
//	Rennie Bowe
//	P J Tewkesbury
//
//-------------------------------------------------------------------------------------------------
//
// StringEx.cpp
//

#include "stdafx.h"
#include "StringEx.h"

CStringEx& CStringEx::Append(CString Fmt,...)
{
	va_list args;
	va_start(args, Fmt);
	CString str;
	str.FormatV(Fmt, args);
	return Insert(GetLength(), str);
}

// Insert	- Inserts a sub string into the string
// Returns	- Reference to the same string object
// pos		- Position to insert at. Extends the string with spaces if needed
// s		- Sub string to insert
CStringEx& CStringEx::Insert(int pos, LPCTSTR s)
{
	int len = lstrlen(s);
	if ( len == 0 )
		return *this;

	int oldlen = GetLength();
	int newlen = oldlen + len;
	LPTSTR str;
	if ( pos >= oldlen ) 
	{			
		// insert after end of string
		newlen += pos - oldlen ;
		str = GetBuffer( newlen );
		_tcsnset( str+oldlen, _T(' '), pos-oldlen );
		_tcsncpy( str+pos, s, len );
	} 
	else 
	{	
		// normal insert
		str = GetBuffer( newlen );
		memmove( str+pos+len, str+pos, sizeof(_T(' ')) *(oldlen-pos) );
		_tcsncpy( str+pos, s, len );
	}
	ReleaseBuffer( newlen );

	return *this;
}


// Insert	- Inserts a character into the string
// Returns	- Reference to the same string object
// pos		- Position to insert at. Extends the string with spaces if needed
// c		- Char to insert
CStringEx& CStringEx::Insert(int pos, TCHAR c)
{
	TCHAR buf[2];
	buf[0] = c;
	buf[1] = _T('\0');
	return Insert( pos, buf );
}


// Delete	- Deletes a segment of the string and resizes it
// Returns	- Reference to the same string object
// pos		- Position of the string segment to remove
// len		- Number of characters to remove
CStringEx& CStringEx::Delete(int pos, int len)
{
	int strLen = GetLength();

	if( pos >= strLen)
		return *this;
	if(len < 0 ||len > strLen - pos)
		len = strLen - pos;

	LPTSTR str = GetBuffer( strLen );
	memmove(str+pos, str+pos+len, sizeof(_T(' ')) *(strLen-pos));
	ReleaseBuffer( strLen - len );

	return *this;
}


// Replace	- Replaces a substring with another
// Returns	- Reference to the same string object
// pos		- Position of the substring
// len		- Length of substring to be replaced
// s		- New substring
CStringEx& CStringEx::Replace(int pos, int len, LPCTSTR s)
{
	Delete(pos, len);
	Insert(pos, s);

	return *this;
}

CStringEx& CStringEx::ReplaceAll(LPCTSTR s1, LPCTSTR s2)
{
	int idx;
	int pos=0;
	do
	{
		idx=Find(s1,pos);
		if (idx!=-1)
		{
			Replace(idx,_tcslen(s1),s2);			
		}
		pos=idx+_tcslen(s2);
	}
	while (idx!=-1);
	return *this;
}


// Find 	- Finds the position of a character in a string
// Returns	- A zero-based index
// ch		- Character to look for
// startpos	- Position to start looking from
int CStringEx::Find( TCHAR ch, int startpos /*= 0*/ ) const
{
	return CString::Find(ch,startpos);
}


// Find 	- Finds the position of a substring in a string
// Returns	- A zero-based index
// lpszSub	- Substring to look for
// startpos	- Position to start looking from
int CStringEx::Find( LPCTSTR lpszSub, int startpos /*= 0*/ ) const
{
	return CString::Find(lpszSub,startpos);	
}

// FindNoCase	- Case insensitive find
// Returns	- A zero-based index
// ch		- Char to search for
// startpos 	- Position to start looking from
int CStringEx::FindNoCase( TCHAR ch, int startpos /*= 0*/ ) const
{	
	unsigned int locase = Find( tolower( ch ), startpos );
	unsigned int upcase = Find( toupper( ch ), startpos );
	return locase < upcase ? locase : upcase;
}


// FindNoCase	- Case insensitive find
// Returns	- A zero-based index
// lpszSub	- Substring to search for
// startpos 	- Position to start looking from
int CStringEx::FindNoCase( LPCTSTR lpszSub, int startpos /*= 0*/ ) const
{
	CStringEx sLowerThis = *this;
	sLowerThis.MakeLower();

	CStringEx sLowerSub = lpszSub;
	sLowerSub.MakeLower();

	return sLowerThis.Find( sLowerSub, startpos );
}


// FindReplace		- Find a substring and replace with another
// Returns		- Number of instances replaced
// lpszSub		- Substring to look for
// lpszReplaceWith	- Substring to replace with
// bGlobal		- Flag to indicate whether all occurances 
//					  should be replaced
int CStringEx::FindReplace( LPCTSTR lpszSub, LPCTSTR lpszReplaceWith, 
					BOOL bGlobal /*= TRUE*/ )
{
	int iReplaced = 0;

	// find first matching substring
	LPTSTR lpsz;
	LPTSTR lpszString=GetBuffer(GetLength());
	
	int pos = 0;
	int lenSub = lstrlen( lpszSub );
	int lenReplaceWith = lstrlen( lpszReplaceWith );
	while( (lpsz = _tcsstr(&lpszString[pos], lpszSub)) != NULL )
	{
		pos = (int)(lpsz - lpszString);
		Replace( pos, lenSub, lpszReplaceWith );
		pos += lenReplaceWith;
		iReplaced++;
		if( !bGlobal ) break;
	}

	return iReplaced;
}


// FindReplaceNoCase	- Find a substring and replace with another
//			  Does case insensitive search
// Returns		- Number of instances replaced
// lpszSub		- Substring to look for
// lpszReplaceWith	- Substring to replace with
// bGlobal		- Flag to indicate whether all occurances 
//			  should be replaced
int CStringEx::FindReplaceNoCase( LPCTSTR lpszSub, LPCTSTR lpszReplaceWith, 
					 BOOL bGlobal /*= TRUE*/ )
{
	int lenSub = _tcslen( lpszSub );
	int pos=0;
	int idx=-1;
	int Count=0;
	do
	{
		idx=FindNoCase(lpszSub,pos);
		if (idx!=-1)
		{
			Replace(idx,lenSub,lpszReplaceWith);
			Count++;
			pos=idx;
		}
		pos++;
	}
	while (idx!=-1);
	return Count;

#if 0
	CStringEx sLowerThis(*this);
	sLowerThis.MakeLower();

	CStringEx sLowerSub(lpszSub);
	sLowerSub.MakeLower();

	int iReplaced = 0;

	int len=GetLength();
	LPTSTR lpszString=GetBuffer(len);

	// find first matching substring
	LPTSTR lpsz;	
	int pos = 0, offset = 0;
	int lenSub = lstrlen( lpszSub );
	int lenReplaceWith = lstrlen( lpszReplaceWith );
	
	while( (lpsz = _tcsstr((LPCTSTR)lpszLower[pos], lpszLower)) != NULL )
	{		
		pos = (int)(lpsz - lpszLower);
		Replace( pos+offset, lenSub, lpszReplaceWith );
		offset += lenReplaceWith - lenSub;
		pos += lenSub;
		iReplaced++;
		if( !bGlobal ) break;
	}

	return iReplaced;
#endif
}

// ReverseFind	- Searches for the last match of a substring
// Returns	- A zero-based index
// lpszSub	- Substring to search for
// startpos 	- Position to start looking from, in reverse dir
int CStringEx::ReverseFind( LPCTSTR lpszSub, int startpos /*= -1*/ ) 
{	
	LPTSTR lpszString=GetBuffer(GetLength());	
	int lenSub = lstrlen( lpszSub );
	int len = GetLength();

	if(0 < lenSub && 0 < len)
	{
		if( startpos == -1 || startpos >= len ) startpos = len - 1;
		for ( LPTSTR lpszReverse = &lpszString[startpos] ; 
						lpszReverse != lpszString; --lpszReverse)
			if (_tcsncmp(lpszSub, lpszReverse, lenSub ) == 0)
				return (lpszReverse - lpszString);
	}
	return -1;
}


// ReverseFindNoCase	- Searches for the last match of a substring
//			  Search is case insensitive
// Returns		- A zero-based index
// lpszSub		- Character to search for
// startpos 		- Position to start looking from, in reverse dir
int CStringEx::ReverseFindNoCase(TCHAR ch, int startpos /*= -1*/ ) 
{
	TCHAR a[2];
	a[0] = ch;
	a[1] = 0;
	return ReverseFindNoCase( a, startpos );
}

// ReverseFindNoCase	- Searches for the last match of a substring
//			  Search is case insensitive
// Returns		- A zero-based index
// lpszSub		- Substring to search for
// startpos 		- Position to start looking from, in reverse dir
int CStringEx::ReverseFindNoCase( LPCTSTR lpszSub, int startpos /*= -1*/ )
{	
	int len = GetLength();	
	LPTSTR lpszString=GetBuffer(GetLength());	
	int lenSub = lstrlen( lpszSub );

	if(0 < lenSub && 0 < len)
	{
		if( startpos == -1 || startpos >= len ) startpos = len - 1;
		for ( LPTSTR lpszReverse = &lpszString[startpos];
				lpszReverse >= lpszString; --lpszReverse)
			if (_tcsnicmp(lpszSub, lpszReverse, lenSub ) == 0)
				return (lpszReverse - lpszString);
	}
	return -1;
}


// GetField 	- Gets a delimited field
// Returns	- A CStringEx object that contains a copy of 
//		  the specified field
// delim	- The delimiter string
// fieldnum 	- The field index - zero is the first
// NOTE 	- Returns the whole string for field zero
//		  if delim not found
//		  Returns empty string if # of delim found
//		  is less than fieldnum
CStringEx CStringEx::GetField( LPCTSTR delim, int fieldnum)
{
	LPTSTR lpsz, lpszRemainder = GetBuffer(GetLength()), lpszret;
	int retlen, lenDelim = lstrlen( delim );

	while( fieldnum-- >= 0 )
	{
		lpszret = lpszRemainder;
		lpsz = _tcsstr(lpszRemainder, delim);
		if( lpsz )
		{
			// We did find the delim
			retlen = lpsz - lpszRemainder;
			lpszRemainder = lpsz + lenDelim;
		}
		else
		{
			retlen = lstrlen( lpszRemainder );
			lpszRemainder += retlen;	// change to empty string
		}
	}
	return Mid( lpszret - GetBuffer(GetLength()), retlen );
}

// GetField 	- Gets a delimited field
// Returns	- A CStringEx object that contains a copy of 
//		  the specified field
// delim	- The delimiter char
// fieldnum 	- The field index - zero is the first
// NOTE 	- Returns the whole string for field zero
//		  if delim not found
//		  Returns empty string if # of delim found
//		  is less than fieldnum
CStringEx CStringEx::GetField( TCHAR delim, int fieldnum)
{
	LPTSTR lpsz, lpszRemainder = GetBuffer(GetLength()), lpszret;
	int retlen;

	while( fieldnum-- >= 0 )
	{
		lpszret = lpszRemainder;
		lpsz = _tcschr(lpszRemainder, (_TUCHAR)delim);
		if( lpsz )
		{
			// We did find the delim
			retlen = lpsz - lpszRemainder;
			lpszRemainder = lpsz + 1;
		}
		else
		{
			retlen = lstrlen( lpszRemainder );
			lpszRemainder += retlen;	// change to empty string
		}
	}
	return Mid( lpszret - GetBuffer(GetLength()), retlen );
}


// GetFieldCount	- Get number of fields in a string
// Returns		- The number of fields
//			  Is always greater than zero
// delim		- The delimiter character
int CStringEx::GetFieldCount( TCHAR delim )
{
	TCHAR a[2];
	a[0] = delim;
	a[1] = 0;
	return GetFieldCount( a );
}


// GetFieldCount	- Get number of fields in a string
// Returns		- The number of fields
//			  Is always greater than zero
// delim		- The delimiter string
int CStringEx::GetFieldCount( LPCTSTR delim )
{	
	LPTSTR lpsz, lpszRemainder = GetBuffer(GetLength());
	int lenDelim = lstrlen( delim );

	int iCount = 1;
	while( (lpsz = _tcsstr(lpszRemainder, delim)) != NULL )
	{
		lpszRemainder = lpsz + lenDelim;
		iCount++;
	}

	return iCount;
}


// GetDelimitedField	- Finds a field delimited on both ends
// Returns		- A CStringEx object that contains a copy of 
//			  the specified field
// delimStart		- Delimiter at the start of the field
// delimEnd 		- Delimiter at the end of the field
CStringEx CStringEx::GetDelimitedField( LPCTSTR delimStart, LPCTSTR delimEnd, int fieldnum /*= 0*/)
{
	LPTSTR lpsz, lpszEnd, lpszRet, lpszRemainder = GetBuffer(GetLength());
	int lenDelimStart = lstrlen( delimStart ), lenDelimEnd = lstrlen( delimEnd );

	while( fieldnum-- >= 0 )
	{
		lpsz = _tcsstr(lpszRemainder, delimStart);
		if( lpsz )
		{
			// We did find the Start delim
			lpszRet = lpszRemainder = lpsz + lenDelimStart;
			lpszEnd = _tcsstr(lpszRemainder, delimEnd);
			if( lpszEnd == NULL ) return"";
			lpszRemainder = lpsz + lenDelimEnd;
		}
		else return "";
	}
	return Mid( lpszRet - (LPCTSTR)this, lpszEnd - lpszRet );
}

CStringEx::CStringEx(DWORD SystemErrorCode)
{
	// Init();

	LPVOID lpMsgBuf;
	::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		SystemErrorCode,
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		(LPTSTR) &lpMsgBuf,
		0,
		NULL );
	Format(_T("%s"),lpMsgBuf);
	LocalFree( lpMsgBuf );
};

CStringEx::CStringEx(TCHAR *szFormat, ... ) 
{ 	
	// Init();
	va_list argList;
	va_start( argList, szFormat );
	FormatV( szFormat, argList );
};

CStringEx::CStringEx(UINT nResID)	// Load string with Resource String
{ 		
//	Init();
	VERIFY(LoadString(nResID) != 0);
//	_ASSERTE( m_pchData );
};

void CStringEx::operator () (UINT nResID)	// CString Name; Name(nID);
{	
	// Init();
	VERIFY(LoadString(nResID) != 0);
	// _ASSERTE( m_pchData );
};

void CStringEx::StripFormatChars()
{
	RemoveAll(10);
	RemoveAll(13);
	RemoveAll(9);	
}

CStringEx CStringEx::RemoveAll(TCHAR c) const
{
	CStringEx hilf = *this;

	while (hilf.Find(c) >= 0)	hilf = hilf.Remove(c);
	return hilf;
}

CStringEx CStringEx::Remove(TCHAR c) const
{
	int i = Find(c);

	if (i >= 0)	return Left(i) + Mid(i+1);
	else		return *this;
}

CStringEx CStringEx::Remove(const CStringEx& s) const
{
	int i = Find(s);

	if (i >= 0)	return Left(i) + Mid(i + s.GetLength());
	else		return *this;
}

CStringEx CStringEx::RemoveAll(const CStringEx& s) const
{
	CStringEx hilf = *this;

	while (hilf.Find(s) >= 0)	hilf = hilf.Remove(s);
	return hilf;
}

int CStringEx::CountChar(TCHAR ch)
{
	int Count=0;
	int idx=-1;
	do
	{
		idx=Find(ch,idx+1);
		if (idx!=-1) Count++;
	}
	while (idx!=-1);

	return Count;
}

void CStringEx::RemoveExtraSpaces()
{
	CString Temp;	
	BOOL bFirst=true;
	for(int i=0;i<GetLength();i++)
	{
		if (GetAt(i)!=' ') 
		{
			Temp+=GetAt(i);
			bFirst=true;
		}
		else 
		{
			if (bFirst)
			{
				Temp+=GetAt(i);
			}
			bFirst=false;
		}
	}
	Format(_T("%s"),Temp);
}