简单之文件存储管理

        别尝试在单个机械硬盘上做并行设计~

XXXXXXXX.h

//######################
//> /*数据结构*/
//######################*********************************************************************************************************/

#pragma pack(1)

//> 最大缓冲区大小
#define MAX_BUFFER_SIZE (500U)

//> 文件存储结构
typedef struct _FILE_AREA_INFO {
	DWORD dwGroupIndex;  //组索引
	DWORD dwItemIndex;   //成员索引
	USHORT uActualSize;     //实际写入缓冲区大小
	UCHAR uBuffer[MAX_BUFFER_SIZE]; //数据缓冲区
	USHORT uIsDelete;    //标记是否被删除
} FILE_AREA_INFO, *PFILE_AREA_INFO;


//> 最大缓存总数
#define MAX_CACHE_COUNT (8192U)

//> 文件缓存信息
typedef struct _FILE_CACHE_INFO {
	USHORT uCurOperationL;          //当前在操作左轮
	PFILE_AREA_INFO lpTurnsCacheL;  //左轮缓存区指针
	USHORT uCurOperationR;          //当前在操作右轮
	PFILE_AREA_INFO lpTurnsCacheR;  //右轮缓存区指针
	DWORD dwFileToCacheCount;             //缓存总数
	PFILE_AREA_INFO lpTurnsFileToCache;   //写入文件的临时缓存区
	DWORD dwCacheToFileCount;             //写入总数
	PFILE_AREA_INFO lpTurnsCacheToFile;   //将要写入文件的缓存区
} FILE_CACHE_INFO, *PFILE_CACHE_INFO;

//> 多少成员总数为一个组
#define MAX_ITEM_COUNT (4096U)

//> 文件基本信息
typedef struct _FILE_INFO {
	/**文件信息**/
	HANDLE hSpecFile;     //文件快句柄
	DWORD dwGroupCount;   //组总数
	DWORD dwGroupIndex;   //组索引
	DWORD dwItemCount;    //成员总数
	DWORD dwItemIndex;    //成员索引
	/**缓存信息**/
	LPVOID lpFindBuffer;  //查找缓冲区
	FILE_CACHE_INFO lpCacheInfo;  //缓存信息
} FILE_INFO, *PFILE_INFO;

//> 文件头信息
typedef struct _FILE_HEADER_INFO {
	DWORD dwGroupCount;   //组总数
	DWORD dwGroupIndex;   //组索引
	DWORD dwItemCount;    //成员总数
	DWORD dwItemIndex;    //成员索引
} FILE_HEADER_INFO, *PFILE_HEADER_INFO;

#pragma pack()

/*************************************************************************************************************************/



//######################
//> /*全局变量*/
//######################*********************************************************************************************************/

//> 文件总数
#define MAX_FILE_COUNT (1U)

//> 全局文件信息
extern PFILE_INFO G_FileInfo;

/*************************************************************************************************************************/


//######################
//> /*操作函数*/
//######################*********************************************************************************************************/

//> 分配指定数量的文件信息空间
BOOLEAN __fastcall AllocFileInfo(DWORD dwFileCount);
//> 释放指定数量的文件信息空间
VOID __fastcall FreeFileInfo(VOID);

//> 分配查找缓冲区空间
BOOLEAN __fastcall AllocBufferInfo(DWORD dwIndex, DWORD dwBufferSize);
//> 释放查找缓冲区空间
VOID __fastcall FreeBufferInfo(DWORD dwIndex);

//> 分配指定文件缓存信息空间
BOOLEAN __fastcall AllocCacheInfo(DWORD dwIndex, DWORD dwCacheCount);
//> 释放指定文件缓存信息空间
VOID __fastcall FreeCacheInfo(DWORD dwIndex);

//> 设置左轮缓存区为默认缓存区
VOID __fastcall SetFileToCacheL(DWORD dwIndex);
//> 设置右轮缓存区为默认缓存区
VOID __fastcall SetFileToCacheR(DWORD dwIndex);

//> 刷新缓存区并写入文件
BOOLEAN __fastcall FlushFileCache(DWORD dwIndex);

//> 返回可读写的新数据索引
VOID __fastcall GetContentsIndex(DWORD dwIndex, DWORD * lpGroupIndex, DWORD * lpItemIndex);
//> 查找需要读写的数据索引
BOOLEAN __stdcall FindContentsIndex(DWORD dwIndex, LPCVOID lpBuffer, USHORT uBufSize, DWORD * lpGroupIndex, DWORD * lpItemIndex);

