www.pudn.com > acdx.rar > StringEx.cpp

 
#include "sfc.h" 
#include "StringEx.h" 
 
#if defined(_DEBUG) 
//#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
 
 
///////////////////////////////////////////////////////////////////////// 
// StringEx 
 
void StringEx::MakeUpper () 
{ 
   // reverse case of string 
   for( iterator p = begin(); p != end(); p++ ) 
   { 
      if( islower( *p ) ) 
         *p = _toupper( *p ); 
   } 
 
} 
 
 
void StringEx::MakeLower () 
{ 
   // reverse case of string 
   for( iterator p = begin(); p != end(); p++ ) 
   { 
      if( isupper( *p ) ) 
         *p = _tolower( *p ); 
   } 
 
} 
 
 
// format a string 
void StringEx::Format ( LPCTSTR lpszFormat, ... ) 
{ 
	va_list args; 
	va_start(args, lpszFormat); 
 
	// buffer for format 
	int   len; 
	TCHAR buffer[512] = _T("\0"); 
 
	// perform format 
	len = _vsntprintf(buffer, 512, lpszFormat, args); 
 
	// if there was no error 
	if ( len >= 0 ) 
		(string &) *this = buffer; 
 
	va_end(args); 
} 
 
 
// load string resource 
 
void StringEx::LoadString ( int id ) 
{ 
	int   len; 
	TCHAR buffer[512]; 
 
	// load resource string 
	// need to examinie instance 
 
	/* 
	#if defined(__AFX_H__) 
	HINSTANCE hInstance = AfxGetInstanceHandle(); 
	#elif defined(__ATLBASE_H__) 
	HINSTANCE hInstance = _Module.GetModuleInstance(); 
	#else 
	HINSTANCE hInstance = 0; 
	#endif 
	*/ 
 
	// get default instance 
	HINSTANCE hInstance = 0; 
 
	len =  
	::LoadString( hInstance, id, buffer, 512 ); 
	 
	DWORD error = 0; 
	if ( len <= 0 ) 
		error = GetLastError(); 
 
 
	// if there was no error 
	if ( len >= 0 ) 
		(string &) *this = buffer; 
} 
 
 
 
 
// trim white space 
void StringEx::TrimRight () 
{ 
	// find last that is not a space 
	reverse_iterator last = std::find_if( rbegin(), rend(), std::bind2nd(std::not_equal_to(),' ') ); 
 
	// remove spaces from end (here we use the knowledge that a reverse_terator  
	// is based on an iterator refer include file xstring 
	erase( (iterator &) last, end() ); 
} 
 
 
 
int StringEx::Compare(LPCTSTR lpsz) const 
{ 
	// if nothing in string stop 
	if ( empty() ) 
		return -1; 
 
	// do comparison 
	int result = compare(lpsz); 
 
	return result; 
} 
 
int StringEx::Compare(TCHAR ch) const 
{ 
	// if nothing in string stop 
	if ( empty() ) 
		return -1; 
 
	// do comparison 
	TCHAR temp[] = {ch}; 
	int result = compare(temp); 
 
	return result; 
} 
 
int StringEx::CompareNoCase(LPCTSTR lpsz) const 
{ 
	// if nothing in string stop 
	if ( empty() ) 
		return -1; 
 
 
	return lstrcmpi(begin(), lpsz);  
}  
 
 
 
void StringEx::TrimLeft  () 
{ 
	// find first that is not space 
	iterator last  = std::find_if( begin(), end(), std::bind2nd(std::not_equal_to(),' ') ); 
 
	// remove spaces from start 
	erase(begin(),last) ; 
} 
 
 
 
void StringEx::TrimRight(TCHAR chTarget) 
{ 
	// find last that is not a space 
	reverse_iterator last = std::find_if( rbegin(), rend(), std::bind2nd(std::not_equal_to(),chTarget) ); 
 
	// remove spaces from end (here we use the knowledge that a reverse_terator  
	// is based on an iterator refer include file xstring 
	erase( (iterator &) last, end() ); 
} 
 
void StringEx::TrimRight(LPCTSTR lpszTargets) 
{ 
	// find last that is not a space 
	reverse_iterator last = std::find_if( rbegin(), rend(), std::bind2nd(std::not_equal_to(),lpszTargets) ); 
 
	// remove spaces from end (here we use the knowledge that a reverse_terator  
	// is based on an iterator refer include file xstring 
	erase( (iterator &) last, end() ); 
} 
 
