makejianpinindexdlg.cpp

中文编码转换

			int iPackID1 = 0;
			int iPackID2 = 0;
			PPCHAR ppDYRet = GetAdjoiningJPByDYZ(szName, strlen(szName), nDistLen);
			bool bFlag[CHARACTER_NEWINDEX_COUNT * CHARACTER_NEWINDEX_COUNT] = {0,};
			for(int i = 0; i < nDistLen - 1; i++)
			{
				iPackID1 = GetPYIndex(ppDYRet[i][0]);
				iPackID2 = GetPYIndex(ppDYRet[i][1]);
				if(iPackID1 < 0 || iPackID2 < 0)
					continue;
				if(bFlag[iPackID1 * CHARACTER_NEWINDEX_COUNT + iPackID2])
					continue;

				CNameNode* pNameNode = new CNameNode(szName, st_info.lBreadthID, st_info.byLayerID, 0);
				ASSERT(pNameNode != NULL);		
				m_ppPINameNewPack[iPackID1][iPackID2]->AddTail(pNameNode);
				bFlag[iPackID1 * CHARACTER_NEWINDEX_COUNT + iPackID2] = true;
			}
			MyDelete(ppDYRet, nDistLen);
		}
		pi_File.Close();
	}

	std::vector<ST_Info> vRdContainer;
	if(_access(strRdFilePath.GetBuffer(0), 0) == 0)
	{
		CStdioFile rd_File(strRdFilePath, CStdioFile::modeRead);
		CString strContent;
		char szName[64] = {0, };
		while(rd_File.ReadString(strContent))
		{
			if(strContent.GetLength() == 0)
				continue;

			ST_Info st_info;
			ASSERT(st_info.ParseRdTxt(strContent));
			vRdContainer.push_back(st_info);						
		}
		rd_File.Close();

		sort(vRdContainer.begin(), vRdContainer.end(), lessName);
		for(int i = 0; i < vRdContainer.size() - 1; )
		{
			ST_Info st_rd1 = vRdContainer[i];
			ST_Info st_rd2 = vRdContainer[i + 1];
			if(strcmp(vRdContainer[i].szName, vRdContainer[i + 1].szName) == 0 &&
				vRdContainer[i].lBreadthID == vRdContainer[i + 1].lBreadthID &&
				vRdContainer[i].byLayerID == vRdContainer[i + 1].byLayerID)
			{
				vRdContainer.erase(&vRdContainer[i]);
				continue;
			}
			
			char szName[64] = {0, };
			strcpy(szName, vRdContainer[i].szName);

			
			int nNameLen = 0;
			DeleteQuotation(szName, nNameLen);

			// 得到相邻多音组合
			int nDistLen = -1;
			int iPackID1 = 0;
			int iPackID2 = 0;
			PPCHAR ppDYRet = GetAdjoiningJPByDYZ(szName, strlen(szName), nDistLen);
			bool bFlag[CHARACTER_NEWINDEX_COUNT * CHARACTER_NEWINDEX_COUNT] = {0,};
			for(int j = 0; j < nDistLen - 1; j++)
			{
				iPackID1 = GetPYIndex(ppDYRet[j][0]);
				iPackID2 = GetPYIndex(ppDYRet[j][1]);
				if(iPackID1 < 0 || iPackID2 < 0)
					continue;
				if(bFlag[iPackID1 * CHARACTER_NEWINDEX_COUNT + iPackID2])
					continue;

				CNameNode* pNameNode = new CNameNode(szName, vRdContainer[i].lBreadthID, vRdContainer[i].byLayerID, 0);
				ASSERT(pNameNode != NULL);		
				m_ppRdNameNewPack[iPackID1][iPackID2]->AddTail(pNameNode);
				bFlag[iPackID1 * CHARACTER_NEWINDEX_COUNT + iPackID2] = true;
			}
			i++;
			MyDelete(ppDYRet, nDistLen);
		}
		m_nRdCnt = vRdContainer.size();
		vRdContainer.clear();
	}
}

void CCity::DeleteQuotation(char* pszName, int& nNameLen)
{
	nNameLen = strlen(pszName);
	int iCnt = 0;
	for(int j = 0; j < nNameLen; j++)
	{
		if(pszName[j] == '\"')
			iCnt++;
		else if(iCnt > 0)
		{
			pszName[j - iCnt] = pszName[j];
		}
	}
	nNameLen -= iCnt;
	pszName[nNameLen] = 0x0;
}