//> 是否是被删除的数据
BOOLEAN __stdcall IsDeleteContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex);
//> 删除指定的数据
BOOLEAN __stdcall DeleteContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex);
//> 恢复指定的数据
BOOLEAN __stdcall RecoveryContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex);

//> 绑定指定的文件索引
BOOLEAN __stdcall BindFileToIndex(DWORD dwIndex, CONST WCHAR wzFilePath[], USHORT uPathSize);
//> 写入指定的文件内容
BOOLEAN __stdcall WriteFileIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPCVOID lpBuffer, USHORT * lpBufSize);
//> 读入指定的文件内容
BOOLEAN __stdcall ReadFileIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPVOID lpBuffer, USHORT * lpBufSize);
//> 关闭指定的文件
BOOLEAN __fastcall CloseFileIndex(DWORD dwIndex);

/*************************************************************************************************************************/

XXXXXXXX.cpp

#include "stdafx.h"
#include "StorageFrameBase.h"

PFILE_INFO G_FileInfo = NULL;

/******************************************
功能：分配指定数量的文件信息空间
参数：dwFileCount 文件总数
返回：TRUE则成功
******************************************/
BOOLEAN __fastcall AllocFileInfo(DWORD dwFileCount)
{
	G_FileInfo = (PFILE_INFO)
		::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, (dwFileCount * sizeof(FILE_INFO)));

	if (NULL == G_FileInfo)
	{
		return FALSE;
	}
	return TRUE;
}

/******************************************
功能：释放指定数量的文件信息空间
参数：无
返回：无
******************************************/
VOID __fastcall FreeFileInfo(VOID)
{
	if (NULL != G_FileInfo)
	{
		if (TRUE == ::HeapFree(::GetProcessHeap(), HEAP_NO_SERIALIZE, G_FileInfo))
		{
			G_FileInfo = NULL;
		}
	}
}

/******************************************
功能：分配查找缓冲区空间
参数：dwIndex 文件索引
参数：dwBufferSize 文件总数
返回：TRUE则成功
******************************************/
BOOLEAN __fastcall AllocBufferInfo(DWORD dwIndex, DWORD dwBufferSize)
{
	G_FileInfo[dwIndex].lpFindBuffer = (LPVOID)
		::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, (dwBufferSize * sizeof(FILE_AREA_INFO)));

	if (NULL == G_FileInfo[dwIndex].lpFindBuffer)
	{
		return FALSE;
	}
	return TRUE;
}

/******************************************
功能：释放查找缓冲区空间
参数：dwIndex 文件索引
返回：无
******************************************/
VOID __fastcall FreeBufferInfo(DWORD dwIndex)
{
	if (NULL != G_FileInfo[dwIndex].lpFindBuffer)
	{
		if (TRUE == ::HeapFree(::GetProcessHeap(), HEAP_NO_SERIALIZE, G_FileInfo[dwIndex].lpFindBuffer))
		{
			G_FileInfo[dwIndex].lpFindBuffer = NULL;
		}
	}
}

/******************************************
功能：分配指定文件缓存信息空间
参数：dwIndex 文件索引
参数：dwCacheCount 缓存总数
返回：TRUE则成功
******************************************/
BOOLEAN __fastcall AllocCacheInfo(DWORD dwIndex, DWORD dwCacheCount)
{
	PFILE_AREA_INFO lpFileAreaInfo;

	lpFileAreaInfo = (PFILE_AREA_INFO)
		::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, (dwCacheCount * sizeof(FILE_AREA_INFO)));

	if (NULL == lpFileAreaInfo)
	{
		return FALSE;
	}

	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL = &lpFileAreaInfo[0];
	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheR = &lpFileAreaInfo[(dwCacheCount / 2U)];
	return TRUE;
}

/******************************************
功能：//> 设置左轮缓存区为默认缓存区
参数：dwIndex 文件索引
返回：无
******************************************/
VOID __fastcall SetFileToCacheL(DWORD dwIndex)
{
	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL;
	G_FileInfo[dwIndex].lpCacheInfo.uCurOperationL = TRUE;
}

/******************************************
功能：//> 设置右轮缓存区为默认缓存区
参数：dwIndex 文件索引
返回：无
******************************************/
VOID __fastcall SetFileToCacheR(DWORD dwIndex)
{
	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheR;
	G_FileInfo[dwIndex].lpCacheInfo.uCurOperationR = TRUE;
}

