///////////////////////////////////////////////////////////////////
//	INCLUDE
///////////////////////////////////////////////////////////////////

#include "STDAFX.H"
#include "STRINGSET.H"
#include <ALGORITHM>
#include <SET>


///////////////////////////////////////////////////////////////////
//	IMPLEMENTATION
///////////////////////////////////////////////////////////////////

//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::CStringSet
//*---------------------------------------------------------------
// DESC : 생성자
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::CStringSet()
{
	m_lpszStringBuffer = NULL;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::CStringSet
//*---------------------------------------------------------------
// DESC : 생성자
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::CStringSet(LPCTSTR pString)
{
	m_lpszStringBuffer = NULL;

	operator=(pString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::CStringSet
//*---------------------------------------------------------------
// DESC : 생성자
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::CStringSet(const CStringSet& pString)
{
	m_lpszStringBuffer = NULL;

	operator=(pString.Get());
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::CStringSet
//*---------------------------------------------------------------
// DESC : 생성자
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::CStringSet(const CStringSet* pString)
{
	m_lpszStringBuffer = NULL;

	operator=(pString->Get());
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::~CStringSet
//*---------------------------------------------------------------
// DESC : 소멸자
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::~CStringSet()
{
	Empty();
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsEmpty
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 유무 체크
// PARM : N/A
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsEmpty() const
{
	return (BOOL)(!m_lpszStringBuffer || _T('\0') == m_lpszStringBuffer[0]);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsNull
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터의 NULL 여부 체크
// PARM : N/A
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsNull() const
{
	return(!m_lpszStringBuffer);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Empty
//*---------------------------------------------------------------
// DESC : 문자열 버퍼를 제거, 초기화
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::Empty()
{
	if (m_lpszStringBuffer) {
		::free((LPVOID)((LPBYTE)(m_lpszStringBuffer) - sizeof(STRINGHEADER)));
		m_lpszStringBuffer = NULL;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::ReAlloc
//*---------------------------------------------------------------
// DESC : 문자열 데이터 버퍼를 제거, 초기화
// PARM :	1 . iNewSize - 새로 할당할 버퍼크기
//			2 . bForceTo - 버퍼크기를 앞에서 입력받은 값으로 강제로 맞출지 여부
// RETV : 새로 할당된 문자열 버퍼 포인터 반환
// PRGM : B4nFter
//*---------------------------------------------------------------
LPTSTR CStringSet::ReAlloc(INT iNewSize, BOOL bForceTo)
{
	if (iNewSize <= 0) {
		return NULL;
	}

	LPBYTE lpbtTempBuffer;
	LPSTRINGHEADER lpstStringHeader;
	if (m_lpszStringBuffer) {
		lpbtTempBuffer = (LPBYTE)(m_lpszStringBuffer) - sizeof(STRINGHEADER);
		if (bForceTo) {
			lpbtTempBuffer = (LPBYTE)::realloc(lpbtTempBuffer, iNewSize*sizeof(TCHAR)+sizeof(STRINGHEADER));
			lpstStringHeader = (LPSTRINGHEADER)(lpbtTempBuffer);
			lpstStringHeader->m_iSize = iNewSize;
			if (lpstStringHeader->m_iLinePtr > iNewSize-1) {
				lpstStringHeader->m_iLinePtr = iNewSize-1;
			}
		}
		else {
			lpstStringHeader = (LPSTRINGHEADER)(lpbtTempBuffer);
			if (lpstStringHeader->m_iSize < iNewSize) {
				lpbtTempBuffer = (LPBYTE)::realloc(lpbtTempBuffer, iNewSize*sizeof(TCHAR)+sizeof(STRINGHEADER));
				lpstStringHeader = (LPSTRINGHEADER)(lpbtTempBuffer);
				lpstStringHeader->m_iSize = iNewSize;
			}
		}
	}
	else {
		lpbtTempBuffer = (LPBYTE)::calloc(iNewSize*sizeof(TCHAR)+sizeof(STRINGHEADER), sizeof(BYTE));
		if (lpbtTempBuffer) {
			lpstStringHeader = (LPSTRINGHEADER)(lpbtTempBuffer);
			lpstStringHeader->m_iLinePtr = 0;
			lpstStringHeader->m_iSize = iNewSize;
		}
	}

	if (lpbtTempBuffer) {
		m_lpszStringBuffer = (LPTSTR)(lpbtTempBuffer+sizeof(STRINGHEADER));
		lpstStringHeader = (LPSTRINGHEADER)(lpbtTempBuffer);
		m_lpszStringBuffer[lpstStringHeader->m_iSize-1] = _T('\0');
		return m_lpszStringBuffer;
	}
	return NULL;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Get
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환
// PARM : N/A
// RETV : 문자열 버퍼 포인터 반환
// PRGM : B4nFter
//*---------------------------------------------------------------
LPCTSTR CStringSet::Get() const
{
	return m_lpszStringBuffer;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetA
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환 (ASCII 형식)
// PARM : N/A
// RETV : 문자열 버퍼 포인터 반환 (ASCII 형식, HEAP 메모리)
// PRGM : B4nFter
// P.S.>
//		- 반환된 문자열 데이터는 NULL이 아닐 경우 반드시 ::free() 로 해제되어야 함
//*---------------------------------------------------------------
LPCSTR CStringSet::GetA() const
{
	return ::strdup(CT2A(m_lpszStringBuffer));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetW
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환 (UNICODE 형식)
// PARM : N/A
// RETV : 문자열 버퍼 포인터 반환 (UNICODE 형식, HEAP 메모리)
// PRGM : B4nFter
// P.S.>
//		- 반환된 문자열 데이터는 NULL이 아닐 경우 반드시 ::free() 로 해제되어야 함
//*---------------------------------------------------------------
LPCWSTR CStringSet::GetW() const
{
	return ::wcsdup(CT2W(m_lpszStringBuffer));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Get
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환 (UNICODE 형식)
// PARM :	1 . nStart - 문자열 버퍼 포인터의 시작점
// RETV : 문자열 버퍼 포인터 반환 (UNICODE 형식)
// PRGM : B4nFter
//*---------------------------------------------------------------
LPCTSTR CStringSet::Get(INT nStart) const
{
	if (!m_lpszStringBuffer) {
		return NULL;
	}

	INT nSize = GetSize();
	if (nSize <= 0 || nStart < 0 || nSize-1 < nStart) {
		return NULL;
	}

	return m_lpszStringBuffer + nStart;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetA
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환 (ASCII 형식)
// PARM :	1 . nStart - 문자열 버퍼 포인터의 시작점
// RETV : 문자열 버퍼 포인터 반환 (ASCII 형식, HEAP 메모리)
// PRGM : B4nFter
// P.S.>
//		- 반환된 문자열 데이터는 NULL이 아닐 경우 반드시 ::free() 로 해제되어야 함
//*---------------------------------------------------------------
LPCSTR CStringSet::GetA(INT nStart) const
{
	if (!m_lpszStringBuffer) {
		return NULL;
	}

	INT nSize = GetSize();
	if (nSize <= 0 || nStart < 0 || nSize-1 < nStart) {
		return NULL;
	}

	return ::strdup(CT2A(m_lpszStringBuffer + nStart));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetW
//*---------------------------------------------------------------
// DESC : 문자열 버퍼 포인터를 반환 (UNICODE 형식)
// PARM :	1 . nStart - 문자열 버퍼 포인터의 시작점
// RETV : 문자열 버퍼 포인터 반환 (UNICODE 형식, HEAP 메모리)
// PRGM : B4nFter
// P.S.>
//		- 반환된 문자열 데이터는 NULL이 아닐 경우 반드시 ::free() 로 해제되어야 함
//*---------------------------------------------------------------
LPCWSTR CStringSet::GetW(INT nStart) const
{
	if (!m_lpszStringBuffer) {
		return NULL;
	}

	INT nSize = GetSize();
	if (nSize <= 0 || nStart < 0 || nSize-1 < nStart) {
		return NULL;
	}

	return ::wcsdup(CT2W(m_lpszStringBuffer + nStart));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetLine
//*---------------------------------------------------------------
// DESC : 전체 문자열 중 한 줄을 반환
// PARM : N/A
// PARM :	1 . nStart - 문자열 버퍼 포인터의 시작점
// RETV : 전체 문자열 중 한 줄을 반환한 CStringSet 객체
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::GetLine()
{ 
	CStringSet aString;
	if (!IsEmpty()) {
		INT iStartPtr = GetLinePtr();
		aString = Tokenize(DF_DEFAULT_NEWLINE_TOKEN_STRING, iStartPtr);
		SetLinePtr(iStartPtr);
	}
	return aString;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetLength
//*---------------------------------------------------------------
// DESC : 문자열의 길이를 반환 (TCHAR 기준)
// PARM : N/A
// RETV : 문자열의 길이
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::GetLength() const
{
	if (m_lpszStringBuffer) {
		return (INT)_tcslen(m_lpszStringBuffer);
	}
	else {
		return 0;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetHeader
//*---------------------------------------------------------------
// DESC : 문자열 버퍼헤더를 반환
// PARM : N/A
// RETV : 문자열 버퍼헤더
// PRGM : B4nFter
//*---------------------------------------------------------------
LPSTRINGHEADER CStringSet::GetHeader() const
{
	if (m_lpszStringBuffer) {
		return (LPSTRINGHEADER)((LPBYTE)(m_lpszStringBuffer) - sizeof(STRINGHEADER));
	}
	else {
		return NULL;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetSize
//*---------------------------------------------------------------
// DESC : 문자열 버퍼의 길이를 반환 (TCHAR 기준)
// PARM : N/A
// RETV : 문자열 버퍼의 길이
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::GetSize() const
{
	if (m_lpszStringBuffer) {
		return GetHeader()->m_iSize;
	}
	else {
		return 0;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetLinePtr
//*---------------------------------------------------------------
// DESC : 문자열의 한 줄을 구분하는 포인터를 반환
// PARM : N/A
// RETV : 문자열 줄구분 포인터
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::GetLinePtr() const
{
	if (m_lpszStringBuffer) {
		return GetHeader()->m_iLinePtr;
	}
	else {
		return 0;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::SetLinePtr
//*---------------------------------------------------------------
// DESC : 문자열의 한 줄을 구분하는 포인터를 지정
// PARM :	1 . iLinePtr - 문자열의 한 줄을 구분하는 포인터 값
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::SetLinePtr(INT iLinePtr)
{
	if (m_lpszStringBuffer) {
		GetHeader()->m_iLinePtr = iLinePtr;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Reset
//*---------------------------------------------------------------
// DESC : 문자열 데이터와 헤더를 리셋
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::Reset()
{
	if (m_lpszStringBuffer) {
		m_lpszStringBuffer[0] = _T('\0');
		GetHeader()->m_iLinePtr = 0;
	}	
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::ResetLinePtr
//*---------------------------------------------------------------
// DESC : 문자열의 한 줄을 구분하는 포인터를 초기화
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::ResetLinePtr()
{
	if (m_lpszStringBuffer) {
		GetHeader()->m_iLinePtr = 0;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::GetAt
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 특정 위치에 있는 문자를 반환 (TCHAR 기준)
// PARM :	1 . nIndex - 문자열 데이터의 특정 위치
// RETV : 문자열 데이터의 특정 위치에 있는 문자
// PRGM : B4nFter
//*---------------------------------------------------------------
#pragma warning (disable:4310)
TCHAR CStringSet::GetAt(INT nIndex) const
{
	INT nLength = GetLength();
	if (nIndex >= 0 && nIndex < nLength) {
		return m_lpszStringBuffer[nIndex];
	}

	return (TCHAR)(0xFFFF);
}
#pragma warning (default:4310)


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::SetAt
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 특정 위치에 문자를 지정 (TCHAR 기준)
// PARM :	1 . nIndex - 문자열 데이터의 특정 위치
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::SetAt(INT nIndex, TCHAR cChar)
{
	INT nLength = GetLength();
	if (nIndex >= 0 && nIndex < nLength) {
		m_lpszStringBuffer[nIndex] = cChar;
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator[]
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 특정 위치에 있는 문자를 반환, GetAt() 과 같음 (TCHAR 기준)
// PARM :	1 . nIndex - 문자열 데이터의 특정 위치
// RETV : 문자열 데이터의 특정 위치에 있는 문자
// PRGM : B4nFter
//*---------------------------------------------------------------
TCHAR CStringSet::operator[](INT nIndex) const
{
	INT nLength = GetLength();
	if (nIndex >= 0 && nIndex < nLength-1) {
		return m_lpszStringBuffer[nIndex];
	}
	return _T('\0');
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator LPCTSTR
//*---------------------------------------------------------------
// DESC : CStringSet 클래스의 LPCTSTR 형 변환연산자
// PARM : N/A
// RETV : LPCTSTR 형 문자열 데이터
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet::operator LPCTSTR() const
{
	if (m_lpszStringBuffer) {
		return const_cast<LPCTSTR>(m_lpszStringBuffer);
	}
	return NULL;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator=
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 문자열 데이터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator=(LPCTSTR pString)
{
	if (pString) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize = (INT)_tcslen(pString)+1;
		if (iSize > 0 && GetSize() < iSize) {
			aStringBuffer = ReAlloc(iSize);
		}
		if (aStringBuffer) {
			_tcsncpy(aStringBuffer, pString, GetSize()-1);
		}
	}
	else {
		Reset();
	}
	ResetLinePtr();
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator=
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 CStringSet 객체
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator=(CStringSet& pString)
{
	if (!pString.IsEmpty()) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize = pString.GetSize();
		if (iSize > 0 && GetSize() < iSize) {
			aStringBuffer = ReAlloc(iSize);
		}
		if (aStringBuffer) {
			_tcsncpy(aStringBuffer, pString.Get(), GetSize()-1);
		}
	}
	else {
		Reset();
	}
	ResetLinePtr();
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator=
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 CStringSet 객체 포인터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator=(CStringSet* pString)
{
	if (pString && !pString->IsEmpty()) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize = pString->GetSize();
		if (iSize > 0 && GetSize() < iSize) {
			aStringBuffer = ReAlloc(iSize);
		}
		if (aStringBuffer) {
			_tcsncpy(aStringBuffer, pString->Get(), GetSize()-1);
		}
	}
	else {
		Reset();
	}
	ResetLinePtr();
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator+=
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 문자열 데이터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator+=(LPCTSTR pString)
{
	if (pString) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize1 = (INT)_tcslen(pString)+1;
		INT iSize2 = GetSize();
		INT nLength = GetLength();
		if (iSize1 > iSize2 - nLength - 1) {
			aStringBuffer = ReAlloc(iSize1 + iSize2);
		}
		if (aStringBuffer) {
			_tcsncat(aStringBuffer, pString, GetSize()-1);
		}
	}
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator+=
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 CStringSet 객체 (문자열 데이터)
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator+=(CStringSet& pString)
{
	if (!pString.IsEmpty()) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize1 = pString.GetSize();
		INT iSize2 = GetSize();
		INT nLength = GetLength();
		if (iSize1 > iSize2 - nLength - 1) {
			aStringBuffer = ReAlloc(iSize1 + iSize2);
		}
		if (aStringBuffer) {
			_tcsncat(aStringBuffer, pString.Get(), GetSize()-1);
		}
	}
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator+=
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 CStringSet 객체 포인터 (문자열 데이터)
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::operator+=(CStringSet* pString)
{
	if (pString && !pString->IsEmpty()) {
		LPTSTR aStringBuffer = m_lpszStringBuffer;
		INT iSize1 = pString->GetSize();
		INT iSize2 = GetSize();
		INT nLength = GetLength();
		if (iSize1 > iSize2 - nLength - 1) {
			aStringBuffer = ReAlloc(iSize1 + iSize2);
		}
		if (aStringBuffer) {
			_tcsncat(aStringBuffer, pString->Get(), GetSize()-1);
		}
	}
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator==
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 == 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator==(LPCTSTR pString) const
{
	return (Compare(pString) == 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator==
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 == 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator==(const CStringSet& pString) const
{
	return (Compare(pString.Get()) == 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator==
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 == 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator==(const CStringSet* pString) const
{
	return (Compare(pString->Get()) == 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator!=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 != 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator!=(LPCTSTR pString) const
{
	return (Compare(pString) != 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator!=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 == 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator!=(const CStringSet& pString) const
{
	return (Compare(pString.Get()) != 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator!=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 != 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator!=(const CStringSet* pString) const
{
	return (Compare(pString->Get()) != 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 < 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<(LPCTSTR pString) const
{
	return (Compare(pString) < 0);
}

//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 < 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<(const CStringSet& pString) const
{
	return (Compare(pString.Get()) < 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 < 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<(const CStringSet* pString) const
{
	return (Compare(pString->Get()) < 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 > 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>(LPCTSTR pString) const
{
	return (Compare(pString) > 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 > 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>(const CStringSet& pString) const
{
	return (Compare(pString.Get()) > 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 > 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>(const CStringSet* pString) const
{
	return (Compare(pString->Get()) > 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 <= 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<=(LPCTSTR pString) const
{
	return (Compare(pString) <= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 <= 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<=(const CStringSet& pString) const
{
	return (Compare(pString.Get()) <= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator<=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 <= 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator<=(const CStringSet* pString) const
{
	return (Compare(pString->Get()) <= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 >= 비교연산
// PARM :	1 . pString - 비교할 문자열
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>=(LPCTSTR pString) const
{
	return (Compare(pString) >= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 >= 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>=(const CStringSet& pString) const
{
	return (Compare(pString.Get()) >= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::operator>=
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 >= 비교연산
// PARM :	1 . pString - 비교할 CStringSet 객체 포인터 (문자열 데이터)
// RETV : true - 성공 / false - 실패 (stl 컨테이너의 인자로 사용하기 위해 BOOL 대신 bool 사용)
// PRGM : B4nFter
//*---------------------------------------------------------------
bool CStringSet::operator>=(const CStringSet* pString) const
{
	return (Compare(pString->Get()) >= 0);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Set
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 문자열 데이터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Set(LPCTSTR pString)
{
	return(operator=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Set
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 CStringSet 객체
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Set(CStringSet& pString)
{
	return(operator=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Set
//*---------------------------------------------------------------
// DESC : 대입 연산자 구현
// PARM :	1 . pString - CStringSet 객체에 치환할 CStringSet 객체 포인터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Set(CStringSet* pString)
{
	return(operator=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Append
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 문자열 데이터
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Append(LPCTSTR pString)
{
	return(operator+=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Append
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 CStringSet 객체 (문자열 데이터)
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Append(CStringSet& pString)
{
	return(operator+=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Append
//*---------------------------------------------------------------
// DESC : 증가 연산자 구현
// PARM :	1 . pString - CStringSet 객체의 문자열 데이터에 추가될 CStringSet 객체 포인터 (문자열 데이터)
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Append(CStringSet* pString)
{
	return(operator+=(pString));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Tokenize
//*---------------------------------------------------------------
// DESC : 구분자 (문자)들을 경계로 부분으로 나눔
// PARM :	1 . lpszTokens - 구분자 (문자집합, \0으로 끝남)
//			2 . iStartPtr - 문자열 데이터 중 특정 위치
// RETV : 
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::Tokenize(LPCTSTR lpszTokens, INT& iStartPtr)
{
	CStringSet aString;
	INT nLength = GetLength();
	if (IsEmpty() || iStartPtr < 0 || iStartPtr >= nLength) {
		return aString;
	}

	std::set<TCHAR> setTokens;
	INT iIndex;

	if (!lpszTokens || lpszTokens[0] == _T('\0')) {
		setTokens.insert(DF_DEFAULT_NEWLINE_TOKEN_CHAR);
	}
	else {
		for (iIndex = 0 ; lpszTokens[iIndex] != _T('\0') ; ++iIndex) {
			setTokens.insert(lpszTokens[iIndex]);
		}
	}
	
	for (iIndex = iStartPtr ; iIndex < nLength ; ++iIndex) {
		if (setTokens.find(m_lpszStringBuffer[iIndex]) != setTokens.end()) {
			break;
		}
	}

	if (iStartPtr < iIndex) {
		LPTSTR aStringBuffer = aString.ReAlloc(iStartPtr+iIndex+1);
		if (aStringBuffer) {
			::memcpy(aStringBuffer, m_lpszStringBuffer+iStartPtr, (iIndex - iStartPtr)*sizeof(TCHAR));
			aStringBuffer[iIndex - iStartPtr] = _T('\0');
		}
	}
	iStartPtr = ++iIndex;
	return(aString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Format
//*---------------------------------------------------------------
// DESC : 특정 문자열 형식의 값으로 치환
// PARM :	1 . lpszFormat - 특정 문자열 형식
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::Format(LPCTSTR lpszFormat, ...)
{
	if (!lpszFormat) {
		return;
	}

	TCHAR szFormat[DF_MAX_FORMAT_TEMPBUFFER_SIZE] = {0,};

	va_list lpArgPtr;
	INT iChrWritten;

	va_start(lpArgPtr, lpszFormat);
	iChrWritten = VSNPRINTF(szFormat, COUNT_OF(szFormat), lpszFormat, lpArgPtr);
	BASE_ASSERT(0 < iChrWritten,	"Invalid!");
	va_end(lpArgPtr);
	
	INT iLength = (INT)_tcslen(szFormat);
	if (iLength > 0) {
		LPTSTR aStringBuffer = ReAlloc(iLength+1);
		if (aStringBuffer) {
			_tcsncpy(aStringBuffer, szFormat, GetSize());
		}
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::TrimLeft
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 왼쪽 공백을 제거
// PARM : N/A
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::TrimLeft()
{
	INT nLength = GetLength();
	if (nLength > 0) {
		INT iStartPtr = 0;
		for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
			if (m_lpszStringBuffer[iIndex] == _T(' ')) {
				iStartPtr = iIndex + 1;
			}
			else {
				break;
			}
		}
		if (iStartPtr > 1) {
			::memmove(m_lpszStringBuffer, m_lpszStringBuffer+iStartPtr, (nLength-iStartPtr)*sizeof(TCHAR));
			m_lpszStringBuffer[nLength-iStartPtr] = _T('\0');
		}
	}
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::TrimRight
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 오른쪽 공백을 제거
// PARM : N/A
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::TrimRight()
{
	INT nLength = GetLength();
	if (nLength > 0) {
		for (INT iIndex = nLength - 1 ; iIndex >= 0 ; --iIndex) {
			if (m_lpszStringBuffer[iIndex] == _T(' ')) {
				m_lpszStringBuffer[iIndex] = _T('\0');
			}
			else {
				break;
			}
		}
	}
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Trim
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 양쪽 공백을 제거
// PARM : N/A
// RETV : CStringSet 객체 자신의 참조
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet& CStringSet::Trim()
{
	TrimLeft();
	TrimRight();
	return(*this);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Mid
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 가운데 특정 범위의 문자열을 얻음
// PARM :	1 . nFirst - 문자열 데이터를 얻을 시작위치
//			2 . nCount - 얻어올 문자의 개수
// RETV : 얻은 문자열
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::Mid(INT nFirst, INT nCount) const
{
	CStringSet aString;
	INT nLength = GetLength();
	if (nFirst >= 0 && 
		nCount > 0 &&
		!IsEmpty() &&
		nLength > nFirst
		) 
	{
		if (nFirst + nCount > nLength) {
			nCount = nLength - nFirst;
		}
		LPTSTR aStringBuffer1 = aString.ReAlloc(nCount+1);
		LPTSTR aStringBuffer2 = m_lpszStringBuffer;
		::memcpy(aStringBuffer1, aStringBuffer2+nFirst, nCount*sizeof(TCHAR));
		aStringBuffer1[nCount] = _T('\0');
	}
	return(aString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Mid
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 가운데 특정 위치부터 끝까지의 문자열을 얻음
// PARM :	1 . nFirst - 문자열 데이터를 얻을 시작위치
// RETV : 얻은 문자열
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::Mid(INT nFirst) const
{
	CStringSet aString;
	INT nLength = GetLength();
	INT nCount = 0;
	if (nFirst >= 0 && 
		!IsEmpty() &&
		nLength > nFirst
		) 
	{
		nCount = nLength - nFirst;
		LPTSTR aStringBuffer1 = aString.ReAlloc(nCount+1);
		LPTSTR aStringBuffer2 = m_lpszStringBuffer;
		::memcpy(aStringBuffer1, aStringBuffer2+nFirst, nCount*sizeof(TCHAR));
		aStringBuffer1[nCount] = _T('\0');
	}
	return(aString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Left
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 왼쪽부터 특정 개수만큼 문자열을 얻음
// PARM :	1 . nCount - 얻어올 문자의 개수
// RETV : 얻은 문자열
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::Left(INT nCount) const
{
	CStringSet aString;
	INT nLength = GetLength();
	if (!IsEmpty() &&
		nCount > 0
		) 
	{
		if (nCount > nLength) {
			nCount = nLength;
		}
		LPTSTR aStringBuffer1 = aString.ReAlloc(nCount+1);
		LPTSTR aStringBuffer2 = m_lpszStringBuffer;
		::memcpy(aStringBuffer1, aStringBuffer2, nCount*sizeof(TCHAR));
		aStringBuffer1[nCount] = _T('\0');
	}
	return(aString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Right
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 오른쪽부터 특정 개수만큼 문자열을 얻음
// PARM :	1 . nCount - 얻어올 문자의 개수
// RETV : 얻은 문자열
// PRGM : B4nFter
//*---------------------------------------------------------------
CStringSet CStringSet::Right(INT nCount) const
{
	CStringSet aString;
	INT nLength = GetLength();
	if (!IsEmpty() &&
		nCount > 0
		) 
	{
		if (nCount > nLength) {
			nCount = nLength;
		}
		LPTSTR aStringBuffer1 = aString.ReAlloc(nCount+1);
		LPTSTR aStringBuffer2 = m_lpszStringBuffer;
		::memcpy(aStringBuffer1, aStringBuffer2+nLength-nCount, nCount*sizeof(TCHAR));
		aStringBuffer1[nCount] = _T('\0');
	}
	return(aString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsAlpha
//*---------------------------------------------------------------
// DESC : 문자열 데이터가 영문자인지 체크
// PARM : N/A
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsAlpha() const
{
	if (!m_lpszStringBuffer) {
		return FALSE;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return FALSE;
	}

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		if (!_istalpha(m_lpszStringBuffer[iIndex])) {
			return FALSE;
		}
	}
	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsNumeric
//*---------------------------------------------------------------
// DESC : 문자열 데이터가 숫자인지 체크
// PARM : N/A
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsNumeric() const
{
	if (!m_lpszStringBuffer) {
		return FALSE;
	}

	BOOL bHasNumeric = FALSE;
	INT nLength = GetLength();
	if (nLength <= 0) {
		return FALSE;
	}

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		if (iIndex == 0 && m_lpszStringBuffer[iIndex] == _T('-')) {
			continue;
		}
		if (!_istdigit(m_lpszStringBuffer[iIndex])) {
			return FALSE;
		}
		bHasNumeric = TRUE;
	}
	return bHasNumeric;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsNumeric
//*---------------------------------------------------------------
// DESC : 문자열 데이터가 숫자 (실수 포함) 인지 체크
// PARM :	1 . bIsRealNumber - 문자열 데이터가 실수인지 여부를 반환받음
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsNumeric(BOOL &bIsRealNumber) const
{
	if (!m_lpszStringBuffer) {
		return FALSE;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return FALSE;
	}

	BOOL bHasNumeric = FALSE;
	INT nDotCount = 0;	//  소수점 ('.') 의 개수
	bIsRealNumber = FALSE;

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		if (iIndex == 0 && m_lpszStringBuffer[iIndex] == _T('-')) {
			continue;
		}
		if (iIndex > 0 && m_lpszStringBuffer[iIndex] == _T('.')) {
			++nDotCount;
			continue;
		}
		if (!_istdigit(m_lpszStringBuffer[iIndex])) {
			return FALSE;
		}
		bHasNumeric = TRUE;
	}
	if (nDotCount > 1) {
		return FALSE;
	}
	if (nDotCount == 1) {
		bIsRealNumber = TRUE;
	}
	return bHasNumeric;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsAlNum
//*---------------------------------------------------------------
// DESC : 문자열 데이터가 영문자 혹은 숫자인지 체크
// PARM : N/A
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsAlNum() const
{
	if (!m_lpszStringBuffer) {
		return FALSE;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return FALSE;
	}

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		if (!_istalnum(m_lpszStringBuffer[iIndex])) {
			return FALSE;
		}
	}
	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::IsAlNum
//*---------------------------------------------------------------
// DESC : 문자열 데이터가 영문자 혹은 숫자 (실수 포함) 인지 체크
// PARM :	1 . bIsRealNumber - 문자열 데이터가 실수인지 여부를 반환받음
// RETV : TRUE - 성공 / FALSE - 실패
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CStringSet::IsAlNum(BOOL &bIsRealNumber) const
{
	if (!m_lpszStringBuffer) {
		return FALSE;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return FALSE;
	}

	INT nDotCount = 0;	//  소수점 ('.') 의 개수
	bIsRealNumber = FALSE;

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		if (_istalnum(m_lpszStringBuffer[iIndex])) {
			continue;
		}
		if (m_lpszStringBuffer[iIndex] == _T('.')) {
			continue;
		}
		return FALSE;
	}
	if (nDotCount > 1) {
		return FALSE;
	}
	if (nDotCount == 1) {
		bIsRealNumber = TRUE;
	}
	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Compare
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 동등, 대소관계를 비교
// PARM :	1 . pString - 비교할 문자열
// RETV : 0:같음/음수:작음/양수:큼/_NLSCMPERROR:에러
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::Compare(LPCTSTR pString) const
{
	return _tcscmp(m_lpszStringBuffer, pString);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::CompareNoCase
//*---------------------------------------------------------------
// DESC : 객체의 문자열 데이터와 특정 문자열의 동등, 대소관계를 비교 (대소문자 구분없음)
// PARM :	1 . pString - 비교할 문자열
// RETV : 0:같음/음수:작음/양수:큼/_NLSCMPERROR:에러
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::CompareNoCase(LPCTSTR pString) const
{
	return _tcsnicmp(m_lpszStringBuffer, pString, GetLength());
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::MakeUpper
//*---------------------------------------------------------------
// DESC : 문자열 데이터를 대문자로 변환
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::MakeUpper()
{
	if (!m_lpszStringBuffer) {
		return;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return;
	}

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		m_lpszStringBuffer[iIndex] = (TCHAR)_totupper(m_lpszStringBuffer[iIndex]);
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::MakeLower
//*---------------------------------------------------------------
// DESC : 문자열 데이터를 소문자로 변환
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::MakeLower()
{
	if (!m_lpszStringBuffer) {
		return;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return;
	}

	for (INT iIndex = 0 ; iIndex < nLength ; ++iIndex) {
		m_lpszStringBuffer[iIndex] = (TCHAR)_totlower(m_lpszStringBuffer[iIndex]);
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::MakeReverse
//*---------------------------------------------------------------
// DESC : 문자열 데이터의 좌우를 뒤집음
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CStringSet::MakeReverse()
{
	if (!m_lpszStringBuffer) {
		return;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return;
	}

	std::reverse(&m_lpszStringBuffer[0], &m_lpszStringBuffer[nLength]);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Find
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자의 위치를 찾아서 반환
// PARM :	1 . cChar - 찾을 문자
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::Find(TCHAR cChar) const
{
	if (!m_lpszStringBuffer) {
		return -1;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return -1;
	}

	TCHAR *lpcChar = _tcschr(m_lpszStringBuffer, cChar);
	if (lpcChar) {
		return (INT)(lpcChar - m_lpszStringBuffer);
	}
	return -1;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::ReverseFind
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자의 위치를 뒤에서부터 찾아서 반환
// PARM :	1 . cChar - 
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::ReverseFind(TCHAR cChar) const
{
	if (!m_lpszStringBuffer) {
		return -1;
	}

	INT nLength = GetLength();
	if (nLength <= 0) {
		return -1;
	}

	TCHAR *lpcChar = _tcsrchr(m_lpszStringBuffer, cChar);
	if (lpcChar) {
		return (INT)(lpcChar - m_lpszStringBuffer);
	}
	return -1;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Find
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자의 위치를 특정 위치부터 시작하여 찾아서 반환
// PARM :	1 . cChar - 찾을 문자
//			2 . nStart - 문자을 찾기 시작할 위치
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::Find(TCHAR cChar, INT nStart) const
{
	if (!m_lpszStringBuffer) {
		return -1;
	}

	INT nLength = GetLength();
	if (nLength <= 0 || nStart < 0 || nLength-1 < nStart) {
		return -1;
	}

	TCHAR *lpcChar = _tcschr(m_lpszStringBuffer+nStart, cChar);
	if (lpcChar) {
		return (INT)(lpcChar - m_lpszStringBuffer);
	}
	return -1;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::FindOneOf
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자집합에 속하는 문자의 위치를 찾아서 반환
// PARM :	1 . lpszCharSet - 찾을 문자집합
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::FindOneOf(LPCTSTR lpszCharSet) const
{
	if (!m_lpszStringBuffer || !lpszCharSet) {
		return -1;
	}

	INT nLength1 = GetLength();
	if (nLength1 <= 0) {
		return -1;
	}
	INT nLength2 = (INT)_tcslen(lpszCharSet);
	if (nLength2 <= 0) {
		return -1;
	}

	std::set<TCHAR> setTokens;
	for (INT iIndex = 0 ; iIndex < nLength2 ; ++iIndex) {
		setTokens.insert(lpszCharSet[iIndex]);
	}

	for (INT iIndex = 0 ; iIndex < nLength1 ; ++iIndex) {
		if (setTokens.find(m_lpszStringBuffer[iIndex]) != setTokens.end()) {
			return iIndex;
		}
	}
	return -1;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::FindOneOf
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자집합에 속하는 문자의 위치를 찾아서 반환 (특정 위치부터 시작)
// PARM :	1 . lpszCharSet - 찾을 문자집합
//			2 . nStart - 찾기 시작할 위치
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::FindOneOf(LPCTSTR lpszCharSet, INT nStart) const
{
	if (!m_lpszStringBuffer || !lpszCharSet) {
		return -1;
	}

	INT nLength1 = GetLength();
	if (nLength1 <= 0 || nStart < 0 || nLength1-1 < nStart) {
		return -1;
	}
	INT nLength2 = (INT)_tcslen(lpszCharSet);
	if (nLength2 <= 0) {
		return -1;
	}

	std::set<TCHAR> setTokens;
	for (INT iIndex = 0 ; iIndex < nLength2 ; ++iIndex) {
		setTokens.insert(lpszCharSet[iIndex]);
	}

	for (INT iIndex = nStart ; iIndex < nLength1 ; ++iIndex) {
		if (setTokens.find(m_lpszStringBuffer[iIndex]) != setTokens.end()) {
			return iIndex;
		}
	}
	return -1;
}



//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Find
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자열의 위치를 찾아서 반환
// PARM :	1 . lpszSub - 찾을 문자열
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::Find(LPCTSTR lpszSub) const
{
	if (!m_lpszStringBuffer || !lpszSub) {
		return -1;
	}

	INT nLength1 = GetLength();
	if (nLength1 <= 0) {
		return -1;
	}
	INT nLength2 = (INT)_tcslen(lpszSub);
	if (nLength2 <= 0) {
		return -1;
	}
	
	LPTSTR lpszStr = _tcsstr(m_lpszStringBuffer, lpszSub);
	if (lpszStr) {
		return (INT)(lpszStr - m_lpszStringBuffer);
	}
	return -1;	
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CStringSet::Find
//*---------------------------------------------------------------
// DESC : 문자열 데이터 중 특정 문자열의 위치를 특정 위치부처 시작하여 찾아서 반환
// PARM :	1 . lpszSub - 찾을 문자열
//			2 . nStart - 문자열을 찾기 시작할 위치
// RETV : 찾은 문자의 위치 (없으면 -1 반환)
// PRGM : B4nFter
//*---------------------------------------------------------------
INT CStringSet::Find(LPCTSTR lpszSub, INT nStart) const
{
	if (!m_lpszStringBuffer || !lpszSub) {
		return -1;
	}

	INT nLength1 = GetLength();
	if (nLength1 <= 0 || nStart < 0 || nLength1-1 < nStart) {
		return -1;
	}
	INT nLength2 = (INT)_tcslen(lpszSub);
	if (nLength2 <= 0) {
		return -1;
	}

	LPTSTR lpszStr = _tcsstr(m_lpszStringBuffer+nStart, lpszSub);
	if (lpszStr) {
		return (INT)(lpszStr - m_lpszStringBuffer);
	}
	return -1;	
}