void CCity::LoadJPToPack(CJPNodeChain *pJPNodeChain, LPBYTE &pbOrigin)
{
	if (pJPNodeChain == NULL || pbOrigin == NULL)
		return;
	
	for (CJPNode *pJPNode = pJPNodeChain->GetFirst(); pJPNode != NULL; pJPNode = pJPNode->GetNext())
	{
		// (1)(1)Offset
		int nTemp = pJPNode->GetOffset();
		memcpy(pbOrigin, &nTemp, sizeof(nTemp));
		pbOrigin += sizeof(nTemp);

		// (1)(2)JPCode
		memcpy(pbOrigin, pJPNode->GetJPCode(), pJPNode->GetJPCodeLen());
		pbOrigin += pJPNode->GetJPCodeLen();
		*pbOrigin++ = 0x0; // '\0'
	}
}

void CCity::LoadNameIndexToPack(ST_NameIndex st_NameIndex, LPBYTE &pbOrigin)
{
	if (pbOrigin == NULL)
		return;

	// Offset
	int nTemp = st_NameIndex.nOffset;
	memcpy(pbOrigin, &nTemp, sizeof(nTemp));
	pbOrigin += sizeof(nTemp);

	// 数据压缩后长度
	nTemp = st_NameIndex.nTotalLen;
	memcpy(pbOrigin, &nTemp, sizeof(nTemp));
	pbOrigin += sizeof(nTemp);

	// PI数据解压缩后长度
	nTemp = st_NameIndex.nPIULen;
	memcpy(pbOrigin, &nTemp, sizeof(nTemp));
	pbOrigin += sizeof(nTemp);

	// RD数据解压缩后长度
	nTemp = st_NameIndex.nRdULen;
	memcpy(pbOrigin, &nTemp, sizeof(nTemp));
	pbOrigin += sizeof(nTemp);
}

void CCity::LoadNameDataToPack(CNameNodeChain *pNameNodeChain, LPBYTE &pbOrigin)
{
	for (CNameNode *pNameNode = pNameNodeChain->GetFirst(); pNameNode != NULL; pNameNode = pNameNode->GetNext())
	{
		// (1)Name length
		int nTemp = pNameNode->GetNameLen();
		memcpy(pbOrigin, &nTemp, sizeof(nTemp));
		pbOrigin += sizeof(nTemp);

		// (2)Name
		memcpy(pbOrigin, pNameNode->GetName(), pNameNode->GetNameLen());
		pbOrigin += pNameNode->GetNameLen();

		// (3)MapID
		nTemp = pNameNode->GetMapID();
		memcpy(pbOrigin, &nTemp, sizeof(nTemp));
		pbOrigin += sizeof(nTemp);

		// (4)Layer
		*pbOrigin++ = pNameNode->GetLayer();
		*pbOrigin++ = pNameNode->GetType();
	}
}