/******************************************
功能：释放指定文件缓存信息空间
参数：dwIndex 文件索引
返回：无
******************************************/
VOID __fastcall FreeCacheInfo(DWORD dwIndex)
{
	if (G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL != NULL)
	{
		if (TRUE == ::HeapFree(::GetProcessHeap(), HEAP_NO_SERIALIZE, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL))
		{
			memset(&G_FileInfo[dwIndex].lpCacheInfo, 0U, sizeof(FILE_CACHE_INFO));
		}
	}
}

/******************************************
功能：读取文件头索引信息
参数：dwIndex 文件信息索引
返回：TRUE则成功
******************************************/
static BOOLEAN __fastcall ReadFileHeader(DWORD dwIndex)
{
	DWORD dwActualSize;
	FILE_HEADER_INFO FileHeadInfo;

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 0U, NULL, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::ReadFile(G_FileInfo[dwIndex].hSpecFile, &FileHeadInfo, sizeof(FILE_HEADER_INFO), &dwActualSize, NULL))
	{
		return FALSE;
	}

	if (0U != dwActualSize)
	{
		G_FileInfo[dwIndex].dwGroupCount = FileHeadInfo.dwGroupCount;
		G_FileInfo[dwIndex].dwGroupIndex = FileHeadInfo.dwGroupIndex;
		G_FileInfo[dwIndex].dwItemCount = FileHeadInfo.dwItemCount;
		G_FileInfo[dwIndex].dwItemIndex = FileHeadInfo.dwItemIndex;
	}
	return TRUE;
}

/******************************************
功能：绑定指定的文件索引
参数：dwIndex 文件信息索引
参数：wzFilePath 文件的路径名
参数：uPathSize 缓冲区大小
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall BindFileToIndex(DWORD dwIndex, CONST WCHAR wzFilePath[], USHORT uPathSize)
{
	if (TRUE == ::IsBadReadPtr(wzFilePath, uPathSize))
	{
		return FALSE;
	}

	G_FileInfo[dwIndex].hSpecFile = ::CreateFileW(wzFilePath, 
		GENERIC_READ | GENERIC_WRITE, 0U, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);

	if (INVALID_HANDLE_VALUE == G_FileInfo[dwIndex].hSpecFile)
	{
		G_FileInfo[dwIndex].hSpecFile = ::CreateFileW(wzFilePath,
			GENERIC_READ | GENERIC_WRITE, 0U, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
	}

	if (INVALID_HANDLE_VALUE == G_FileInfo[dwIndex].hSpecFile)
	{
		return FALSE;
	}
	return (ReadFileHeader(dwIndex));
}

/******************************************
功能：设置将要写入文件的缓存区
参数：dwIndex 文件索引
参数：lpFileAreaInfo 指定缓存区指针
参数：dwCacheToFileCount 缓存总数
返回：无
******************************************/
static VOID __fastcall SetCacheToFileInfo(DWORD dwIndex, PFILE_AREA_INFO lpTurnsCacheToFile, DWORD dwCacheToFileCount)
{
	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheToFile = lpTurnsCacheToFile;
	G_FileInfo[dwIndex].lpCacheInfo.dwCacheToFileCount = dwCacheToFileCount;
}

/******************************************
功能：将缓存数据写入硬盘文件
参数：dwIndex 文件索引
返回：TRUE则成功
******************************************/
static BOOLEAN __fastcall CacheCopyFile(DWORD dwIndex)
{
	LARGE_INTEGER FilePoint;

	for (register UINT uCacheIndex = 0U; uCacheIndex < 
		G_FileInfo[dwIndex].lpCacheInfo.dwCacheToFileCount; ++uCacheIndex)
	{
		FilePoint.QuadPart = MAX_ITEM_COUNT * 
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheToFile[uCacheIndex].dwGroupIndex;
		FilePoint.QuadPart = FilePoint.QuadPart + 
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheToFile[uCacheIndex].dwItemIndex;

		FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
		FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

		if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 
			FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
		{
			return FALSE;
		}

		if (FALSE == ::WriteFile(G_FileInfo[dwIndex].hSpecFile, 
			&G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheToFile[uCacheIndex], 
			sizeof(FILE_AREA_INFO), &FilePoint.LowPart, NULL))
		{
			return FALSE;
		}
	}
	G_FileInfo[dwIndex].lpCacheInfo.dwCacheToFileCount = 0U;
	return TRUE;
}

