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

#include "STDAFX.H"
#include "FILESET.H"


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

#pragma warning (disable:4238)
CFileSet::FILEBOMTYPEDAT CFileSet::m_stBomTypeDat[EV_BT_NONE] = {
	CFileSet::FILEBOMTYPEDAT(EV_BT_UTF8,		&CVarArgA<UCHAR_MAX>("%c%c%c",		0xEF,0xBB,0xBF),		3),
	CFileSet::FILEBOMTYPEDAT(EV_BT_UTF16_LE,	&CVarArgA<UCHAR_MAX>("%c%c",		0xFF,0xFE),				2),
	CFileSet::FILEBOMTYPEDAT(EV_BT_UTF16_BE,	&CVarArgA<UCHAR_MAX>("%c%c",		0xFE,0xFF),				2),
// 	CFileSet::FILEBOMTYPEDAT(EV_BT_UTF32_LE,	&CVarArgA<UCHAR_MAX>("%c%c%c%c",	0xFF,0xFE,0x00,0x00),	4),
// 	CFileSet::FILEBOMTYPEDAT(EV_BT_UTF32_BE,	&CVarArgA<UCHAR_MAX>("%c%c%c%c",	0x00,0x00,0xFE,0xFF),	4),
};
#pragma warning (default:4238)


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::CFileSet
//*---------------------------------------------------------------
// DESC : »ý¼ºÀÚ
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CFileSet::CFileSet()
{
	Reset();
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::~CFileSet
//*---------------------------------------------------------------
// DESC : ¼Ò¸êÀÚ
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CFileSet::~CFileSet()
{
	Close();
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Reset
//*---------------------------------------------------------------
// DESC : ÆÄÀÏ°ü·Ã ÀÚ¿ø ÃʱâÈ­
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
// P.S.>
//		- ÇÚµéÀ» ´Ý´Â°ÍÀÌ ¾Æ´Ï¹Ç·Î ÁÖÀÇ
//*---------------------------------------------------------------
VOID CFileSet::Reset()
{
	m_hFile = INVALID_HANDLE_VALUE;
	::memset(m_szFileFullPath, 0, sizeof(m_szFileFullPath));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Open
//*---------------------------------------------------------------
// DESC : ÆÄÀÏÀ» ¿­°í ÀÚ¿øÀ» ÇÒ´ç
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . bIsReadOnly - ÀбâÀü¿ë ¿©ºÎ
//			3 . bIsAppend - ÆÄÀÏ¿¡ µ¥ÀÌÅ͸¦ Ãß°¡ÇÏ´Â °ÍÀ¸·Î ÇÒÁö ¿©ºÎ (bIsReadOnly == FALSE ÀÏ ¶§¸¸ À¯È¿)
//			4 . bIsReadShare - Àбâ°øÀ¯ ¿©ºÎ
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::Open(LPCTSTR lpszFileName, BOOL bIsReadOnly, BOOL bIsAppend, BOOL bIsReadShare)
{
	BASE_ASSERT(FALSE == IsOpen(),		"Invalid!");
	BASE_ASSERT(NULL != lpszFileName,	"Invalid!");

	DWORD dwDesiredAccess;
	DWORD dwShareMode;
	DWORD dwCreationDisposition;
	DWORD dwFlagsAndAttributes;

	if (bIsReadOnly) {
		dwDesiredAccess = GENERIC_READ;
		dwShareMode = FILE_SHARE_READ;
		dwCreationDisposition = OPEN_EXISTING;
		dwFlagsAndAttributes = FILE_FLAG_SEQUENTIAL_SCAN | FILE_ATTRIBUTE_READONLY;
		if (!bIsReadShare) { 
			dwShareMode |= FILE_SHARE_WRITE;
		}
	}
	else {
		dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
		dwShareMode = FILE_SHARE_READ;
		dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
		if (bIsAppend) {
			dwCreationDisposition = OPEN_ALWAYS;
		}
		else {
			dwCreationDisposition = CREATE_NEW;
		}
	}

	DWORD dwRetVal = Open(lpszFileName, dwDesiredAccess, dwShareMode, dwCreationDisposition, dwFlagsAndAttributes, NULL, NULL);
	if (NOERROR != dwRetVal) {
		return dwRetVal;
	}

	if (!bIsReadOnly) {
		if (bIsAppend) {
			dwRetVal = Seek(FILE_END, 0, 0);
		}
		else {
			if (FALSE == ::SetEndOfFile(m_hFile)) {
				dwRetVal = ::GetLastError();
			}
		}
	}
	
	return dwRetVal;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Open
//*---------------------------------------------------------------
// DESC : ÆÄÀÏÀ» ¿­°í ÀÚ¿øÀ» ÇÒ´ç
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . dwDesiredAccess - Á¢±Ù¸ðµå
//			3 . dwShareMode - °øÀ¯¸ðµå
//			4 . dwCreationDisposition - »ý¼º°èȹ
//			5 . dwFlagsAndAttributes - Ç÷¡±×, ¼Ó¼º (´Ù¼öÁöÁ¤ °¡´É)
//			6 . lpSecurityAttributes - º¸¾È¼Ó¼º
//			7 . hTemplateFile - ÅÛÇø´ ÆÄÀÏ ÇÚµé
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::Open(
  LPCTSTR lpszFileName,	
  DWORD dwDesiredAccess, 
  DWORD dwShareMode, 
  DWORD dwCreationDisposition, 
  DWORD dwFlagsAndAttributes, 
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  HANDLE hTemplateFile
  )
{
	BASE_ASSERT(FALSE == IsOpen(),		"Invalid!");
	BASE_ASSERT(NULL != lpszFileName,	"Invalid!");
	if (NULL == lpszFileName) {
		return HASERROR;
	}

	m_hFile = ::CreateFile(lpszFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
	if (INVALID_HANDLE_VALUE == m_hFile) {
		return(::GetLastError());
	}

	TCHAR szFileFullPath[MAX_PATH] = { _T('\0') };
	STRNCPY(szFileFullPath, lpszFileName, _countof(szFileFullPath));
	LPTSTR lpszFilePart;
	DWORD dwRetVal = ::GetFullPathName(szFileFullPath, _countof(m_szFileFullPath), m_szFileFullPath, &lpszFilePart);
	if (0 == dwRetVal) {
		return(::GetLastError());
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Close
//*---------------------------------------------------------------
// DESC : ÆÄÀÏÇÚµéÀ» ´Ý°í °´Ã¼ÀÚ¿ø Á¤¸®
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CFileSet::Close()
{
	if (INVALID_HANDLE_VALUE != m_hFile) {
		::CloseHandle(m_hFile);
		Reset();
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Flush
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ ¾²±â¹öÆÛÀÇ µ¥ÀÌÅ͸¦ Áï½Ã ó¸®ÇÏ°í ºñ¿ò
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::Flush()
{
	BASE_ASSERT(TRUE == IsOpen(),	"Invalid!");
	if (FALSE == IsOpen()) {
		return FALSE;
	}

	return(::FlushFileBuffers(m_hFile));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::IsOpen
//*---------------------------------------------------------------
// DESC : ÆÄÀÏ°´Ã¼°¡ ÇöÀç ¿­·ÁÀÖ´ÂÁö ¿©ºÎ ¹Ýȯ
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::IsOpen() const
{
	return(INVALID_HANDLE_VALUE != m_hFile);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetFullPath
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ Àüü°æ·Î¸¦ ±¸ÇÔ
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetFullPath(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),					"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,					"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],	"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	return (_tcsncpy_s(lpszBuffer, nBufferSize, m_szFileFullPath, _TRUNCATE)?(TRUE):(FALSE));
#else	// #if	(_MSC_VER >= 1400)
	return (_tcsncpy(lpszBuffer, m_szFileFullPath, nBufferSize)?(TRUE):(FALSE));
#endif	// #if	(_MSC_VER >= 1400)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetDrive
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ µå¶óÀ̺긦 ±¸ÇÔ
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetDrive(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),						"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,						"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	return (!_tsplitpath_s(m_szFileFullPath, lpszBuffer, nBufferSize, NULL, 0, NULL, 0, NULL, 0)?(TRUE):(FALSE));
#else	// #if	(_MSC_VER >= 1400)
	return (!_tsplitpath(m_szFileFullPath, lpszBuffer, NULL, NULL, NULL)?(TRUE):(FALSE));
#endif	// #if	(_MSC_VER >= 1400)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetPath
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ °æ·Î¸¦ ±¸ÇÔ
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetPath(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),						"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,						"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	return (!_tsplitpath_s(m_szFileFullPath, NULL, 0, lpszBuffer, nBufferSize, NULL, 0, NULL, 0)?(TRUE):(FALSE));
#else	// #if	(_MSC_VER >= 1400)
	return (!_tsplitpath(m_szFileFullPath, NULL, lpszBuffer, NULL, NULL)?(TRUE):(FALSE));
#endif	// #if	(_MSC_VER >= 1400)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetName
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ À̸§À» ±¸ÇÔ (È®ÀåÀÚ Á¦¿Ü)
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetName(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),						"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,						"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	return (!_tsplitpath_s(m_szFileFullPath, NULL, 0, NULL, 0, lpszBuffer, nBufferSize, NULL, 0)?(TRUE):(FALSE));
#else	// #if	(_MSC_VER >= 1400)
	return (!_tsplitpath(m_szFileFullPath, NULL, NULL, lpszBuffer, NULL)?(TRUE):(FALSE));
#endif	// #if	(_MSC_VER >= 1400)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetExt
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ È®ÀåÀÚ¸¦ ±¸ÇÔ
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetExt(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),						"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,						"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	return (!_tsplitpath_s(m_szFileFullPath, NULL, 0, NULL, 0, NULL, 0, lpszBuffer, nBufferSize)?(TRUE):(FALSE));
#else	// #if	(_MSC_VER >= 1400)
	return (!_tsplitpath(m_szFileFullPath, NULL, NULL, NULL, lpszBuffer)?(TRUE):(FALSE));
#endif	// #if	(_MSC_VER >= 1400)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetTitle
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ À̸§ + È®ÀåÀÚ¸¦ ±¸ÇÔ
// PARM :	1 . lpszBuffer - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛ
//			2 . nBufferSize - ¹®ÀÚ¿­ Ãâ·Â¹öÆÛÀÇ Å©±â 
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetTitle(/*out*/ LPTSTR lpszBuffer, DWORD nBufferSize) const
{
	BASE_ASSERT(TRUE == IsOpen(),						"Invalid!");
	BASE_ASSERT(NULL != lpszBuffer,					"Invalid!");
	BASE_ASSERT(0 != nBufferSize,						"Invalid!");
	BASE_ASSERT(_T('\0') != m_szFileFullPath[0],		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpszBuffer ||
		0 == nBufferSize ||
		!_tcsncmp(m_szFileFullPath, _T(""), _countof(m_szFileFullPath))
		)
	{
		return FALSE;
	}

	TCHAR szFileName[MAX_PATH] = { _T('\0'), };
	TCHAR szExtName[MAX_PATH] = { _T('\0'), };
#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	INT iRetVal = _tsplitpath_s(m_szFileFullPath, NULL, 0, NULL, 0, szFileName, _countof(szFileName), szExtName, _countof(szExtName));
#else	// #if	(_MSC_VER >= 1400)
	INT iRetVal = _tsplitpath(m_szFileFullPath, NULL, NULL, szFileName, szExtName);
#endif	// #if	(_MSC_VER >= 1400)
	if (iRetVal) {
		return FALSE;
	}

#if	(_MSC_VER >= 1400)	// VS.NET 2005 ÀÌ»ó
	iRetVal = _stprintf_s(lpszBuffer, nBufferSize, _T("%s%s"), szFileName, szExtName);
#else	// #if	(_MSC_VER >= 1400)
	iRetVal = _sntprintf(lpszBuffer, nBufferSize, _T("%s%s"), szFileName, szExtName);
#endif	// #if	(_MSC_VER >= 1400)
	if (iRetVal < 0) {
		return FALSE;
	}

	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Seek
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ Æ¯Á¤ À§Ä¡¿¡ ÆÄÀÏÆ÷ÀÎÅ͸¦ À§Ä¡½ÃÅ´
// PARM :	1 . dwMoveMethod - ÆÄÀÏÆ÷ÀÎÅÍ À̵¿¹æ¹ý
/*
				FILE_BEGIN : ÆÄÀÏÀÇ Æ¯Á¤À§Ä¡¸¦ ÆÄÀÏÀÇ Ã³À½ºÎÅÍ Ã£À½
				FILE_CURRENT : ÆÄÀÏÀÇ Æ¯Á¤À§Ä¡¸¦ ÆÄÀÏÀÇ ÇöÀç À§Ä¡ºÎÅÍ Ã£À½
				FILE_END : ÆÄÀÏÀÇ Æ¯Á¤À§Ä¡¸¦ ÆÄÀÏÀÇ ³¡ºÎÅÍ Ã£À½
*/
//			2 . lOffsetLow - ÆÄÀÏÆ÷ÀÎÅ͸¦ À̵¿½Ãų »ó´ëÀ§Ä¡ (ÇÏÀ§ LONG)
//			3 . lOffsetHigh - ÆÄÀÏÆ÷ÀÎÅ͸¦ À̵¿½Ãų »ó´ëÀ§Ä¡ (»óÀ§ LONG)
//			4 . lpu64Offset - À̵¿µÈ ÆÄÀÏÆ÷ÀÎÅÍÀÇ À§Ä¡°ª
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::Seek(DWORD dwMoveMethod, LONG lOffsetLow, LONG lOffsetHigh, ULONGLONG* lpu64Offset)
{
	BASE_ASSERT(TRUE == IsOpen(),		"Invalid!");
	if (FALSE == IsOpen()) {
		return HASERROR;
	}

	LPLONG lpOffsetHigh = NULL;
	if (lOffsetHigh > 0) {
		lpOffsetHigh = &lOffsetHigh;
	}

	DWORD dwOffsetLow = ::SetFilePointer(m_hFile, lOffsetLow, lpOffsetHigh, dwMoveMethod);
	if (INVALID_SET_FILE_POINTER == dwOffsetLow) {
		DWORD dwErrNo = ::GetLastError();
		if (NO_ERROR != dwErrNo) {
			return dwErrNo;
		}
	}
	if (lpu64Offset) {
		if (lpOffsetHigh) {
			*lpu64Offset = MAKELONGLONG(dwOffsetLow, *lpOffsetHigh);
		}
		else {
			*lpu64Offset = MAKELONGLONG(dwOffsetLow, 0);
		}
	}
	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::SetLength
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ Å©±â¸¦ ƯÁ¤ ¼öÄ¡¸¸Å­ °­Á¦Á¶Á¤
// PARM :	1 . dwFileLength - Á¶Á¤ÇÒ ÆÄÀÏÀÇ Å©±â
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::SetLength(ULONGLONG dwFileLength)
{
	BASE_ASSERT(IsOpen(),				"Invalid!");

	DWORD dwRetVal = Seek(FILE_BEGIN, LOLONG(dwFileLength), HILONG(dwFileLength));
	if (NOERROR != dwRetVal) {
		return dwRetVal;
	}

	if (!::SetEndOfFile(m_hFile)) {
		dwRetVal = ::GetLastError();
		if (::GetLastError() != NO_ERROR) {
			return dwRetVal;
		}
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetLength
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ Å©±â¸¦ ¾ò¾î¿È
// PARM :	1 . dwFileLength - ¾òÀº ÆÄÀÏÀÇ Å©±â
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::GetLength(/*out*/ ULONGLONG& dwFileLength) const
{
	BASE_ASSERT(IsOpen(),				"Invalid!");

	ULARGE_INTEGER unFileSize;
	unFileSize.LowPart = ::GetFileSize(m_hFile, &unFileSize.HighPart);
	if (unFileSize.LowPart == INVALID_FILE_SIZE) {
		DWORD dwRetVal = ::GetLastError();
		if (NO_ERROR != dwRetVal) {
			return dwRetVal;
		}
	}

	dwFileLength = unFileSize.QuadPart;

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Read
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ ÇöÀç ÆÄÀÏÆ÷ÀÎÅͺÎÅÍ µ¥ÀÌÅ͸¦ ÀÐÀ½
// PARM :	1 . lpBuffer - µ¥ÀÌÅ͸¦ ÀÐÀ» ¹öÆÛÆ÷ÀÎÅÍ
//			2 . nBufferSize - ¹öÆÛÀÇ Å©±â
// RETV : NOERROR - ¼º°ø / ERROR_HANDLE_EOF - ÆÄÀÏÀбâÁ¾·á / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::Read(/*out*/ LPVOID lpBuffer, /*int,out*/ DWORD& nBufferSize)
{
	BASE_ASSERT(TRUE == IsOpen(),		"Invalid!");
	BASE_ASSERT(NULL != lpBuffer,		"Invalid!");
	BASE_ASSERT(0 != nBufferSize,		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpBuffer ||
		0 == nBufferSize
		)
	{
		return HASERROR;
	}
	
	DWORD dwRetVal = ::ReadFile(m_hFile, lpBuffer, nBufferSize, &nBufferSize, NULL);
	if (0 == dwRetVal) {
		return(::GetLastError());
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Write
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ ÇöÀç ÆÄÀÏÆ÷ÀÎÅͺÎÅÍ µ¥ÀÌÅ͸¦ ±â·Ï
// PARM :	1 . lpBuffer - ±â·ÏÇÒ µ¥ÀÌÅ͸¦ °¡Áø ¹öÆÛÆ÷ÀÎÅÍ
//			2 . nBufferSize - ¹öÆÛÀÇ Å©±â
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::Write(LPCVOID lpBuffer, /*int,out*/ DWORD& nBufferSize)
{
	BASE_ASSERT(TRUE == IsOpen(),		"Invalid!");
	BASE_ASSERT(NULL != lpBuffer,		"Invalid!");
	BASE_ASSERT(0 != nBufferSize,		"Invalid!");
	if (FALSE == IsOpen() ||
		NULL == lpBuffer ||
		0 == nBufferSize
		)
	{
		return HASERROR;
	}

	DWORD dwRetVal = ::WriteFile(m_hFile, lpBuffer, nBufferSize, &nBufferSize, NULL);
	if (0 == dwRetVal) {
		return(::GetLastError());
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::LockRange
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ Æ¯Á¤ À§Ä¡¸¦ ´Ù¸¥ ÇÁ·Î¼¼½ºµéÀÌ Á¢±ÙÇÏÁö ¸øÇϵµ·Ï ¹èŸÀû Àá±èÀ» ¼³Á¤
// PARM :	1 . uOffset - ÆÄÀÏÀÇ ½ÃÀÛÀ§Ä¡·Î ºÎÅÍÀÇ »ó´ëÀ§Ä¡
//			2 . uNumberOfBytes - Àá±èÀ» ¼öÇàÇÒ ¹ÙÀÌÆ® ¼ö
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::LockRange(ULONGLONG uOffset, ULONGLONG uNumberOfBytes)
{
	BASE_ASSERT(IsOpen(),				"Invalid!");
	BASE_ASSERT(0 != uNumberOfBytes,	"Invalid!");

	ULARGE_INTEGER unULargeInterger;
	ULARGE_INTEGER unCount;

	unULargeInterger.QuadPart = uOffset;
	unCount.QuadPart = uNumberOfBytes;
	if (!::LockFile(m_hFile, unULargeInterger.LowPart, unULargeInterger.HighPart, unCount.LowPart, unCount.HighPart)) {
		return (::GetLastError());
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::SkipBOM
//*---------------------------------------------------------------
// DESC : ¹®¼­ÆÄÀÏÀÇ ÀÎÄÚµùÇüŸ¦ ³ªÅ¸³»´Â BOM (Byte Order Mark) °¡ Á¸ÀçÇÏ¸é ³Ñ±è
// PARM : N/A
// RETV : BOM ŸÀÔ (EV_BT_NONE ÀÌ¸é ¼ÓÇØÀÖÁö ¾ÊÀ½)
// PRGM : B4nFter
// P.S.>
//		- ÇÊ¿¬ÀûÀ¸·Î ÆÄÀÏÆ÷ÀÎÅÍ´Â ¸Ç ¾ÕÀ¸·Î À̵¿µÇ°í ÀÌÈÄ¿¡ BOMÀÇ Å©±â¸¸Å­ À̵¿, ÃÖÁ¾ÀûÀ¸·Î ÆÄÀÏÆ÷ÀÎÅÍ´Â BOM µÚ¿¡ À§Ä¡
//		- BOMÀÌ ¾ø´Â °æ¿ì ÆÄÀÏÆ÷ÀÎÅÍ´Â ¸Ç ¾ÕÀ¸·Î À̵¿
//*---------------------------------------------------------------
CFileSet::EF_BOMTYPE CFileSet::SkipBOM()
{
	BASE_ASSERT(IsOpen(),				"Invalid!");

	if (!IsOpen()) {
		return EV_BT_NONE;
	}

	BYTE btData[UCHAR_MAX];
	DWORD dwSize, dwRetVal;
	for (DWORD dwIndex = 0 ; dwIndex < EV_BT_NONE ; ++dwIndex) {
		dwRetVal = Seek(FILE_BEGIN, 0, 0);
		if (NOERROR != dwRetVal) {
			BASE_CONTINUE;
		}
		dwSize = m_stBomTypeDat[dwIndex].m_nSize;
		dwRetVal = Read(btData, dwSize);
		if (NOERROR != dwRetVal) {
			BASE_CONTINUE;
		}
		if (dwSize != m_stBomTypeDat[dwIndex].m_nSize) {
			continue;
		}
		if (!::memcmp(btData, m_stBomTypeDat[dwIndex].m_btData, m_stBomTypeDat[dwIndex].m_nSize)) {
			return m_stBomTypeDat[dwIndex].m_eType;
		}
	}

	return EV_BT_NONE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::WriteBOM
//*---------------------------------------------------------------
// DESC : ÆÄÀÏÀÇ ¸Ç ¾Õ¿¡ ƯÁ¤ BOM (Byte Order Mark) À» ³²±è
// PARM :	1 . eBomType - ¾²±â¸¦ ¿øÇÏ´Â BOM ŸÀÔ
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::WriteBOM(CFileSet::EF_BOMTYPE eBomType)
{
	BASE_ASSERT(IsOpen(),								"Invalid!");
	BASE_ASSERT(CHECK_LIMIT(eBomType, EV_BT_NONE),	"Invalid!");

	if (!IsOpen() ||
		!CHECK_LIMIT(eBomType, EV_BT_NONE)
		)
	{
		return HASERROR;
	}

	DWORD dwRetVal = Seek(FILE_BEGIN, 0, 0);
	if (NOERROR != dwRetVal) {
		BASE_RETURN(dwRetVal);
	}

	DWORD dwSize = m_stBomTypeDat[eBomType].m_nSize;
	dwRetVal = Write(m_stBomTypeDat[eBomType].m_btData, dwSize);
	if (NOERROR != dwRetVal) {
		BASE_RETURN(dwRetVal);
	}
	if (dwSize != m_stBomTypeDat[eBomType].m_nSize) {
		BASE_RETURN(HASERROR);
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::UnlockRange
//*---------------------------------------------------------------
// DESC : ÀÌÀü¿¡ Lock µÇ¾ú´ø ÆÄÀÏÀÇ Æ¯Á¤ À§Ä¡ÀÇ ¹èŸÀû Àá±èÀ» ÇØÁ¦
// PARM :	1 . uOffset - ÆÄÀÏÀÇ ½ÃÀÛÀ§Ä¡·Î ºÎÅÍÀÇ »ó´ëÀ§Ä¡
//			2 . uNumberOfBytes - Àá±èÇØÁ¦¸¦ ¼öÇàÇÒ ¹ÙÀÌÆ® ¼ö
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::UnlockRange(ULONGLONG uOffset, ULONGLONG uNumberOfBytes)
{
	BASE_ASSERT(IsOpen(),				"Invalid!");
	BASE_ASSERT(0 != uNumberOfBytes,	"Invalid!");

	ULARGE_INTEGER unULargeInterger;
	ULARGE_INTEGER unCount;

	unULargeInterger.QuadPart = uOffset;
	unCount.QuadPart = uNumberOfBytes;
	if (!::UnlockFile(m_hFile, unULargeInterger.LowPart, unULargeInterger.HighPart, unCount.LowPart, unCount.HighPart)) {
		return (::GetLastError());
	}

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetPosition
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ ÆÄÀÏÆ÷ÀÎÅÍ À§Ä¡¸¦ ¾ò¾î¿È
// PARM :	1 . u64FilePositon - ÆÄÀÏÆ÷ÀÎÅÍ À§Ä¡¸¦ ¾ò¾î¿Ã º¯¼ö
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::GetPosition(/*out*/ ULONGLONG& u64FilePositon) const
{
	BASE_ASSERT(IsOpen(),				"Invalid!");

	LARGE_INTEGER unLargeInteger;
	unLargeInteger.QuadPart = 0;
	unLargeInteger.LowPart = ::SetFilePointer(m_hFile, unLargeInteger.LowPart, &unLargeInteger.HighPart , FILE_CURRENT);
	if (unLargeInteger.LowPart == (DWORD)-1) {
		DWORD dwErrNo = ::GetLastError();
		if (NO_ERROR != dwErrNo) {
			return dwErrNo;
		}
	}

	u64FilePositon = unLargeInteger.QuadPart;

	return NOERROR;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetTime
//*---------------------------------------------------------------
// DESC : ÇöÀç Á¢±ÙÁßÀÎ ÆÄÀÏÀÇ ÆÄÀϽð£À» ¾ò¾î¿È
// PARM :	1 . lpstCreateFileTime - »ý¼º½Ã°£
//			2 . lpstAccessFileTime - ¸¶Áö¸· Á¢±Ù½Ã°£
//			3 . lpstWriteFileTime - ¸¶Áö¸· ±â·Ï½Ã°£
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::GetTime(/*out*/ LPFILETIME lpstCreateFileTime, /*out*/ LPFILETIME lpstAccessFileTime, /*out*/ LPFILETIME lpstWriteFileTime) const
{
	BASE_ASSERT(NULL != lpstCreateFileTime,		"Invalid!");
	BASE_ASSERT(NULL != lpstAccessFileTime,		"Invalid!");
	BASE_ASSERT(NULL != lpstWriteFileTime,		"Invalid!");

	DWORD dwRetVal = 0;
	if (INVALID_HANDLE_VALUE != m_hFile)
	{
		if (!::GetFileTime(m_hFile, lpstCreateFileTime, lpstAccessFileTime, lpstWriteFileTime))
		{
			dwRetVal = ::GetLastError();
			BASE_ASSERT(0, "Error!");
		}
//		DN_VERIFY(::CloseHandle(m_hFile), TRUE,	"error!");
	}
	else
	{
		BASE_RETURN(HASERROR);
	}

	return(dwRetVal);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetTime
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀÇ ÆÄÀϽð£À» ¾ò¾î¿È (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . lpstCreateFileTime - »ý¼º½Ã°£
//			3 . lpstAccessFileTime - ¸¶Áö¸· Á¢±Ù½Ã°£
//			4 . lpstWriteFileTime - ¸¶Áö¸· ±â·Ï½Ã°£
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::GetTime(LPCTSTR lpszFileName, /*out*/ LPFILETIME lpstCreateFileTime, /*out*/ LPFILETIME lpstAccessFileTime, /*out*/ LPFILETIME lpstWriteFileTime)
{
	BASE_ASSERT(NULL != lpstCreateFileTime,		"Invalid!");
	BASE_ASSERT(NULL != lpstCreateFileTime,		"Invalid!");
	BASE_ASSERT(NULL != lpstAccessFileTime,		"Invalid!");
	BASE_ASSERT(NULL != lpstWriteFileTime,		"Invalid!");

	DWORD dwRetVal = 0;
	HANDLE hFile = ::CreateFile(lpszFileName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (INVALID_HANDLE_VALUE != hFile)
	{
		if (!::GetFileTime(hFile, lpstCreateFileTime, lpstAccessFileTime, lpstWriteFileTime))
		{
			dwRetVal = ::GetLastError();
			BASE_ASSERT(0, "Error!");
		}
		BASE_VERIFY(::CloseHandle(hFile), TRUE,	"Error!");
	}
	else
	{
		BASE_RETURN(HASERROR);
	}

	return(dwRetVal);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetVersion
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀÇ ¹öÀüÁ¤º¸¸¦ ¾ò¾î¿È (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . dwFileVersion1 - ¹öÀüÁ¤º¸ 1
//			3 . dwFileVersion2 - ¹öÀüÁ¤º¸ 2
//			4 . dwFileVersion3 - ¹öÀüÁ¤º¸ 3
//			5 . dwFileVersion4 - ¹öÀüÁ¤º¸ 4
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ (ÆÄÀÏ ¹ÙÀ̳ʸ®¿¡ ¹öÀü ¸®¼Ò½º°¡ ¾øÀ¸¸é ERROR_RESOURCE_TYPE_NOT_FOUND (1813L) ¹Ýȯ)
// PRGM : B4nFter
// P.S.>
//		- ÆÄÀÏ ¹ÙÀ̳ʸ®¿¡ ¹öÀü ¸®¼Ò½º°¡ ÀÌ¹Ì Á¸ÀçÇØ¾ß ÇÔ
//*---------------------------------------------------------------
DWORD CFileSet::GetVersion(LPCTSTR lpszFileName, DWORD& dwFileVersion1, DWORD& dwFileVersion2, DWORD& dwFileVersion3, DWORD& dwFileVersion4)
{
	DWORD dwHandle= 0;
	DWORD dwFileVersionInfoSize = ::GetFileVersionInfoSize(lpszFileName, &dwHandle);
	if (0 == dwFileVersionInfoSize)
	{
		return (::GetLastError());	// Version Resource°¡ ¾øÀ¸¸é ERROR_RESOURCE_TYPE_NOT_FOUND (1813L)
	}

	std::auto_ptr<BYTE>	aVerBuf(NEW BYTE[dwFileVersionInfoSize]);
	if (NULL == aVerBuf.get())
	{
		return ERROR_NOT_ENOUGH_MEMORY;
	}

	DWORD	dwRetVal = 0;
	if (TRUE == ::GetFileVersionInfo(lpszFileName, dwHandle, dwFileVersionInfoSize, aVerBuf.get()))
	{
		UINT uLength    = 0;
		VS_FIXEDFILEINFO* lpVsFixedFileInfo = NULL;
		if (TRUE == ::VerQueryValue(aVerBuf.get(), _T("\\"), (LPVOID*)&lpVsFixedFileInfo, &uLength))
		{
			BASE_ASSERT(sizeof(VS_FIXEDFILEINFO) == uLength,	"Error!");
			dwFileVersion1	= HIWORD(lpVsFixedFileInfo->dwFileVersionMS);
			dwFileVersion2	= LOWORD(lpVsFixedFileInfo->dwFileVersionMS);
			dwFileVersion3	= HIWORD(lpVsFixedFileInfo->dwFileVersionLS);
			dwFileVersion4	= LOWORD(lpVsFixedFileInfo->dwFileVersionLS);
		}
		else
		{
			dwRetVal = ERROR_NOT_FOUND;	// 1168L
		}
	}
	else
	{
		dwRetVal = ::GetLastError();
	}

	return dwRetVal;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetAttributes
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀÇ ¼Ó¼ºÁ¤º¸¸¦ °¡Á®¿È (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
// RETV : ÆÄÀÏÀÇ ¼Ó¼º : ¼º°ø / INVALID_FILE_ATTRIBUTES : ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CFileSet::GetAttributes(LPCTSTR lpszFileName)
{
	BASE_ASSERT(NULL != lpszFileName,		"Invalid!");
	return (::GetFileAttributes(lpszFileName));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::SetAttributes
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀÇ ¼Ó¼ºÀ» ÁöÁ¤ (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . dwFileAttributes - ÆÄÀÏ ¼Ó¼º
/*
				FILE_ATTRIBUTE_READONLY             0x00000001
				FILE_ATTRIBUTE_HIDDEN               0x00000002
				FILE_ATTRIBUTE_SYSTEM               0x00000004
				FILE_ATTRIBUTE_DIRECTORY            0x00000010
				FILE_ATTRIBUTE_ARCHIVE              0x00000020
				FILE_ATTRIBUTE_DEVICE               0x00000040
				FILE_ATTRIBUTE_NORMAL               0x00000080
				FILE_ATTRIBUTE_TEMPORARY            0x00000100
				FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
				FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
				FILE_ATTRIBUTE_COMPRESSED           0x00000800
				FILE_ATTRIBUTE_OFFLINE              0x00001000
				FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  0x00002000
				FILE_ATTRIBUTE_ENCRYPTED            0x00004000
*/
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::SetAttributes(LPCTSTR lpszFileName, DWORD dwFileAttributes)
{
	BASE_ASSERT(NULL != lpszFileName,			"Invalid!");
	return (::SetFileAttributes(lpszFileName, dwFileAttributes));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Remove
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀ» Á¦°Å (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszSrcFileName - ¿øº» ÆÄÀÏ
//			2 . lpszTgtFileName - ¸ñÀû ÆÄÀÏ
//			3 . pIsFailIfExist - ±âÁ¸¿¡ ÆÄÀÏÀÌ ÀÖÀ¸¸é ½ÇÆзΠó¸®ÇÒÁö ¿©ºÎ (TRUE:½ÇÆÐ / FALSE:¼º°ø(µ¤¾î¾¸))
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::Copy(LPCTSTR lpszSrcFileName, LPCTSTR lpszTgtFileName, BOOL pIsFailIfExist)
{
	BASE_ASSERT(NULL != lpszSrcFileName,	"Invalid!");
	BASE_ASSERT(NULL != lpszTgtFileName,	"Invalid!");

	return (::CopyFile(lpszSrcFileName, lpszTgtFileName, pIsFailIfExist));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Remove
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀ» Á¦°Å (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszFileName - ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::Remove(LPCTSTR lpszFileName)
{
	BASE_ASSERT(NULL != lpszFileName,			"Invalid!");

	return (::DeleteFile(lpszFileName));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::Rename
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·ÎÀÇ ÆÄÀÏÀÇ À̸§°ú °æ·Î¸¦ º¯°æ (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpszOldFileName - ÀÌÀü ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
//			2 . lpszNewFileName - ½Å±Ô ÆÄÀÏÀÇ À̸§À» Æ÷ÇÔÇÑ Àý´ë/»ó´ë °æ·Î
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::Rename(LPCTSTR lpszOldFileName, LPCTSTR lpszNewFileName)
{
	BASE_ASSERT(NULL != lpszOldFileName,		"Invalid!");
	BASE_ASSERT(NULL != lpszNewFileName,		"Invalid!");
	
	return (::MoveFile(lpszOldFileName, lpszNewFileName));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetTempName
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·Î¿Í Á¢µÎ»ç, ¼ýÀÚ¸¦ ±âÁØÀ¸·Î ÀÓ½ÃÆÄÀÏ À̸§À» »ý¼º (Á¤Àû ¸Þ¼­µå)
// PARM :	1 . lpPathName - ±âÁØ °æ·Î
//			2 . lpPrefixString - ±âÁØ ÆÄÀÏ Á¢µÎ»ç
//			3 . uUnique - ±âÁØ ¼ýÀÚ
//			4 . lpTempFileName - Àӽà ÆÄÀÏÀ̸§À» ¾ò¾î¿Ã ¹öÆÛ
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CFileSet::GetTempName(LPCTSTR lpPathName, LPCTSTR lpPrefixString, UINT uUnique, /*out*/ LPTSTR lpTempFileName)
{
	BASE_ASSERT(NULL != lpPathName,				"Invalid!");
	BASE_ASSERT(NULL != lpPrefixString,			"Invalid!");
	BASE_ASSERT(NULL != lpTempFileName,			"Invalid!");
	if (NULL == lpPathName) { return FALSE; }
	if (NULL == lpPrefixString) { return FALSE; }
	if (NULL == lpTempFileName) { return FALSE; }

	UINT uRetVal = ::GetTempFileName(lpPathName, lpPrefixString, uUnique, lpTempFileName);
	if (0 == uRetVal) {
		return FALSE;
	}

	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CFileSet::GetBomTypeDat
//*---------------------------------------------------------------
// DESC : ƯÁ¤ BOM ŸÀÔ¿¡ ´ëÇÑ Á¤º¸¸¦ ¾òÀ½
// PARM :	1 . pBomType - ƯÁ¤ BOM ŸÀÔ¿¡ ´ëÇÑ EF_BOMTYPE ¿­°ÅÇü °ª
// RETV : ƯÁ¤ BOM ŸÀÔ¿¡ ´ëÇÑ Á¤º¸ Æ÷ÀÎÅÍ
// PRGM : B4nFter
//*---------------------------------------------------------------
CFileSet::LPFILEBOMTYPEDAT CFileSet::GetBomTypeDat(EF_BOMTYPE pBomType)
{
	if (!CHECK_LIMIT(pBomType, EV_BT_NONE)) {
		BASE_RETURN(NULL);
	}

	return &m_stBomTypeDat[pBomType];
}