void StringEx::TrimLeft(TCHAR chTarget) 
{ 
	// find first that is not space 
	iterator last  = std::find_if( begin(), end(), std::bind2nd(std::not_equal_to(),chTarget) ); 
 
	// remove spaces from start 
	erase(begin(),last) ; 
} 
 
void StringEx::TrimLeft(LPCTSTR lpszTargets) 
{ 
	// find first that is not space 
	iterator last  = std::find_if( begin(), end(), std::bind2nd(std::not_equal_to(),lpszTargets) ); 
 
	// remove spaces from start 
	erase(begin(),last) ; 
} 
 
 
int StringEx::Replace(TCHAR chOld, TCHAR chNew) 
{ 
	// replace if found 
	replace( begin(), end(), chOld, chNew ); 
 
	return 0; 
} 
 
int StringEx::Replace(LPCTSTR lpszOld, LPCTSTR lpszNew) 
{ 
	// replace if found 
	replace( begin(), end(), lpszOld, lpszNew ); 
 
	return 0; 
} 
 
int StringEx::Remove(TCHAR chRemove) 
{ 
	// remove if found 
	std::remove_if( begin(), end(), std::bind2nd(std::equal_to(),chRemove) ); 
 
 
	return 0; 
} 
 
int StringEx::Insert(int nIndex, TCHAR ch) 
{ 
	// find start 
	iterator start = begin() + nIndex; 
	if ( start == end() ) 
		return 0; 
 
	// insert char 
	insert( start, ch ); 
 
 
	return 0; 
} 
 
int StringEx::Insert(int nIndex, LPCTSTR pstr) 
{ 
	// find start 
	iterator start = begin() + nIndex; 
	if ( start == end() ) 
		return 0; 
 
	// insert string 
	insert( nIndex, pstr ); 
 
	return 0; 
} 
 
int StringEx::Delete(int nIndex, int nCount) 
{ 
	// find start 
	iterator start = begin() + nIndex; 
	if ( start == end() ) 
		return 0; 
 
	iterator last = start + nCount; 
	if ( last == end() ) 
		return 0; 
 
	// remove chars 
	erase( start, last ); 
 
	return 0; 
} 
 
 
void StringEx::allocCopy ( StringEx & dest, int copyLen, int copyIndex, 
				            int extraLen ) const 
{ 
	// will clone the data attached to this string 
	// allocating 'nExtraLen' characters 
	// Places results in uninitialized string 'dest' 
	// Will copy the part or all of original data to start of new string 
 
	int newLen = copyLen + extraLen; 
	if ( newLen == 0 ) 
	{	 
		dest = ""; 
	} 
	else 
	{ 
		// get allocator for string 
		StringEx::allocator_type allocator =  
		dest.get_allocator(); 
 
		// setup buffer for copy 
		allocator.allocate( newLen, NULL ); 
 
		// copy data 
		TCHAR * pData = (TCHAR *) c_str(); 
 
		memcpy( (TCHAR *) dest.c_str(),  
			    pData + copyIndex,  
				copyLen * sizeof(TCHAR) ); 
	} 
} 
 
 
StringEx StringEx::Mid(int first) const 
{ 
	return Mid(first, size() - first); 
} 
 
StringEx StringEx::Mid(int first, int count) const 
{ 
	// out-of-bounds requests return sensible things 
	if (first < 0) 
		first = 0; 
	if (count < 0) 
		count = 0; 
 
	if ( first + count > size() ) 
		count = size() - first; 
	if ( first > size() ) 
		count = 0; 
 
#ifdef _DEBUG 
	if(!(first >= 0)) 
		throw 1; 
	if(!(first + count <= size())) 
		throw 1; 
#endif	// _DEBUG 
 
	// optimize case of returning entire string 
	if ( first == 0 && first + count == size() ) 
		return *this; 
 
	StringEx dest; 
	allocCopy(dest, count, first, 0); 
	return dest; 
} 
 
StringEx StringEx::Right(int count) const 
{ 
	if (count < 0) 
		count = 0; 
	if (count >= size()) 
		return *this; 
 
	StringEx dest; 
	allocCopy( dest, count, size()-count, 0 ); 
	return dest; 
} 
 