/******************************************
功能：设置将要临时存储的缓存区
参数：dwIndex 文件索引
参数：lpFileAreaInfo 指定缓存区指针
参数：dwCacheToFileCount 缓存总数
返回：无
******************************************/
static VOID __fastcall SetFileToCacheInfo(DWORD dwIndex, PFILE_AREA_INFO lpTurnsFileToCache, DWORD dwFileToCacheCount)
{
	G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache = lpTurnsFileToCache;
	G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount = dwFileToCacheCount;
}

/******************************************
功能：写入缓存区
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
参数：lpBuffer 需要写入的数据
参数：uBufSize 数据大小
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall FileCopyCache(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPCVOID lpBuffer, USHORT uBufSize)
{
	if (0U != G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize)
	{
		if (dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex)
		{
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize = uBufSize;
			memcpy(G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uBuffer, lpBuffer, uBufSize);
		}
		else
		{
			CONST DWORD dwCurIndex = G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount;

			G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount++;

			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwCurIndex].dwGroupIndex = dwGroupIndex;
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwCurIndex].dwItemIndex = dwItemIndex;
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwCurIndex].uActualSize = uBufSize;

			memcpy(G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwCurIndex].uBuffer, lpBuffer, uBufSize);
		}
	}
	if (0U == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize)
	{
		G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount++;

		G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex = dwGroupIndex;
		G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwItemIndex = dwItemIndex;
		G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize = uBufSize;

		memcpy(G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uBuffer, lpBuffer, uBufSize);
	}
	return TRUE;
}

/******************************************
功能：交替轮流作用缓存区
参数：dwIndex 文件索引
返回：TRUE则数据发生交换
******************************************/
static BOOLEAN __fastcall SwitchTurnsCache(DWORD dwIndex)
{
	CONST DWORD dwFileToCacheCount = G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount;

	if ((MAX_CACHE_COUNT / 2U) == dwFileToCacheCount)
	{
		if (TRUE == G_FileInfo[dwIndex].lpCacheInfo.uCurOperationL)
		{
			SetFileToCacheInfo(dwIndex, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheR,0U);
			SetCacheToFileInfo(dwIndex, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL, dwFileToCacheCount);
			G_FileInfo[dwIndex].lpCacheInfo.uCurOperationL = FALSE;
			G_FileInfo[dwIndex].lpCacheInfo.uCurOperationR = TRUE;
			return TRUE;
		}

		if (TRUE == G_FileInfo[dwIndex].lpCacheInfo.uCurOperationR)
		{
			SetFileToCacheInfo(dwIndex, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheL, 0U);
			SetCacheToFileInfo(dwIndex, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsCacheR, dwFileToCacheCount);
			G_FileInfo[dwIndex].lpCacheInfo.uCurOperationR = FALSE;
			G_FileInfo[dwIndex].lpCacheInfo.uCurOperationL = TRUE;
			return TRUE;
		}
	}
	return FALSE;
}

