makejianpinindexdlg.cpp

中文编码转换

	AfxMessageBox("Finished!");
}




/*************************************** CJPNode ***************************************/
CJPNode::CJPNode()
{
	m_nOffset = 0xFFFFFFFF;
	m_pbJPCode = NULL;
	m_pNext = NULL;
}

CJPNode::~CJPNode()
{
	if (m_pbJPCode != NULL)
	{
		delete []m_pbJPCode;
	}
}

// Get
int CJPNode::GetOffset() const
{
	return m_nOffset;
}

BYTE* CJPNode::GetJPCode() const
{
	return m_pbJPCode;
}

BYTE CJPNode::GetJPCodeLen() const
{
	ASSERT(m_pbJPCode != NULL);

	return strlen((char*)m_pbJPCode);
}

CJPNode* CJPNode::GetNext() const
{
	return m_pNext;
}

// Set
void CJPNode::SetOffset(const int &nOffset)
{
	m_nOffset = nOffset;
}

void CJPNode::SetJPCode(const BYTE *pbJPCode)
{
	m_pbJPCode = (BYTE*)pbJPCode;
}

void CJPNode::SetNext(const CJPNode *pNext)
{
	m_pNext = (CJPNode*)pNext;
}

// Stat
int CJPNode::IndexLen()
{
	/*
	* Offset:	4
	* JPCode:	n including '\0'
	*/

	ASSERT(m_pbJPCode != NULL);
	return 4 + GetJPCodeLen() + 1;
}
/*************************************** CJPNode ***************************************/


/*************************************** CJPNodeChain ***************************************/
// Constructor and destroyer
CJPNodeChain::CJPNodeChain()
{
	m_pHead = new CJPNode;
	m_pTail = m_pHead;
	m_nObjNum = 0;
	ASSERT(m_pHead != NULL);
}

CJPNodeChain::~CJPNodeChain()
{
	for (CJPNode *pTemp = m_pHead; pTemp != NULL; )
	{
		m_pHead = pTemp->GetNext();
		delete pTemp;
		pTemp = m_pHead;
	}
	m_nObjNum = 0;
}

// Get
int CJPNodeChain::GetObjNum() const
{
	return m_nObjNum;
}

CJPNode* CJPNodeChain::GetFirst() const
{
	return m_pHead->GetNext();
}

// Set

// Insert
void CJPNodeChain::AddTail(CJPNode *pInsNode)
{
	if (pInsNode == NULL)
		return;

	m_pTail->SetNext(pInsNode);
	m_pTail = pInsNode;
	m_pTail->SetNext(NULL);
	++m_nObjNum;
}

// Stat
int CJPNodeChain::IndexLen() const
{
	int nIndexLen = 0;
	for (CJPNode *pNode = GetFirst(); pNode != NULL; pNode = pNode->GetNext())
		nIndexLen += pNode->IndexLen();

	return nIndexLen;
}

/*************************************** ~CJPNodeChain ***************************************/

/*************************************** CNameNode ***************************************/
CNameNode::CNameNode()
{
	m_pszName = NULL;
	m_nMapID = 0xFFFFFFFF;
	m_bLayer = 0xFF;
	m_bType = 0xFF;
	m_pNext = NULL;
}

CNameNode::CNameNode(char *pszName, int nMapID, BYTE bLayer, BYTE bType): m_nMapID(nMapID), m_bLayer(bLayer), m_bType(bType)
{	
	m_pszName = new char[strlen(pszName) + 1];
	memset(m_pszName, 0x0, strlen(pszName) + 1);
	strcpy(m_pszName, pszName);
	m_pNext = NULL;

	// for test
	int iLen = strlen(m_pszName);
}

CNameNode::~CNameNode()
{
	if (m_pszName != NULL)
	{
		delete []m_pszName;
	}
}

// Get
char* CNameNode::GetName() const
{
	return m_pszName;
}

int  CNameNode::GetNameLen() const
{
	if (m_pszName == NULL)
		return 0;
	return strlen(m_pszName);
}

int CNameNode::GetMapID() const
{
	return m_nMapID;
}

BYTE CNameNode::GetLayer() const
{
	return m_bLayer;
}

BYTE CNameNode::GetType() const
{
	return m_bType;
}

CNameNode* CNameNode::GetNext() const
{
	return m_pNext;
}