//////////////////////////////////////////////////////////////////
// 功能：将简拼索引、数据以及名称索引、数据写入文件
// 注意：分包大于cdwCapacity的进行拆分
// 日期：20071225
//////////////////////////////////////////////////////////////////
const DWORD cdwCapacity = 300000;
int CCity::Write(CFile& fileJP,		
				 CFile& fileData,			// 临时文件，存放分包数据
				 int& iCharIdxPos,			// 字母一级索引位置
				 int& iPackIdxPos,			// 分包索引位置（字母二级索引位置）
				 int& iPackDataPos)			// 分包数据位置				 		
{		
	int iPackNum = 0;
	int iPackNo1 = 0;
	int iPackNo2 = 0;
	int iTotalULen = 0;

	for(iPackNo1 = 0; iPackNo1 < CHARACTER_NEWINDEX_COUNT; iPackNo1++)
	{	
		ST_CharIndex st_CharIdx;
		memset(&st_CharIdx, 0x0, sizeof(ST_CharIndex));		
		st_CharIdx.iOffset = iPackIdxPos;
		
		for(iPackNo2 = 0; iPackNo2 < CHARACTER_NEWINDEX_COUNT; iPackNo2++)
		{
			ST_PackIndex st_PackIndex;
			memset(&st_PackIndex, 0x0, sizeof(ST_PackIndex));
			st_PackIndex.byNo = iPackNo2;
			ST_NameData st_NameData;
			memset(&st_NameData, 0x0, sizeof(ST_NameData));
			
			BYTE* pJPData = new BYTE[cdwCapacity];		// 临时JP数据块
			BYTE* pNameData = new BYTE[cdwCapacity];	// 临时Name数据块
			memset(pJPData, 0x0, cdwCapacity);
			memset(pNameData, 0x0, cdwCapacity);
			BYTE* pJPCur = pJPData;
			BYTE* pNameCur = pNameData;
			DWORD dwDataLen = 0; // 总的数据长度
			int iOffset = 0; // 相对偏移
			BYTE byJPLen = 0;

			// (1)分拆POI简拼和对应的名称数据
			CNameNode* pNameNode = m_ppPINameNewPack[iPackNo1][iPackNo2]->GetFirst();
			while(pNameNode != NULL)
			{
				char* pszName  = pNameNode->GetName();
				int nNameLen = pNameNode->GetNameLen();
				int iUnitNum = 0; // 一个名称对应iUnitNum个简拼
				PPCHAR ppDYRet = GetFullHZJPByDYZ(pszName, nNameLen, iUnitNum);
				byJPLen = strlen(ppDYRet[0]) + 1;
				ASSERT(iUnitNum * (sizeof(iOffset) + byJPLen) + pNameNode->IndexLen() <= cdwCapacity);

				// 判断是否超过存储长度上限
				if(dwDataLen + iUnitNum * (sizeof(iOffset) + byJPLen) + pNameNode->IndexLen() <= cdwCapacity)				
				{
					// 多音简拼，same offset
					for (int i = 0; i < iUnitNum; ++i)
					{
						char *pszJPCode = new char[byJPLen];
						strcpy(pszJPCode, ppDYRet[i]);
						pszJPCode[byJPLen - 1] = 0x0;

						// 写入POI简拼数据
						memcpy(pJPCur, &iOffset, sizeof(iOffset));
						pJPCur += sizeof(iOffset);				
						memcpy(pJPCur, pszJPCode, byJPLen);
						pJPCur += byJPLen;
						
						delete[] pszJPCode;
						pszJPCode = NULL;
					}					
					dwDataLen += iUnitNum * (sizeof(iOffset) + byJPLen);

					// 写入POI名称数据
					st_NameData.byCharCnt	= pNameNode->GetNameLen();
					st_NameData.byType		= pNameNode->GetType();
					st_NameData.byLayerID	= pNameNode->GetLayer();
					st_NameData.iMapID		= pNameNode->GetMapID();
					memcpy(pNameCur, &st_NameData, sizeof(ST_NameData));
					pNameCur += sizeof(ST_NameData);
					memcpy(pNameCur, pszName, nNameLen);
					pNameCur += nNameLen;

					dwDataLen += pNameNode->IndexLen();
					iOffset += pNameNode->IndexLen();
					
					// 取下一条数据
					pNameNode = pNameNode->GetNext();
				}
				else
				{
					// 一、将临时数据合并并压缩，形成一分包
					int iTmpJPULen = pJPCur - pJPData;
					int iTmpNameULen = pNameCur - pNameData;
					ASSERT(dwDataLen == iTmpJPULen + iTmpNameULen);
					uLongf nULen = dwDataLen;
					uLongf nLen = compressBound(nULen);
					BYTE *pbUBuf = new BYTE[nULen];
					BYTE *pbBuf = new BYTE[nLen];
					memcpy(pbUBuf, pJPData, iTmpJPULen);
					memcpy(pbUBuf + iTmpJPULen, pNameData, iTmpNameULen);
					
					if (Z_OK != compress(pbBuf, &nLen, pbUBuf, nULen))
					{
						AfxMessageBox("compress error!");
						delete []pbBuf;
						delete []pbUBuf;
						pbBuf = NULL;
						pbUBuf = NULL;
						return;
					}						
					
					st_PackIndex.byFlag			= 0;
					st_PackIndex.iOffset		= iPackDataPos;					
					st_PackIndex.nTotalLen		= nLen;
					st_PackIndex.nTotalULen		= nULen;
					st_PackIndex.nJPULen		= iTmpJPULen;
					fileJP.Seek(iPackIdxPos, CFile::begin);
					fileJP.Write(&st_PackIndex, sizeof(ST_PackIndex));
					iPackIdxPos += sizeof(ST_PackIndex);
					fileData.Write(pbBuf, nLen);
					iPackDataPos += nLen;
					
					delete []pbBuf;
					delete []pbUBuf;
					pbBuf = NULL;
					pbUBuf = NULL;
					st_CharIdx.usPackNum++;

					// 二、重新初始化
					dwDataLen = 0;
					iOffset = 0;
					memset(pJPData, 0x0, cdwCapacity);
					memset(pNameData, 0x0, cdwCapacity);
					pJPCur = pJPData;
					pNameCur = pNameData;
				}
				MyDelete(ppDYRet, iUnitNum);
			}

			// (2)将余下不满上限的POI数据压缩打包
			if(pJPCur > pJPData && pNameCur > pNameData)
			{
				int iTmpJPULen = pJPCur - pJPData;
				int iTmpNameULen = pNameCur - pNameData;
				ASSERT(dwDataLen == iTmpJPULen + iTmpNameULen);
				uLongf nULen = dwDataLen;
				uLongf nLen = compressBound(nULen);
				BYTE *pbUBuf = new BYTE[nULen];
				BYTE *pbBuf = new BYTE[nLen];
				memcpy(pbUBuf, pJPData, iTmpJPULen);
				memcpy(pbUBuf + iTmpJPULen, pNameData, iTmpNameULen);
				
				if (Z_OK != compress(pbBuf, &nLen, pbUBuf, nULen))
				{
					AfxMessageBox("compress error!");
					delete []pbBuf;
					delete []pbUBuf;
					pbBuf = NULL;
					pbUBuf = NULL;
					return;
				}						
				
				st_PackIndex.byFlag			= 0;
				st_PackIndex.iOffset		= iPackDataPos;					
				st_PackIndex.nTotalLen		= nLen;	
				st_PackIndex.nTotalULen		= nULen;
				st_PackIndex.nJPULen		= iTmpJPULen;
				fileJP.Seek(iPackIdxPos, CFile::begin);
				fileJP.Write(&st_PackIndex, sizeof(ST_PackIndex));
				iPackIdxPos += sizeof(ST_PackIndex);
				fileData.Write(pbBuf, nLen);
				iPackDataPos += nLen;
				
				delete []pbBuf;
				delete []pbUBuf;
				pbBuf = NULL;
				pbUBuf = NULL;
				st_CharIdx.usPackNum++;

				// 二、重新初始化
				dwDataLen = 0;
				iOffset = 0;
				memset(pJPData, 0x0, cdwCapacity);
				memset(pNameData, 0x0, cdwCapacity);
				pJPCur = pJPData;
				pNameCur = pNameData;
			}

			// (3)分拆Rd简拼和对应的名称数据
			pNameNode = m_ppRdNameNewPack[iPackNo1][iPackNo2]->GetFirst();
			while(pNameNode != NULL)
			{
				char* pszName  = pNameNode->GetName();
				int nNameLen = pNameNode->GetNameLen();
				int iUnitNum = 0; // 一个名称对应iUnitNum个简拼
				PPCHAR ppDYRet = GetFullHZJPByDYZ(pszName, nNameLen, iUnitNum);
				byJPLen = strlen(ppDYRet[0]) + 1;
				ASSERT(iUnitNum * (sizeof(iOffset) + byJPLen) + pNameNode->IndexLen() <= cdwCapacity);

				// 判断是否超过存储长度上限
				if(dwDataLen + iUnitNum * (sizeof(iOffset) + byJPLen) + pNameNode->IndexLen() <= cdwCapacity)
				{	
					// 多音简拼，same offset
					for (int i = 0; i < iUnitNum; ++i)
					{
						char *pszJPCode = new char[byJPLen];
						strcpy(pszJPCode, ppDYRet[i]);
						pszJPCode[byJPLen - 1] = 0x0;

						// 写入Rd简拼数据
						memcpy(pJPCur, &iOffset, sizeof(iOffset));
						pJPCur += sizeof(iOffset);				
						memcpy(pJPCur, pszJPCode, byJPLen);
						pJPCur += byJPLen;
						
						delete[] pszJPCode;
						pszJPCode = NULL;
					}					
					dwDataLen += iUnitNum * (sizeof(iOffset) + byJPLen);					

					// 写入Rd名称数据
					st_NameData.byCharCnt	= pNameNode->GetNameLen();
					st_NameData.byType		= pNameNode->GetType();
					st_NameData.byLayerID	= pNameNode->GetLayer();
					st_NameData.iMapID		= pNameNode->GetMapID();
					memcpy(pNameCur, &st_NameData, sizeof(ST_NameData));
					pNameCur += sizeof(ST_NameData);
					memcpy(pNameCur, pszName, nNameLen);
					pNameCur += nNameLen;

					dwDataLen += pNameNode->IndexLen();
					iOffset += pNameNode->IndexLen();
					
					// 取下一条数据
					pNameNode = pNameNode->GetNext();
				}
				else
				{
					// 一、将临时数据合并并压缩，形成一分包
					int iTmpJPULen = pJPCur - pJPData;
					int iTmpNameULen = pNameCur - pNameData;
					ASSERT(dwDataLen == iTmpJPULen + iTmpNameULen);
					uLongf nULen = dwDataLen;
					uLongf nLen = compressBound(nULen);
					BYTE *pbUBuf = new BYTE[nULen];
					BYTE *pbBuf = new BYTE[nLen];
					memcpy(pbUBuf, pJPData, iTmpJPULen);
					memcpy(pbUBuf + iTmpJPULen, pNameData, iTmpNameULen);
					
					if (Z_OK != compress(pbBuf, &nLen, pbUBuf, nULen))
					{
						AfxMessageBox("compress error!");
						delete []pbBuf;
						delete []pbUBuf;
						pbBuf = NULL;
						pbUBuf = NULL;
						return;
					}						
					
					st_PackIndex.byFlag			= 1;
					st_PackIndex.iOffset		= iPackDataPos;					
					st_PackIndex.nTotalLen		= nLen;	
					st_PackIndex.nTotalULen		= nULen;
					st_PackIndex.nJPULen		= iTmpJPULen;
					fileJP.Seek(iPackIdxPos, CFile::begin);
					fileJP.Write(&st_PackIndex, sizeof(ST_PackIndex));
					iPackIdxPos += sizeof(ST_PackIndex);
					fileData.Write(pbBuf, nLen);
					iPackDataPos += nLen;
					
					delete []pbBuf;
					delete []pbUBuf;
					pbBuf = NULL;
					pbUBuf = NULL;
					st_CharIdx.usPackNum++;

					// 二、重新初始化
					dwDataLen = 0;
					iOffset = 0;
					memset(pJPData, 0x0, cdwCapacity);
					memset(pNameData, 0x0, cdwCapacity);
					pJPCur = pJPData;
					pNameCur = pNameData;
				}
				MyDelete(ppDYRet, iUnitNum);
			}

			// (4)将余下不满上限的Rd数据压缩打包
			if(pJPCur > pJPData && pNameCur > pNameData)
			{
				int iTmpJPULen = pJPCur - pJPData;
				int iTmpNameULen = pNameCur - pNameData;
				ASSERT(dwDataLen == iTmpJPULen + iTmpNameULen);
				uLongf nULen = dwDataLen;
				uLongf nLen = compressBound(nULen);
				BYTE *pbUBuf = new BYTE[nULen];
				BYTE *pbBuf = new BYTE[nLen];
				memcpy(pbUBuf, pJPData, iTmpJPULen);
				memcpy(pbUBuf + iTmpJPULen, pNameData, iTmpNameULen);
				
				if (Z_OK != compress(pbBuf, &nLen, pbUBuf, nULen))
				{
					AfxMessageBox("compress error!");
					delete []pbBuf;
					delete []pbUBuf;
					pbBuf = NULL;
					pbUBuf = NULL;
					return;
				}						
				
				st_PackIndex.byFlag			= 1;
				st_PackIndex.iOffset		= iPackDataPos;					
				st_PackIndex.nTotalLen		= nLen;	
				st_PackIndex.nTotalULen		= nULen;
				st_PackIndex.nJPULen		= iTmpJPULen;
				fileJP.Seek(iPackIdxPos, CFile::begin);
				fileJP.Write(&st_PackIndex, sizeof(ST_PackIndex));
				iPackIdxPos += sizeof(ST_PackIndex);
				fileData.Write(pbBuf, nLen);
				iPackDataPos += nLen;
				
				delete []pbBuf;
				delete []pbUBuf;
				pbBuf = NULL;
				pbUBuf = NULL;
				st_CharIdx.usPackNum++;

				// 二、重新初始化
				dwDataLen = 0;