/******************************************
功能：写入指定的文件内容
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
参数：lpBuffer 需要写入的数据
参数：lpBufSize 写入实际大小
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall WriteFileIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPCVOID lpBuffer, USHORT * lpBufSize)
{
	BOOLEAN bWriteCache;
	BOOLEAN bSwitchCache;

	if (0U == *lpBufSize || TRUE == ::IsBadReadPtr(lpBuffer, *lpBufSize) || dwItemIndex >= MAX_ITEM_COUNT)
	{
		return FALSE;
	}

	if (*lpBufSize > MAX_BUFFER_SIZE)
	{
		*lpBufSize = MAX_BUFFER_SIZE;
	}

	bSwitchCache = SwitchTurnsCache(dwIndex);
	bWriteCache = FileCopyCache(dwIndex, dwGroupIndex, dwItemIndex, lpBuffer, *lpBufSize);

	if (TRUE == bSwitchCache)
	{
		return (CacheCopyFile(dwIndex));
	}
	return (bWriteCache);
}

/******************************************
功能：在缓存区读取数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
参数：lpBuffer 需要读入的缓冲区
参数：lpBufSize 读入实际大小
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall ReadCacheToBuffer(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPVOID lpBuffer, USHORT * lpBufSize)
{
 if (0U != G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize &&
  dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex)
 {
  *lpBufSize = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize;
  memcpy(lpBuffer, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uBuffer, *lpBufSize);
  return TRUE;
 }

 for (register UINT uFindIndex = dwItemIndex + 1U; uFindIndex < G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount; ++uFindIndex)
 {
  if (dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].dwGroupIndex &&
   dwItemIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].dwItemIndex)
  {
   *lpBufSize = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].uActualSize;
   memcpy(lpBuffer, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].uBuffer, *lpBufSize);
   return TRUE;
  }
 }
 return FALSE;
}

/******************************************
功能：从硬盘文件中读取内容
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
参数：lpBuffer 需要读入的缓冲区
参数：lpBufSize 读入实际大小
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall ReadHardDriveFile(HANDLE hFile, DWORD dwGroupIndex, DWORD dwItemIndex, LPVOID lpBuffer, USHORT * lpBufSize)
{
	LARGE_INTEGER FilePoint;
	FILE_AREA_INFO FileAreaInfo;

	FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
	FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
	FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
	FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(hFile, FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::ReadFile(hFile, &FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL) || 
		0U == FileAreaInfo.uActualSize)
	{
		return FALSE;
	}

	if (0U != FilePoint.LowPart && *lpBufSize != FileAreaInfo.uActualSize)
	{
		*lpBufSize = FileAreaInfo.uActualSize;
	}

	memcpy(lpBuffer, FileAreaInfo.uBuffer, *lpBufSize);
	return TRUE;
}

/******************************************
功能：读入指定的文件内容
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
参数：lpBuffer 需要读入的缓冲区
参数：lpBufSize 读入实际大小
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall ReadFileIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex, LPVOID lpBuffer, USHORT * lpBufSize)
{
	if (0U == *lpBufSize || TRUE == ::IsBadWritePtr(lpBuffer, *lpBufSize) || dwItemIndex >= MAX_ITEM_COUNT)
	{
		return FALSE;
	}

	if (FALSE == ReadCacheToBuffer(dwIndex, dwGroupIndex, dwItemIndex, lpBuffer, lpBufSize))
	{
		return ReadHardDriveFile(G_FileInfo[dwIndex].hSpecFile, dwGroupIndex, dwItemIndex, lpBuffer, lpBufSize);
	}
	return TRUE;
}

/******************************************
功能：将索引信息写入文件
参数：dwIndex 文件索引
返回：TRUE则成功
******************************************/
static BOOLEAN __fastcall WriteFileHeader(DWORD dwIndex)
{
	DWORD dwActualSize;
	FILE_HEADER_INFO FileHeader;

	FileHeader.dwGroupCount = G_FileInfo[dwIndex].dwGroupCount;
	FileHeader.dwGroupIndex = G_FileInfo[dwIndex].dwGroupIndex;
	FileHeader.dwItemCount = G_FileInfo[dwIndex].dwItemCount;
	FileHeader.dwItemIndex = G_FileInfo[dwIndex].dwItemIndex;

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 0U, NULL, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::WriteFile(G_FileInfo[dwIndex].hSpecFile, &FileHeader, sizeof(FILE_HEADER_INFO), &dwActualSize, NULL))
	{
		return FALSE;
	}
	return TRUE;
}

/******************************************
功能：刷新缓存区并写入文件
参数：dwIndex 文件索引
返回：TRUE则成功
******************************************/
BOOLEAN __fastcall FlushFileCache(DWORD dwIndex)
{
	if (0U == G_FileInfo[dwIndex].lpCacheInfo.dwCacheToFileCount)
	{
		SetCacheToFileInfo(dwIndex, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache,
			G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount);
		return (CacheCopyFile(dwIndex));
	}
	return FALSE;
}

/******************************************
功能：关闭指定的文件
参数：dwIndex 文件索引
返回：TRUE则成功
******************************************/
BOOLEAN __fastcall CloseFileIndex(DWORD dwIndex)
{
	if (NULL != G_FileInfo[dwIndex].hSpecFile)
	{
		if (FALSE == WriteFileHeader(dwIndex))
		{
			return FALSE;
		}

		if (FALSE == FlushFileCache(dwIndex))
		{
			return FALSE;
		}

		::CloseHandle(G_FileInfo[dwIndex].hSpecFile);
		G_FileInfo[dwIndex].hSpecFile = NULL;
	}
	return TRUE;
}