// Set
void CNameNode::SetNext(CNameNode *pNext)
{
	m_pNext = pNext;
}

// Stat
int CNameNode::IndexLen()
{
	/*
	* NameLen: 1 Bytes
	* Type:    1 Byte
	* Layer:   1 Byte
	* MapID:   4 Bytes
	* Name:    n Bytes
	*/

	return GetNameLen() + sizeof(ST_NameData);
}
/*************************************** ~CNameNode ***************************************/

/*************************************** CNameNodeChain ***************************************/
// Constructor and destroyer
CNameNodeChain::CNameNodeChain()
{
	m_pHead = new CNameNode;
	m_pTail = m_pHead;
	ASSERT(m_pHead != NULL);
	m_nObjNum = 0;
	m_nOffset = 0xFFFFFFFF;
}

CNameNodeChain::~CNameNodeChain()
{
	for (CNameNode *pTemp = m_pHead; pTemp != NULL;)
	{
		m_pHead = pTemp->GetNext();
		delete pTemp;
		pTemp = m_pHead;
	}
	m_nObjNum = 0;
}

// Get
CNameNode* CNameNodeChain::GetFirst() const
{
	return m_pHead->GetNext();
}

int CNameNodeChain::GetOffset() const
{
	return m_nOffset;
}

int CNameNodeChain::GetObjNum() const
{
	return m_nObjNum;
}

// Set
void CNameNodeChain::SetOffset(const int &nOffset)
{
	m_nOffset = nOffset;
}

// Insert
void CNameNodeChain::AddTail(CNameNode *pInsNode)
{
	if (pInsNode == NULL)
		return;

	m_pTail->SetNext(pInsNode);
	m_pTail = pInsNode;
	m_pTail->SetNext(NULL);
	++m_nObjNum;
}

// Stat
int CNameNodeChain::IndexLen() const
{
	int nIndexLen = 0;
	for (CNameNode *pNode = GetFirst(); pNode != NULL; pNode = pNode->GetNext())
		nIndexLen += pNode->IndexLen();

	return nIndexLen;
}

/*************************************** ~CNameNodeChain ***************************************/

/*************************************** Class City ***************************************/
CCity::CCity()
{
	m_nID = 0;
	m_nOffset = 0;
	m_nJPLen = 0;
	m_nPIJPUCLen = 0;
	m_nRdJPUCLen = 0;
	m_nPOICnt = 0;
	m_nRdCnt = 0;
	
	for (int nChIndexCount = 0; nChIndexCount < CHARACTER_INDEX_COUNT; ++nChIndexCount)
	{
		m_pbPack[nChIndexCount] = NULL;
		m_pPIJPPool[nChIndexCount] = new CJPNodeChain;
		m_pRdJPPool[nChIndexCount] = new CJPNodeChain;	
		m_ppPINamePack[nChIndexCount] = new CNameNodeChain;
		m_ppRdNamePack[nChIndexCount] = new CNameNodeChain;

		ASSERT(m_pPIJPPool[nChIndexCount] != NULL);
		ASSERT(m_pRdJPPool[nChIndexCount] != NULL);	
		ASSERT(m_ppPINamePack[nChIndexCount] != NULL);
		ASSERT(m_ppRdNamePack[nChIndexCount] != NULL);			
	}

	for(nChIndexCount = 0; nChIndexCount < CHARACTER_NEWINDEX_COUNT; nChIndexCount++)
	{		
		for(int j = 0; j < CHARACTER_NEWINDEX_COUNT; j++)
		{			
			m_ppPINameNewPack[nChIndexCount][j] = new CNameNodeChain;
			m_ppRdNameNewPack[nChIndexCount][j] = new CNameNodeChain;
			ASSERT(m_ppPINameNewPack[nChIndexCount][j] != NULL);	
			ASSERT(m_ppRdNameNewPack[nChIndexCount][j] != NULL);
		}		
	}
}