StringEx StringEx::Left ( int count ) const 
{ 
	if ( count < 0 ) 
		count = 0; 
	if ( count >= size() ) 
		return *this; 
 
	StringEx dest; 
	allocCopy(dest, count, 0, 0); 
	return dest; 
} 
 
// strspn equivalent 
StringEx StringEx::SpanIncluding ( LPCTSTR charSet ) const 
{ 
	// get data 
	TCHAR * pData = (TCHAR *) c_str(); 
 
	return Left(_tcsspn(pData, charSet)); 
} 
 
// strcspn equivalent 
StringEx StringEx::SpanExcluding ( LPCTSTR charSet ) const 
{ 
	// get data 
	TCHAR * pData = (TCHAR *) c_str(); 
 
	return Left(_tcscspn(pData, charSet)); 
} 
 
 
 
void StringEx::operator = ( LPWSTR wstr ) 
{ 
	// get buffer 
	long   len    = wcslen(wstr); 
	char * buffer = new char[len+1]; 
	 
	if ( buffer ) 
	{ 
		wcstombs( buffer, wstr, len ); 
		((string &) *this) = buffer; 
		delete [] buffer; 
	} 
} 
 
 
void StringEx::operator += ( LPWSTR wstr ) 
{ 
	// get buffer 
	long   len    = wcslen(wstr); 
	char * buffer = new char[len+1]; 
	 
	if ( buffer ) 
	{ 
		wcstombs( buffer, wstr, len ); 
		((string &) *this) += buffer; 
		delete [] buffer; 
	} 
} 
 
//////////////////////////////////////////////////////////////////////////////////////// 
// StringList 
 
void StringList::getEmbeddedStr ( string & embeddedStr ) 
{ 
	// clear embedded string 
	embeddedStr = ""; 
 
	// get ptr to list 
	string str; 
 
	// copy list 
	for ( iterator item = begin(); item != end(); item++ ) 
	{ 
		// get string 
		str = *item; 
 
		// copy string 
		embeddedStr += str; 
		embeddedStr += '\0'; 
	} 
 
	// add final null terminator 
	embeddedStr += '\0'; 
} 
 
 
 
void StringList::setEmbeddedStr ( string & embeddedStr ) 
{ 
	// if nothing then move on 
	if ( embeddedStr.empty() ) 
		return; 
 
	// clear list 
	if ( !empty() ) 
		erase(begin(),end()); 
 
	appendEmbeddedStr(embeddedStr); 
} 
 
 
void StringList::appendEmbeddedStr ( string & embeddedStr ) 
{ 
	// if nothing then move on 
	if ( embeddedStr.empty() ) 
		return; 
 
	// init from embedded string 
	LPTSTR start = (LPTSTR) embeddedStr.c_str(); 
	LPTSTR end   = start + embeddedStr.size(); 
	for ( LPTSTR str = (LPTSTR) embeddedStr.c_str();  
	      *str != '\0'|| str > end;  ) 
	{ 
		// copy string 
		string tmpStr = str; 
 
		// add it 
		push_back(tmpStr); 
 
		// go to next string 
		int len = _tcslen(str) + 1; 
		str += len; 
	} 
} 
 
 
void StringList::operator -= ( StringList & list ) 
{ 
	// remove strings from our list that are in 
	// list 
	StringList result; 
	result.resize( size() + list.size() ); 
	std::set_difference( begin(), end(),  
					list.begin(), list.end(), 
					result.begin() ); 
 
	*this = result; 
} 
 
 
void StringList::operator += ( StringList & list ) 
{ 
	// add strings from list to ours 
	StringList result; 
	result.resize( size() + list.size() ); 
	std::set_union( begin(), end(), 
			   list.begin(), list.end(), 
			   result.begin() ); 
 
	*this = result; 
} 
 
 
void StringList::operator = ( StringList & list ) 
{ 
	// copy strings 
	if ( !empty() ) 
		clear(); 
	resize( list.size() ); 
	std::copy( list.begin(), list.end(), begin() ); 
} 
 
void StringList::removeDuplicates () 
{ 
	// remove duplicate strings from list 
	for ( iterator item = begin(); 
	      item != end(); 
		  item++ ) 
	{ 
 
		// get string 
		string & str = *item; 
 
		// start search after this string 
		iterator srch = item + 1; 
		if ( srch == end() ) 
			continue; 
 
		// search for it, if found remove it 
		iterator found = std::find( srch, end(), str ); 
		if ( found != end() ) 
			erase(found); 
 
	} 
}