/******************************************
功能：增加指定文件内部索引
参数：dwIndex 文件索引
返回：不会失败
******************************************/
static VOID __fastcall AddFileIndexInfo(DWORD dwIndex)
{
	G_FileInfo[dwIndex].dwItemIndex++;
	G_FileInfo[dwIndex].dwItemCount++;

	if (MAX_ITEM_COUNT == G_FileInfo[dwIndex].dwItemIndex)
	{
		G_FileInfo[dwIndex].dwGroupIndex++;
		G_FileInfo[dwIndex].dwGroupCount++;
		G_FileInfo[dwIndex].dwItemIndex = 0U;
	}
}

/******************************************
功能：返回可读写的新数据索引
参数：dwIndex 文件索引
参数：lpGroupIndex 返回新组索引
参数：lpItemIndex 返回新成员索引
返回：无
******************************************/
VOID __fastcall GetContentsIndex(DWORD dwIndex, DWORD * lpGroupIndex, DWORD * lpItemIndex)
{
	*lpGroupIndex = G_FileInfo[dwIndex].dwGroupIndex;
	*lpItemIndex = G_FileInfo[dwIndex].dwItemIndex;
	return (AddFileIndexInfo(dwIndex));
}

/******************************************
功能：从缓存区中查找数据索引
参数：dwIndex 文件索引
参数：lpBuffer 需要查找的缓冲区
参数：uBufSize 查找内容的长度
参数：lpGroupIndex 返回组索引
参数：lpItemIndex 返回成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall FindCacheContentIndex(DWORD dwIndex, LPCVOID lpBuffer, USHORT uBufSize, DWORD * lpGroupIndex, DWORD * lpItemIndex)
{
	for (register UINT uFindIndex = 0U; uFindIndex < G_FileInfo[dwIndex].lpCacheInfo.dwFileToCacheCount; ++uFindIndex)
	{
		if (0 == memcmp(lpBuffer, G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].uBuffer, uBufSize))
		{
			*lpGroupIndex = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].dwGroupIndex;
			*lpItemIndex = G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[uFindIndex].dwItemIndex;
			return TRUE;
		}
	}
	return FALSE;
}

/******************************************
功能：从硬盘文件中查找数据索引
参数：dwIndex 文件索引
参数：lpBuffer 需要查找的缓冲区
参数：uBufSize 查找内容的长度
参数：lpGroupIndex 返回组索引
参数：lpItemIndex 返回成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall FindFileContentIndex(DWORD dwIndex, LPCVOID lpBuffer, USHORT uBufSize, DWORD * lpGroupIndex, DWORD * lpItemIndex)
{
	LARGE_INTEGER FilePoint;
	PFILE_AREA_INFO FileAreaInfo = (PFILE_AREA_INFO)G_FileInfo[dwIndex].lpFindBuffer;

	CONST DWORD dwFindCount = ((G_FileInfo[dwIndex].dwItemCount % MAX_ITEM_COUNT) > 0U) ?
		(G_FileInfo[dwIndex].dwGroupCount + 1U) : (G_FileInfo[dwIndex].dwGroupCount);

	for (register UINT uFileIndex = 0U; uFileIndex < dwFindCount; ++uFileIndex)
	{
		FilePoint.QuadPart = sizeof(FILE_HEADER_INFO);
		FilePoint.QuadPart = FilePoint.QuadPart + ((uFileIndex * MAX_ITEM_COUNT) * sizeof(FILE_AREA_INFO));

		if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 
			FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
		{
			return FALSE;
		}

		if (FALSE == ::ReadFile(G_FileInfo[dwIndex].hSpecFile,
			FileAreaInfo, (sizeof(FILE_AREA_INFO) * MAX_ITEM_COUNT), &FilePoint.LowPart, NULL))
		{
			return FALSE;
		}

		FilePoint.LowPart = FilePoint.LowPart / sizeof(FILE_AREA_INFO);

		for (register UINT uBufferIndex = 0U; uBufferIndex < FilePoint.LowPart; ++uBufferIndex)
		{
			if (0 == memcmp(lpBuffer, FileAreaInfo[uBufferIndex].uBuffer, uBufSize))
			{
				*lpGroupIndex = FileAreaInfo[uBufferIndex].dwGroupIndex;
				*lpItemIndex = FileAreaInfo[uBufferIndex].dwItemIndex;
				return TRUE;
			}
		}
	}
	return FALSE;
}

/******************************************
功能：查找需要读写的数据索引
参数：dwIndex 文件索引
参数：lpBuffer 需要查找的缓冲区
参数：uBufSize 查找内容的长度
参数：lpGroupIndex 返回组索引
参数：lpItemIndex 返回成员索引
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall FindContentsIndex(DWORD dwIndex, LPCVOID lpBuffer, USHORT uBufSize, DWORD * lpGroupIndex, DWORD * lpItemIndex)
{
	if (uBufSize >= MAX_BUFFER_SIZE || TRUE == ::IsBadReadPtr(lpBuffer, uBufSize))
	{
		return FALSE;
	}

	if (FALSE == FindCacheContentIndex(dwIndex, lpBuffer, uBufSize, lpGroupIndex, lpItemIndex))
	{
		return (FindFileContentIndex(dwIndex, lpBuffer, uBufSize, lpGroupIndex, lpItemIndex));
	}
	return TRUE;
}

/******************************************
功能：在缓存中检测是否被删除
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall IsDeleteCacheContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (0U != G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize && 
		dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex)
	{
		if (TRUE == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uIsDelete)
		{
			return TRUE;
		}
	}
	return FALSE;
}

/******************************************
功能：在文件中检测是否被删除
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static  BOOLEAN __stdcall IsDeleteFileContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	LARGE_INTEGER FilePoint;
	FILE_AREA_INFO FileAreaInfo;

	FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
	FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
	FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
	FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile,
		FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::ReadFile(G_FileInfo[dwIndex].hSpecFile, 
		&FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL))
	{
		return FALSE;
	}

	if (0U != FilePoint.LowPart && TRUE == FileAreaInfo.uIsDelete)
	{
		return TRUE;
	}
	return FALSE;
}

/******************************************
功能：是否是被删除的数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall IsDeleteContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (dwItemIndex >= MAX_ITEM_COUNT)
	{
		return FALSE;
	}

	if (FALSE == IsDeleteCacheContentsIndex(dwIndex, dwGroupIndex, dwItemIndex))
	{
		return (IsDeleteFileContentsIndex(dwIndex, dwGroupIndex, dwItemIndex));
	}
	return TRUE;
}

/******************************************
功能：在缓存中删除数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall DeleteCacheContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (0U != G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize && 
		dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex)
	{
		if (FALSE == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uIsDelete)
		{
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uIsDelete = TRUE;
			return TRUE;
		}
	}
	return FALSE;
}

/******************************************
功能：在文件中删除数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall DeleteFileContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	LARGE_INTEGER FilePoint;
	FILE_AREA_INFO FileAreaInfo;

	FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
	FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
	FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
	FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 
		FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::ReadFile(G_FileInfo[dwIndex].hSpecFile, 
		&FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL))
	{
		return FALSE;
	}

	if (0U != FilePoint.LowPart && FALSE == FileAreaInfo.uIsDelete)
	{

		FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
		FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
		FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
		FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

		if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile, 
			FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
		{
			return FALSE;
		}

		FileAreaInfo.uIsDelete = TRUE;
		return (::WriteFile(G_FileInfo[dwIndex].hSpecFile, 
			&FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL));
	}
	return FALSE;
}

/******************************************
功能：删除指定的数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall DeleteContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (dwItemIndex >= MAX_ITEM_COUNT)
	{
		return FALSE;
	}

	if (FALSE == DeleteCacheContentsIndex(dwIndex, dwGroupIndex, dwItemIndex))
	{
		return (DeleteFileContentsIndex(dwIndex, dwGroupIndex, dwItemIndex));
	}
	return TRUE;
}

/******************************************
功能：在缓存中恢复数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall RecoveryCacheContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (0U != G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uActualSize && 
		dwGroupIndex == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].dwGroupIndex)
	{
		if (TRUE == G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uIsDelete)
		{
			G_FileInfo[dwIndex].lpCacheInfo.lpTurnsFileToCache[dwItemIndex].uIsDelete = FALSE;
			return TRUE;
		}
	}
	return FALSE;
}

/******************************************
功能：在文件中恢复数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
static BOOLEAN __stdcall RecoveryFileContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	LARGE_INTEGER FilePoint;
	FILE_AREA_INFO FileAreaInfo;

	FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
	FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
	FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
	FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

	if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile,
		FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
	{
		return FALSE;
	}

	if (FALSE == ::ReadFile(G_FileInfo[dwIndex].hSpecFile, 
		&FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL))
	{
		return FALSE;
	}

	if (0U != FilePoint.LowPart && TRUE == FileAreaInfo.uIsDelete)
	{
		FilePoint.QuadPart = dwGroupIndex * MAX_ITEM_COUNT;
		FilePoint.QuadPart = FilePoint.QuadPart + dwItemIndex;
		FilePoint.QuadPart = FilePoint.QuadPart * sizeof(FILE_AREA_INFO);
		FilePoint.QuadPart = FilePoint.QuadPart + sizeof(FILE_HEADER_INFO);

		if (INVALID_SET_FILE_POINTER == ::SetFilePointer(G_FileInfo[dwIndex].hSpecFile,
			FilePoint.LowPart, &FilePoint.HighPart, FILE_BEGIN))
		{
			return FALSE;
		}

		FileAreaInfo.uIsDelete = FALSE;
		return (::WriteFile(G_FileInfo[dwIndex].hSpecFile, 
			&FileAreaInfo, sizeof(FileAreaInfo), &FilePoint.LowPart, NULL));
	}
	return FALSE;
}

/******************************************
功能：恢复指定的数据
参数：dwIndex 文件索引
参数：dwGroupIndex 组索引
参数：dwItemIndex 成员索引
返回：TRUE则成功
******************************************/
BOOLEAN __stdcall RecoveryContentsIndex(DWORD dwIndex, DWORD dwGroupIndex, DWORD dwItemIndex)
{
	if (dwItemIndex >= MAX_ITEM_COUNT)
	{
		return FALSE;
	}

	if (FALSE == RecoveryCacheContentsIndex(dwIndex, dwGroupIndex, dwItemIndex))
	{
		return (RecoveryFileContentsIndex(dwIndex, dwGroupIndex, dwItemIndex));
	}
	return TRUE;
}