CCity::~CCity()
{
	for (int nChIndexCount = 0; nChIndexCount < CHARACTER_INDEX_COUNT; ++nChIndexCount)
	{
		if (m_pPIJPPool[nChIndexCount] != NULL)
			delete m_pPIJPPool[nChIndexCount];

		if (m_pRdJPPool[nChIndexCount] != NULL)
			delete m_pRdJPPool[nChIndexCount];
		
		if (m_ppPINamePack[nChIndexCount] != NULL)
			delete m_ppPINamePack[nChIndexCount];

		if (m_ppRdNamePack[nChIndexCount] != NULL)
			delete m_ppRdNamePack[nChIndexCount];

		if (m_pbPack[nChIndexCount] != NULL)
			delete[] m_pbPack[nChIndexCount];		
	}

	for (nChIndexCount = 0; nChIndexCount < CHARACTER_NEWINDEX_COUNT; ++nChIndexCount)
	{
		for(int j = 0; j < CHARACTER_NEWINDEX_COUNT; j++)
		{			
			if (m_ppPINameNewPack[nChIndexCount][j] != NULL)
				delete m_ppPINameNewPack[nChIndexCount][j];		
			if (m_ppRdNameNewPack[nChIndexCount][j] != NULL)
				delete m_ppRdNameNewPack[nChIndexCount][j];	
		}
	}
}

// Get
int CCity::GetID() const
{
	return m_nID;
}

int CCity::GetOffset() const
{
	return m_nOffset;
}

int CCity::GetCLen() const
{
	return m_nCLen;
}

int CCity::GetUCLen () const
{
	return m_nUCLen;
}

int CCity::GetJPLen() const
{
	return m_nJPLen;
}

ST_PackIndex CCity::GetPackIndex(const int i)
{
	return m_ST_PackIndex[i];
}

BYTE* CCity::GetPackBuffer(const int i)
{
	return m_pbPack[i];
}

int CCity::GetPOICnt()
{
	return m_nPOICnt;
}

int CCity::GetRdCnt()
{
	return m_nRdCnt;
}

int CCity::GetSrcPIJPULen() const
{
	return m_nPIJPUCLen;
}

int CCity::GetSrcRdJPULen() const
{
	return m_nRdJPUCLen;
}

// Set
void CCity::SetID(const int &nID)
{
	m_nID = nID;
}

void CCity::SetOffset(const int &nOffset)
{
	m_nOffset = nOffset;
}

void CCity::SetCLen(const int &nCLen)
{
	m_nCLen = nCLen;
}

void CCity::SetUCLen(const int &nUCLen)
{
	m_nUCLen = nUCLen;
}

void CCity::SetJPLen(const int nJPLen)
{
	m_nJPLen = nJPLen;
}


int CCity::CharacterIndexLen()
{
	/*
	* POIOffset:	4
	* POIObjNum:	4
	* RoadOffset:	4
	* RoadObjNum:	4
	*/
	return 0x10 * CHARACTER_INDEX_COUNT/*24*/;
}


void CCity::ParseJPIndex(const BYTE *pbOldNamePack)
{

}

bool lessName( const ST_Info &m1, const ST_Info &m2 )
{
	if(strcmp(m1.szName, m2.szName) < 0)
		return true;
	else if(strcmp(m1.szName, m2.szName) == 0)
	{
		if(m1.lBreadthID < m2.lBreadthID)
			return true;
		else if(m1.lBreadthID == m2.lBreadthID)
		{
			if(m1.byLayerID < m2.byLayerID)
				return true;
		}
	}

	return false;
}

void CCity::ParseTxt(CString strDir)
{
	CString strPIFilePath, strRdFilePath;
	strPIFilePath.Format("%s\\POITxt\\%d.txt", strDir, GetID());
	strRdFilePath.Format("%s\\RdTxt\\%d.txt", strDir, GetID());
	
	if(_access(strPIFilePath.GetBuffer(0), 0) == 0)
	{
		CStdioFile pi_File(strPIFilePath, CStdioFile::modeRead);		
		char szName[256] = {0, };
		char cpBuffer[256] = {0,};
		while(pi_File.ReadString(cpBuffer, 256))
		{
			if(strlen(cpBuffer) == 2 && cpBuffer[0] == 0x0d && cpBuffer[1] == 0x0a)
				continue;

			m_nPOICnt++;
			CString strContent(cpBuffer);
			memset(cpBuffer, 0x0 , 256);
			if(strContent.GetLength() == 0)
				continue;

			ST_Info st_info;
			ASSERT(st_info.ParsePITxt(strContent));
			memset(szName, 0x0, 256);
			strcpy(szName, st_info.szName);

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

			// 得到相邻多音组合
			int nDistLen = -1;