TEST.cpp

// StorageFrame.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "StorageFrameBase.h"

#include "amp.h"


int _tmain(int argc, _TCHAR* argv[])
{
	DWORD dwGroupIndex;
	DWORD dwItemIndex;
	USHORT uSize;
	char IndexBuf[32];

	if (FALSE == AllocFileInfo(MAX_FILE_COUNT))
	{
		printf("分配文件信息失败！\r\n");
		return 0;
	}

	for (register unsigned int i = 0U; i < MAX_FILE_COUNT; ++i)
	{

		if (FALSE == AllocBufferInfo(i, MAX_ITEM_COUNT))
		{
			printf("分配缓冲区信息失败！\r\n");
			return 0;
		}

		if (FALSE == AllocCacheInfo(i, MAX_CACHE_COUNT))
		{
			printf("分配缓存信息失败！\r\n");
			return 0;
		}

		SetFileToCacheL(i);

		if (FALSE == BindFileToIndex(i, L"D:\\test.txt", wcslen(L"D:\\test.txt")))
		{
			printf("绑定文件索引失败！\r\n");
			return 0;
		}

		X = i;


		for (register unsigned int j = 0U; j < 4096U; ++j)
		{
			uSize = 32U;
			_itoa_s(j, IndexBuf, 16);

			if (FALSE == FindContentsIndex(i, IndexBuf, uSize, &dwGroupIndex, &dwItemIndex))
			{
				printf("%d:数据未找到！\r\n",j);
				GetContentsIndex(i, &dwGroupIndex, &dwItemIndex);
			}
			//DeleteContentsIndex(X, PFILE_PARAM(PTRY)->dwGroupIndex, PFILE_PARAM(PTRY)->dwItemIndex);
			//RecoveryContentsIndex(X, PFILE_PARAM(PTRY)->dwGroupIndex, PFILE_PARAM(PTRY)->dwItemIndex);

			if (TRUE == IsDeleteContentsIndex(i, dwGroupIndex, dwItemIndex))
			{
				//printf("该数据已被删除！\r\n");
			}
			else
			{
				if (FALSE == WriteFileIndex(i, dwGroupIndex, dwItemIndex, IndexBuf, &uSize))
				{
					printf("写入数据失败！\r\n");
				}
				else
				{
					if (TRUE == ReadFileIndex(i, dwGroupIndex, dwItemIndex, IndexBuf, &uSize))
					{
						//printf("读取数据 -> %s\r\n", IndexBuf);
					}
				}
			}
		}
		CloseFileIndex(i);
		FreeBufferInfo(i);
		FreeCacheInfo(i);
	}

	FreeFileInfo();
	return 0;
}