#include "stdafx.h"
#include "geassign.h"
#include "acutmem.h"
#include "TDbXDataMap.h"
#include <algorithm>
#include "dbxrecrd.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define MAP_BLOCK_BEGIN		_T("TDBXDATAMAP_BLOCK_BEGIN_")
#define MAP_BLOCK_END		_T("TDBXDATAMAP_BLOCK_END_")
#define DIF_VT_PT			_T("$vector3d")					// 设置向量是在键值pszkey后增加字符串"$vector3d",与点进行区分

#define _ttof _tstof

TDbXDataMap::TDbXDataMap()
{
}

TDbXDataMap::TDbXDataMap(const TDbXDataMap& datamap)
{
	if (this != &datamap)
	{
		//map 互相复制
		m_xData.erase(m_xData.begin(),m_xData.end());
		m_xData.clear();
		CopyFrom(&datamap);
	}
}
//bslmodyfied2010.11.3
//
/*
struct DelStringFunc
{
	void operator () (std::pair<CString,TXData>& pairT) const
	{
		if (pairT.second.nVt == VT_BSTR ||
			pairT.second.nVt == (VT_BYREF | VT_R8 + 4) )
		{
			if (pairT.second.pszVal != NULL && pairT.second.npszLen > 0)
			{
				delete [] pairT.second.pszVal;
				pairT.second.pszVal = NULL;
				pairT.second.npszLen = 0;
			}
		}
	}
};
*/

TDbXDataMap::~TDbXDataMap()
{
	//释放 xData 是自符串的元素
//	std::for_each(m_xData.begin(),m_xData.end(),DelStringFunc());
	std::map<CString,TXData>::iterator itor;
	for (itor = m_xData.begin();itor != m_xData.end();++itor)
	{

		if (itor->second.nVt == VT_BSTR ||
			itor->second.nVt == (VT_BYREF | VT_R8 + 4) )
		{
			if (itor->second.pszVal != NULL && itor->second.npszLen > 0)
			{
				delete [] itor->second.pszVal;
				itor->second.pszVal = NULL;
				itor->second.npszLen = 0;
			}
		}		
	}
}

BOOL TDbXDataMap::SetAt( LPCTSTR pszKey,int nVal )
{
	if (pszKey != NULL)
	{
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = VT_I4;
		xdata.nVal = nVal;

		It it = m_xData.find(pszKey);
		if (it != m_xData.end())
		{
			(*it).second = xdata;
		}
		else
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,double dVal)
{
	if (pszKey != NULL)
	{
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = VT_R8;
		xdata.dVal[0] = dVal;
		
		It it = m_xData.find(pszKey);
		if (it != m_xData.end())
		{
			(*it).second = xdata;
		}
		else
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcGeDoubleArray& arVal)
{
	if (pszKey != NULL)
	{
		CString sSubKey;
		for (int i = 0;i < arVal.length();++i)
		{
			sSubKey.Format(_T("%s%d"),pszKey,i);
			SetAt(sSubKey,arVal[i]);
		}

		return TRUE;
	}

	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcGeVector3d& vt,BOOL bTransformBy)
{
	/*
	设置向量是在键值pszkey后增加字符串"$vector3d",与点进行区分
	bTransformBy标识向量是否随cad实体所变化
	*/
	if (pszKey != NULL)
	{
		CString sTmpKey = pszKey;
		sTmpKey += DIF_VT_PT;
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = (VT_BYREF | VT_R8 + 2);
		if(bTransformBy)
		{
			// 向量随cad实体变化而改变
			xdata.nVt = (VT_BYREF | VT_R8 + 3);
		}
		xdata.dVal[0] = vt.x;
		xdata.dVal[1] = vt.y;
		xdata.dVal[2] = vt.z;

		It it = m_xData.find(sTmpKey);
		if (it != m_xData.end())
		{
			(*it).second = xdata;
		}
		else
		{
			std::pair<CString,TXData> pa(sTmpKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcGePoint3d& ptGe,BOOL bTransformBy)
{
	/*
	bTransformBy标识点是否随cad实体所变化
	*/
	if (pszKey != NULL)
	{
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = VT_BYREF | VT_R8;
		if (bTransformBy)
		{
			// 点随cad实体变化而改变
			xdata.nVt = (VT_BYREF|VT_R8 + 1);
		}

		xdata.dVal[0] = ptGe.x;
		xdata.dVal[1] = ptGe.y;
		xdata.dVal[2] = ptGe.z;
	
		It it = m_xData.find(pszKey);
		if (it != m_xData.end())
		{
			(*it).second = xdata;
		}
		else
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcGePoint3dArray& arPt,BOOL bTransformBy)
{
	if (pszKey != NULL)
	{
		CString sSubKey;
		for (int i = 0;i < arPt.length();++i)
		{
			sSubKey.Format(_T("%s%d"),pszKey,i);
			SetAt(sSubKey,arPt[i],bTransformBy);
		}
		
		return TRUE;
	}
	
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcGeMatrix3d& xform)
{
	if (pszKey != NULL)
	{
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = (VT_BYREF | VT_R8 + 4);

		CString sText = _T(""),sTemp;
		for (int i = 0;i < 4;i++)
		{
			for (int j = 0;j < 4;j++)
			{
				sTemp.Format(_T("%g"),xform.entry[i][j]);
				sText += _T(",") + sTemp;
			}
		}
		sText.TrimLeft(_T(","));

		xdata.npszLen = sText.GetLength() + 1;
		xdata.pszVal = new TCHAR[xdata.npszLen];
		_tcscpy(xdata.pszVal,sText);

		It it = m_xData.find(pszKey);
		if (it != m_xData.end()) //找到
		{
			if ( (*it).second.nVt == VT_BSTR ||
				 (*it).second.nVt == (VT_BYREF | VT_R8 + 4) )
			{
				if ( (*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
				{
					delete [] (*it).second.pszVal;
				}
			}

			(*it).second = xdata;
		}
		else //未找到
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

static BOOL Script2StringArray(const CString& sScript,TCHAR tSpace,CStringArray& arTexts)
{
	//x,y,z,d,a
	int nPos = -1,nStart = 0;
	CString sText;
	
	while(TRUE)
	{
		nPos = sScript.Find(tSpace,nStart);
		if (nPos != -1)
		{
			sText = sScript.Mid(nStart,nPos - nStart);
			arTexts.Add(sText);
			nStart = nPos + 1;
		}
		else
		{
			if (nStart <= sScript.GetLength() - 1)
			{
				sText = sScript.Mid(nStart);
				arTexts.Add(sText);
			}
			
			break;
		}
	}
	return arTexts.GetSize() > 0;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcGeMatrix3d& xform) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;
			if ( xdata.nVt == (VT_BYREF | VT_R8 + 4))
			{
				CString sText = xdata.pszVal;
				CStringArray arTexts;

				Script2StringArray(sText,_T(','),arTexts);
				if (arTexts.GetSize() == 16)
				{
					for (int i = 0;i < 4;i++)
					{
						for (int j = 0;j < 4;j++)
						{
							xform.entry[i][j] = _ttof(arTexts.GetAt(i * 4 + j));
						}
					}
					return TRUE;
				}
			}
		}		
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,LPCTSTR pszValue)
{
	if (pszKey != NULL)
	{
		CString sTmp = pszValue;
		if(sTmp.GetLength() >= MAX_PATH)
			return FALSE;

		if (_tcslen(pszValue) < 0)
			return FALSE;

		TXData xdata;
		memset(&xdata,0,sizeof(xdata));

		xdata.nVt = VT_BSTR;
		xdata.npszLen = _tcslen(pszValue) + 1;
		xdata.pszVal = new TCHAR[xdata.npszLen];
		memset(xdata.pszVal,0,xdata.npszLen);
		_tcscpy(xdata.pszVal,pszValue);

		It it = m_xData.find(pszKey);
		if (it != m_xData.end())
		{
			// mcl add.2010.7.23 原来的要删除
			if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
				delete [] (*it).second.pszVal;
		
			//(*it).second = xdata;
			(*it).second.pszVal = new TCHAR[xdata.npszLen];
			memset((*it).second.pszVal,0,xdata.npszLen);
			_tcscpy((*it).second.pszVal,pszValue);

			delete [] xdata.pszVal;
			xdata.pszVal = NULL;
		}
		else
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,int iIndex,LPCTSTR pszValue)
{
	if (pszKey != NULL)
	{
		CString sKey;
		sKey.Format(_T("%s_%d"),pszKey,iIndex);
		return SetAt(sKey,pszValue);
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,int iIndex,CString &sValue)
{
	if (pszKey != NULL)
	{
		CString sKey;
		sKey.Format(_T("%s_%d"),pszKey,iIndex);
		return GetAt(sKey,sValue);
	}
	return FALSE;	
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,int iIndex,const TDbXDataMap& xDataMap)
{
	//{key | type | inf}个隔开
	CString sKey,sType,sInfo,sRecord,sText;
	sText = _T("");
	TXData xdata;
	memset(&xdata,0,sizeof(TXData));

	typedef std::map<CString,TXData>::const_iterator It;
	for (It it = xDataMap.m_xData.begin(); it != xDataMap.m_xData.end(); ++it)
	{
		xdata = (*it).second;
		sKey = (*it).first;
		sType = _T("");
		sInfo = _T("");

		switch (xdata.nVt)
		{
			case VT_I4:										// 整型
				{
					sType.Format(_T("%d"),VT_I4);
					sInfo.Format(_T("%d"),xdata.nVal);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case VT_UI4:
				{
					sType.Format(_T("%d"),VT_UI4);
					sInfo.Format(_T("%d"),xdata.nVal);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case VT_UI8:
				{
					sType.Format(_T("%d"),VT_UI8);
					sInfo.Format(_T("%d"),xdata.nVal);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case VT_R8:										// 浮点
				{
					sType.Format(_T("%d"),VT_R8);
					sInfo.Format(_T("%g"),xdata.dVal[0]);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case (VT_BYREF | VT_R8):						// 点
				{
					sType.Format(_T("%d"),(VT_BYREF | VT_R8));
					sInfo.Format(_T("%.4f,%.4f,%.4f"),xdata.dVal[0],xdata.dVal[1],xdata.dVal[2]);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case (VT_BYREF | VT_R8 + 1):					// cad变化点
				{
					sType.Format(_T("%d"),(VT_BYREF | VT_R8 + 1));
					sInfo.Format(_T("%g,%g,%g"),xdata.dVal[0],xdata.dVal[1],xdata.dVal[2]);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case (VT_BYREF | VT_R8 + 2):					// 向量
				{
					sType.Format(_T("%d"),(VT_BYREF | VT_R8 + 2));
					sInfo.Format(_T("%g,%g,%g"),xdata.dVal[0],xdata.dVal[1],xdata.dVal[2]);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case (VT_BYREF | VT_R8 + 3):					// 变化向量
				{
					sType.Format(_T("%d"),(VT_BYREF | VT_R8 + 3));
					sInfo.Format(_T("%g,%g,%g"),xdata.dVal[0],xdata.dVal[1],xdata.dVal[2]);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case (VT_BYREF | VT_R8 + 4):					// 矩阵
				{
					sType.Format(_T("%d"),VT_BYREF | VT_R8 + 4);
					sInfo.Format(_T("%s"),xdata.pszVal);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
			case VT_BSTR:									// 字符串
				{
					sType.Format(_T("%d"),VT_BSTR);
					sInfo.Format(_T("%s"),xdata.pszVal);
					sRecord.Format(_T("{%s|%s|%s}"),sKey,sType,sInfo);
					sText += sRecord;
					break;
				}
				break;
			default:
				break;
		}
	}
	if (!sText.IsEmpty())
		return SetAt(pszKey,iIndex,sText);
	return FALSE;
}

BOOL TDbXDataMap::ParseToRecords(CString& sText,CStringArray& arRecords)
{
	CString sRecord;
	int nFr = 0,nTo = 0;
	//{Key|Type|Info}...
	while(TRUE)
	{
		nFr = sText.Find(_T("{"),0);
		nTo = sText.Find(_T("}"),0);
		if (nFr == 0 && nTo > 0)
		{
			sRecord = sText.Mid(nFr,nTo + 1);
			sRecord.TrimLeft(_T("{"));
			sRecord.TrimRight(_T("}"));
			arRecords.Add(sRecord);

			if (nTo + 1 < sText.GetLength())
			{
				sRecord = sText.Mid(nTo + 1);
				sText = sRecord;
			}
			else
			{
				break;
			}
		}
		else
		{
			break;
		}
	}
	return arRecords.GetSize() > 0;
}

BOOL TDbXDataMap::ExtractRecord(CString& sRecord,CString& sKey,CString& sType,CString& sInfo)
{
	//Key|int|Info
	int nFr = sRecord.Find(_T("|"),0);
	if (nFr != -1)
	{
		CString sTemp;
		sKey = sRecord.Mid(0,nFr);
		if (nFr + 1 < sRecord.GetLength())
		{
			sTemp = sRecord.Mid(nFr + 1);
			sRecord = sTemp;

			nFr = sRecord.Find(_T("|"),0);
			if (nFr != -1)
			{
				sType = sRecord.Mid(0,nFr);
				if (nFr + 1 < sRecord.GetLength())
				{
					sInfo = sRecord.Mid(nFr + 1);
					return TRUE;
				}
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::StringToAcGePoint3d(CString& sText,AcGePoint3d& ptGe)
{
	//x,y,z
	CString sX,sY,sZ;

	int nFr = sText.Find(_T(","),0);
	if (nFr != -1)
	{
		CString sTemp;
		sX = sText.Mid(0,nFr);
		if (nFr + 1 < sText.GetLength())
		{
			sTemp = sText.Mid(nFr + 1);
			sText = sTemp;

			nFr = sText.Find(_T(","),0);
			if (nFr != -1)
			{
				sY = sText.Mid(0,nFr);
				if (nFr + 1 < sText.GetLength())
				{
					sZ = sText.Mid(nFr + 1);
					ptGe.set(_ttof(sX),_ttof(sY),_ttof(sZ));
					return TRUE;
				}
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::StringToAcGeVector3d(CString& sText,AcGeVector3d& vt)
{
	//x,y,z
	AcGePoint3d ptGe;
	if (StringToAcGePoint3d(sText,ptGe))
	{
		vt = ptGe.asVector();
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,int iIndex,TDbXDataMap& xDataMap)
{
	CString sKey,sType,sInfo,sText,sRecord;
	AcGePoint3d ptGe;
	AcGeVector3d vt;
	BOOL bSuccess = FALSE;
	AcDbObjectId id;
	TXData xDat;

	if (GetAt(pszKey,iIndex,sText))
	{
		sText.TrimLeft();
		sText.TrimRight();

		if (sText.GetLength() > 1)
		{
			CStringArray arRecords;
			bSuccess = ParseToRecords(sText,arRecords);
			
			for (int i = 0;i < arRecords.GetSize();i++)
			{
				sRecord = arRecords.GetAt(i);
				if (ExtractRecord(sRecord,sKey,sType,sInfo))
				{
					int nVt = _ttoi(sType);
					switch (nVt)
					{
						case VT_I4:										// 整型
							{
								xDataMap.SetAt(sKey,_ttoi(sInfo));
								break;
							}
						case VT_UI4:
							{
								id.setFromOldId((INT_PTR)_ttoi(sInfo));
								xDataMap.SetAt(sKey,id);
								break;
							}
						case VT_UI8:
							{
								id.setFromOldId((INT_PTR)_ttoi(sInfo));
								xDataMap.SetAt(sKey,id,FALSE);
								break;
							}
						case VT_R8:										// 浮点
							{
								xDataMap.SetAt(sKey,_ttof(sInfo));
								break;
							}
						case (VT_BYREF | VT_R8):						// 点
							{
								if (StringToAcGePoint3d(sInfo,ptGe))
								{
									xDataMap.SetAt(sKey,ptGe);
								}
								break;
							}
						case (VT_BYREF | VT_R8 + 1):					// cad变化点
							{
								if (StringToAcGePoint3d(sInfo,ptGe))
								{
									xDataMap.SetAt(sKey,ptGe,TRUE);
								}
								break;
							}
						case (VT_BYREF | VT_R8 + 2):					// 向量
							{
								if (StringToAcGeVector3d(sInfo,vt))
								{
									sKey.Replace(DIF_VT_PT,_T(" "));
									sKey.TrimRight();
									xDataMap.SetAt(sKey,vt);
								}
								break;
							}
						case (VT_BYREF | VT_R8 + 3):					// 变化向量
							{
								if (StringToAcGeVector3d(sInfo,vt))
								{
									sKey.Replace(DIF_VT_PT,_T(" "));
									sKey.TrimRight();
									xDataMap.SetAt(sKey,vt,TRUE);
								}
								break;
							}
						case (VT_BYREF | VT_R8 + 4):					//矩阵
							{
								memset(&xDat,0,sizeof(TXData));
								xDat.npszLen = sInfo.GetLength() + 1;
								xDat.pszVal = new TCHAR[xDat.npszLen];
								_tcscpy(xDat.pszVal,sInfo);
								xDataMap.SetAt(sKey,xDat);
								delete [] xDat.pszVal;
								break;
							}
						case VT_BSTR:									// 字符串
							{
								xDataMap.SetAt(sKey,sInfo);
								break;
							}
							break;
						default:
							break;
					}
				}
				else
				{
					//按照常规处理
					xDataMap.SetAt(pszKey,iIndex,sText);
					bSuccess = TRUE;
				}
			}
		}
		else
		{
			//按照常规处理
			xDataMap.SetAt(pszKey,iIndex,sText);
			bSuccess = TRUE;
		}
	}
	return bSuccess;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const AcDbObjectId& id,BOOL bIsSoft)
{
	if (pszKey != NULL)
	{
		TXData xdata;
		memset(&xdata,0,sizeof(xdata));
		xdata.nVt = VT_UI4;
		if (!bIsSoft) xdata.nVt = VT_UI8;
		xdata.nVal = id.asOldId();
		It it = m_xData.find(pszKey);
		if (it != m_xData.end())
		{
			(*it).second = xdata;
		}
		else
		{
			std::pair<CString,TXData> pa(pszKey,xdata);
			m_xData.insert(pa);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::SetAt(LPCTSTR pszKey,const TXData& XData)
{
	if (pszKey != NULL)
	{
		It it = m_xData.find(pszKey);
		if (it != m_xData.end()) //找到
		{
			if ( (*it).second.nVt == XData.nVt ) //判断类型相同
			{
				if ( (*it).second.nVt == VT_BSTR ||
					 (*it).second.nVt == (VT_BYREF | VT_R8 + 4) ) //字符串特殊处理
				{
					// mcl changed to below 2010.7.23 
// 					if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL) //清空原来的
// 					{
// 						delete [] (*it).second.pszVal;
// 					}

					// 重新分配空间赋值
					if (XData.npszLen > 0 && XData.pszVal != NULL)
					{
						if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL) //清空原来的
							delete [] (*it).second.pszVal;

						(*it).second = XData;
						(*it).second.pszVal = new TCHAR[XData.npszLen];
						memset((*it).second.pszVal,0,XData.npszLen);
						_tcscpy((*it).second.pszVal,XData.pszVal);
					}
				}
				else
				{
					(*it).second = XData;
				}
			}
		}
		else
		{
			if (XData.nVt == VT_BSTR ||
				XData.nVt == (VT_BYREF | VT_R8 + 4))
			{
				SetAt(pszKey,XData.pszVal);
			}
			else
			{
				std::pair<CString,TXData> pa(pszKey,XData);
				m_xData.insert(pa);
			}
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,TXData& XData)
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			XData = (*it).second;
			return TRUE;
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,int& nVal) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if (xdata.nVt == VT_I4)
			{
				nVal = (int)xdata.nVal;
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,double& dVal) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if (xdata.nVt == VT_R8)
			{
				dVal = xdata.dVal[0];
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcGeDoubleArray& arVal) const
{
	arVal.setLogicalLength(0);
	if (pszKey != NULL)
	{
		CString sSubKey;
		double dVal;

		int nIndex = 0;
		sSubKey.Format(_T("%s%d"),pszKey,nIndex++);
		while(GetAt(sSubKey,dVal))
		{
			arVal.append(dVal);
			sSubKey.Format(_T("%s%d"),pszKey,nIndex++);
		}
	}

	return (arVal.length() > 0);
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcGeVector3d& vt) const
{
	/*
	由于设置向量是将键值pszkey后增加字符串"$vector3d",
	故获取向量时在键值pszkey后增加字符串"$vector3d"
	*/
	if (pszKey != NULL)
	{
		CString sTmpKey = pszKey;
		sTmpKey += DIF_VT_PT;
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(sTmpKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if ((xdata.nVt == (VT_BYREF | VT_R8) + 2)
				|| (xdata.nVt == ((VT_BYREF | VT_R8) + 3)))
			{
				vt.x = xdata.dVal[0];
				vt.y = xdata.dVal[1];
				vt.z = xdata.dVal[2];
				
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcGePoint3d& ptGe) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if ( (xdata.nVt == (VT_BYREF | VT_R8))
				|| (xdata.nVt == (VT_BYREF | VT_R8 + 1)))
			{
				ptGe.x = xdata.dVal[0];
				ptGe.y = xdata.dVal[1];
				ptGe.z = xdata.dVal[2];
				
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcGePoint3dArray& arPt) const
{
	arPt.setLogicalLength(0);
	if (pszKey != NULL)
	{
		CString sSubKey;
		AcGePoint3d pt;
		
		int nIndex = 0;
		sSubKey.Format(_T("%s%d"),pszKey,nIndex++);
		while(GetAt(sSubKey,pt))
		{
			arPt.append(pt);
			sSubKey.Format(_T("%s%d"),pszKey,nIndex++);
		}
	}
	
	return (arPt.length() > 0);
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,CString &sValue) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey)) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if (xdata.nVt == VT_BSTR ||
				xdata.nVt == (VT_BYREF | VT_R8 + 4) )
			{
				sValue = xdata.pszVal;
				return TRUE;
			}
		}
	}
	return FALSE;	
}

BOOL TDbXDataMap::GetAt(LPCTSTR pszKey,AcDbObjectId& id) const
{
	if (pszKey != NULL)
	{
		std::map<CString,TXData>::const_iterator it;
		if ((it = m_xData.find(pszKey) ) != m_xData.end())
		{
			TXData xdata = (*it).second;

			if (xdata.nVt == VT_UI4 ||
				xdata.nVt == VT_UI8)
			{
				id.setFromOldId(xdata.nVal);
				return TRUE;
			}
		}
	}
	return FALSE;	
}

BOOL TDbXDataMap::HasKey(LPCTSTR pszKey,int& nVt)
{
	if (pszKey != NULL)
	{
		CString sTmpKey = pszKey;
		sTmpKey += DIF_VT_PT;

		if (m_xData.find(pszKey) != m_xData.end())
		{
			TXData xdata = m_xData[pszKey];
			nVt = xdata.nVt;
			return TRUE;
		}
		else if( m_xData.find(sTmpKey) != m_xData.end())
		{
			TXData xdata = m_xData[sTmpKey];
			nVt = xdata.nVt;
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	return FALSE;
}

void TDbXDataMap::Empty()
{
	m_xData.clear();
}

BOOL TDbXDataMap::RemoveAt(LPCTSTR pszKey)
{
	if (pszKey != NULL)
	{
		CString sTmpKey = pszKey;
		sTmpKey += DIF_VT_PT;
		It it = m_xData.find(pszKey);
		It it1 = m_xData.find(sTmpKey);
		if (it != m_xData.end())
		{
			if ( (*it).second.nVt == VT_BSTR ||
				 (*it).second.nVt == (VT_BYREF | VT_R8 + 4)  )
			{
				if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
				{
					delete [] (*it).second.pszVal;
				}
				(*it).second.pszVal = NULL;
			}
			m_xData.erase(it);
			//m_xData.clear();
			return TRUE;
		}
		else if(it1 != m_xData.end())
		{
			if ( (*it1).second.nVt == VT_BSTR ||
				 (*it1).second.nVt == (VT_BYREF | VT_R8 + 4) )
			{
				if ((*it1).second.pszVal != NULL)
				{
					delete [] (*it1).second.pszVal;
				}
				(*it1).second.pszVal = NULL;
			}
			m_xData.erase(it1);
			//m_xData.clear();
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	return FALSE;	
}

BOOL TDbXDataMap::RemoveAt(LPCTSTR pszKey,int nIndex)
{
	if (pszKey != NULL)
	{
		CString sKey;
		sKey.Format(_T("%s_%d"),pszKey,nIndex);
		return RemoveAt(sKey);
	}
	return FALSE;	
}

TDbXDataMap& TDbXDataMap::operator = (const TDbXDataMap& srcMap)
{
	if (this != &srcMap)
	{
		//map 互相复制
		m_xData.erase(m_xData.begin(),m_xData.end());
		m_xData.clear();
		CopyFrom(&srcMap);
	}
	return *this;
}

BOOL TDbXDataMap::CopyFrom(const TDbXDataMap* pSrc)
{
	TDbXDataMap* pTDbXDataMap = (TDbXDataMap*) pSrc;
	if(pTDbXDataMap != NULL && this != pSrc)
	{
		//map 互相复制
		//m_xData = pSrc->m_xData; 

		m_xData.erase(m_xData.begin(),m_xData.end());
		m_xData.clear();

		typedef std::map<CString,TXData>::const_iterator It;
		for (It it = pSrc->m_xData.begin();it != pSrc->m_xData.end();it++)
		{
			if ( (*it).second.nVt == VT_BSTR ||
				 (*it).second.nVt == (VT_BYREF | VT_R8 + 4 ))
			{
				SetAt( (*it).first,(*it).second);
			}
			else
			{
				m_xData.insert( (*it) );
			}
		}
		return TRUE;
	}
	return FALSE;
}

TDbXDataMap::It TDbXDataMap::Begin()
{
	return m_xData.begin();
}

TDbXDataMap::ItC TDbXDataMap::Begin() const
{
	return m_xData.begin();
}

BOOL TDbXDataMap::GetNext(It& it,TXData& xData)
{
	if (it != m_xData.end())
	{
		xData = (*it).second;
		++it;

		return TRUE;
	}
	return FALSE;
}

BOOL TDbXDataMap::GetNext(ItC& it,TXData& xData) const
{
	if (it != m_xData.end())
	{
		xData = (*it).second;
		++it;

		return TRUE;
	}
	return FALSE;
}

TDbXDataMap::It TDbXDataMap::End()
{
	return m_xData.end();
}

TDbXDataMap::ItC TDbXDataMap::End() const
{
	return m_xData.end();
}

Acad::ErrorStatus TDbXDataMap::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	if (pFiler == NULL) return Acad::eInvalidInput;
	
	TXData xdata;
	int nVt = -1;
	AcGePoint3d ptVal;
	AcGeVector3d vt;
	AcDbObjectId id;
	
	pFiler->writeString(AcDb::kDxfXTextString, MAP_BLOCK_BEGIN);
	
	typedef std::map<CString,TXData>::const_iterator It;
	for (It it = m_xData.begin(); it != m_xData.end(); ++it)
	{
		xdata = (*it).second;
		nVt = xdata.nVt;
		pFiler->writeString(AcDb::kDxfXdAsciiString, (LPCTSTR)(*it).first);
		pFiler->writeInt32(AcDb::kDxfXdInteger32, nVt);
		
		switch (nVt)
		{
		case VT_I4:										// 整型
			pFiler->writeInt32(AcDb::kDxfXdInteger32, (int)xdata.nVal);
			break;
		case VT_UI4:									//s id
			id.setFromOldId(xdata.nVal);
			pFiler->writeObjectId(AcDb::kDxfSoftPointerId,id);
			break;
		case VT_UI8:									//h id
			id.setFromOldId(xdata.nVal);
			pFiler->writeObjectId(AcDb::kDxfHardPointerId,id);
			break;
		case VT_R8:										// 浮点
			pFiler->writeDouble(AcDb::kDxfXdReal, xdata.dVal[0]);
			break;
		case (VT_BYREF | VT_R8):						// 点
			ptVal.x = xdata.dVal[0];
			ptVal.y = xdata.dVal[1];
			ptVal.z = xdata.dVal[2];
			pFiler->writePoint3d(AcDb::kDxfXdXCoord, ptVal);
			break;
		case (VT_BYREF | VT_R8 + 1):					// cad变化点
			ptVal.x = xdata.dVal[0];
			ptVal.y = xdata.dVal[1];
			ptVal.z = xdata.dVal[2];
			pFiler->writePoint3d(AcDb::kDxfXdWorldXCoord, ptVal);
			break;
		case (VT_BYREF | VT_R8 + 2):					// 向量
			vt.x = xdata.dVal[0];
			vt.y = xdata.dVal[1];
			vt.z = xdata.dVal[2];			
			pFiler->writeVector3d(AcDb::kDxfXdXCoord, vt);
			break;
		case (VT_BYREF | VT_R8 + 3):					// 变化向量
			vt.x = xdata.dVal[0];
			vt.y = xdata.dVal[1];
			vt.z = xdata.dVal[2];			
			pFiler->writeVector3d(AcDb::kDxfXdWorldXDir, vt);
			break;
		case (VT_BYREF | VT_R8 + 4):					// 矩阵
			pFiler->writeString(AcDb::kDxfXdAsciiString, (LPCTSTR)xdata.pszVal);
			break;
		case VT_BSTR:									// 字符串
			pFiler->writeString(AcDb::kDxfXdAsciiString, (LPCTSTR)xdata.pszVal);
			break;
		default:
			break;
		}
	}
	pFiler->writeString(AcDb::kDxfXTextString, MAP_BLOCK_END);

	return Acad::eOk;
}

Acad::ErrorStatus TDbXDataMap::dxfInFields(AcDbDxfFiler* pFiler)
{
	if (pFiler == NULL) return Acad::eInvalidInput;
	
	BOOL bFinded = FALSE;
	long nVt = 0;
	TCHAR* pszKey = NULL;
	TCHAR* pszVal = NULL;
	AcGePoint3d ptVal;
	AcGeVector3d vt;
	CString sKey,sTag;

	struct resbuf rb;
	while ((pFiler->readItem(&rb)) == Acad::eOk)
	{
		if(rb.restype == AcDb::kDxfXdAsciiString)
		{
			sTag = rb.resval.rstring;
			if (sTag.CompareNoCase(MAP_BLOCK_BEGIN) == 0)
			{
				bFinded = TRUE;
				break;
			}
		}
	}
	if (!bFinded) return Acad::eOk;
	
	int nMapUnitIndex = 0;
	AcDbObjectId id;
	while ((pFiler->readItem(&rb)) == Acad::eOk)
	{
		nMapUnitIndex++;
		if(nMapUnitIndex == 1)
		{
			if(rb.restype == AcDb::kDxfXdAsciiString)
			{
				sKey = rb.resval.rstring;
				continue;
			}
		}
		else
		{
			nMapUnitIndex = 0;
		}

		nVt = rb.restype;
		
		switch (nVt)
		{
		case VT_I4:										// 整型
			SetAt(sKey,rb.resval.rlong);
			break;
		case VT_UI4:									//s id
		
			#ifdef _WIN64
				id.setFromOldId(rb.resval.mnInt64);
			#else	
				id.setFromOldId(rb.resval.rlong);
			#endif

			SetAt(sKey,id);
			break;
		case VT_UI8:									//h id

			#ifdef _WIN64
				id.setFromOldId(rb.resval.mnInt64);
			#else	
				id.setFromOldId(rb.resval.rlong);
			#endif

			SetAt(sKey,id,FALSE);
			break;
		case VT_R8:										// 浮点
			SetAt(sKey,rb.resval.rreal);
			break;
		case (VT_BYREF | VT_R8):						// 点
			SetAt(sKey, asPnt3d(rb.resval.rpoint));
			break;
		case (VT_BYREF | VT_R8 + 1):					// 变化点
			SetAt(sKey, asPnt3d(rb.resval.rpoint),TRUE);
			break;
		case (VT_BYREF | VT_R8 + 2):					// 向量	
			sKey.Replace(DIF_VT_PT,_T(" "));
			sKey.TrimRight();
			SetAt(sKey, asPnt3d(rb.resval.rpoint));
			break;
		case (VT_BYREF | VT_R8 + 3):					// cad变化向量
			sKey.Replace(DIF_VT_PT,_T(" "));
			sKey.TrimRight();
			SetAt(sKey, asPnt3d(rb.resval.rpoint),TRUE);
			break;
		case (VT_BYREF | VT_R8 + 4):					//矩阵
			SetAt(sKey, rb.resval.rstring);
			break;
		case VT_BSTR:									// 字符串
			SetAt(sKey, rb.resval.rstring);
			break;
		default:
			break;
		}
	}
	return Acad::eOk;
}

// 增加 clone 的 xdatamap 的关系复制维护lfy 2011-12-6
void TDbXDataMap::BeginCloneXlation(TDbXDataMap* pMapClone,AcDbIdMapping& idMap) const
{
	assert(pMapClone != NULL);

	AcDbObjectId id;
	TXData xdata;
	AcDbIdPair idpair;

	typedef std::map<CString,TXData>::const_iterator IT;
	for (IT it = m_xData.begin();it != m_xData.end();it++)
	{
		xdata = (*it).second;
		switch (xdata.nVt)
		{
		case VT_UI4:
			{
				id.setFromOldId(xdata.nVal);
				idpair.setKey(id);
				if ( idMap.compute(idpair) )
				{
					pMapClone->SetAt((*it).first,idpair.value(),TRUE);
				}
			}
			break;
		case VT_UI8:
			{
				id.setFromOldId(xdata.nVal);
				idpair.setKey(id);
				if ( idMap.compute(idpair) )
				{
					pMapClone->SetAt((*it).first,idpair.value(),FALSE);
				}
			}
			break;
		default:
			break;
		}
	}
}

Acad::ErrorStatus TDbXDataMap::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	if (pFiler != NULL)
	{
		TXData xdata;
		int nVt = -1;
		AcGePoint3d ptVal;
		AcGeVector3d vt;
		AcDbSoftPointerId id;

		pFiler->writeString(MAP_BLOCK_BEGIN);
		
		typedef std::map<CString,TXData>::const_iterator It;
		for (It it = m_xData.begin(); it != m_xData.end(); ++it)
		{
			xdata = (*it).second;
			nVt = xdata.nVt;
			pFiler->writeString((LPCTSTR)(*it).first);
			pFiler->writeInt32(nVt);

			switch (nVt)
			{
			case VT_I4:										// 整型
				pFiler->writeInt32((int)xdata.nVal);
				break;
			case VT_UI4:
				id.setFromOldId(xdata.nVal);
				pFiler->writeSoftPointerId(id);
				break;
			case VT_UI8:
				id.setFromOldId(xdata.nVal);
				pFiler->writeHardPointerId(id);
				break;
			case VT_R8:										// 浮点
				pFiler->writeDouble(xdata.dVal[0]);
				break;
			case (VT_BYREF | VT_R8):						// 点
			case (VT_BYREF | VT_R8 + 1):
				ptVal.x = xdata.dVal[0];
				ptVal.y = xdata.dVal[1];
				ptVal.z = xdata.dVal[2];
				pFiler->writePoint3d(ptVal);
				break;
			case (VT_BYREF | VT_R8 + 2):					// 向量
			case (VT_BYREF | VT_R8 + 3):
				vt.x = xdata.dVal[0];
				vt.y = xdata.dVal[1];
				vt.z = xdata.dVal[2];			
				pFiler->writeVector3d(vt);
				break;
			case (VT_BYREF | VT_R8 + 4):					//矩阵
				pFiler->writeString(xdata.pszVal);
				break;
			case VT_BSTR:									// 字符串
				pFiler->writeString(xdata.pszVal);
				break;
			default:
				break;
			}
		}
		pFiler->writeString(MAP_BLOCK_END);
		return Acad::eOk;
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbXDataMap::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler == NULL) return Acad::eInvalidInput;

	BOOL bFinded = FALSE;
	Adesk::Int32 nVt = 0;
	TXData xdata;
	TCHAR* pszKey = NULL;
	TCHAR* pszVal = NULL;
	AcGePoint3d ptVal;
	AcGeVector3d vt;
	CString sKey,sTag;
	
	m_xData.erase(m_xData.begin(),m_xData.end());
	m_xData.clear();

	while ((pFiler->readString(&pszVal)) == Acad::eOk)
	{
		sTag = pszVal;
		if (pszVal != NULL) acutDelString(pszVal);
		if (sTag.CompareNoCase(MAP_BLOCK_BEGIN) == 0)
		{
			bFinded = TRUE;
			break;
		}
	}
	if (!bFinded) return Acad::eOk;

	while ((pFiler->readString(&pszKey)) == Acad::eOk)
	{
		sKey = pszKey;
		if (pszKey != NULL) acutDelString(pszKey);
		if (sKey.CompareNoCase(MAP_BLOCK_END) == 0)
		{
			break;
		}

		pFiler->readInt32(&nVt);
		xdata.nVt = (int)nVt;
		AcDbSoftPointerId id;
		AcDbHardPointerId idh;

		switch (nVt)
		{
		case VT_I4:										// 整型
			pFiler->readInt32(&nVt);
			xdata.nVal = (int)nVt;
			SetAt(sKey, (int)xdata.nVal);
			break;
		case VT_UI4:
			pFiler->readSoftPointerId(&id);
			SetAt(sKey,id);
			break;
		case VT_UI8:
			pFiler->readHardPointerId(&idh);
			SetAt(sKey,idh,FALSE);
			break;
		case VT_R8:										// 浮点
			pFiler->readDouble(&xdata.dVal[0]);
			SetAt(sKey, xdata.dVal[0]);
			break;
		case (VT_BYREF | VT_R8):						// 点
			pFiler->readPoint3d(&ptVal);
			SetAt(sKey, ptVal);
			break;
		case (VT_BYREF | VT_R8 + 1):					// cad变化点
			pFiler->readPoint3d(&ptVal);
			SetAt(sKey, ptVal, TRUE);
			break;
		case (VT_BYREF | VT_R8 + 2):					// 向量	
			pFiler->readVector3d(&vt);
			sKey.Replace(DIF_VT_PT,_T(" "));
			sKey.TrimRight();
			SetAt(sKey, vt);
			break;
		case (VT_BYREF | VT_R8 + 3):					// cad变化向量
			pFiler->readVector3d(&vt);
			sKey.Replace(DIF_VT_PT,_T(" "));
			sKey.TrimRight();
			SetAt(sKey, vt, TRUE);
			break;
		case (VT_BYREF | VT_R8 + 4):					//矩阵
			pszVal = NULL;
			pFiler->readString(&pszVal);
			SetAt(sKey, pszVal);
			if (pszVal != NULL) acutDelString(pszVal);			
			break;
		case VT_BSTR:									// 字符串
			pszVal = NULL;
			pFiler->readString(&pszVal);
			SetAt(sKey, pszVal);
			if (pszVal != NULL) acutDelString(pszVal);
			break;
		default:
			break;
		}
	}
	return Acad::eOk;
}

// bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::XDMap2Resbuf(LPCTSTR pszApp, struct resbuf*& pRb,BOOL bXRecord)
{
	if(pszApp == NULL || m_xData.empty()) return FALSE;

	struct resbuf* pTemp = NULL;

	// 链表头
	if (!bXRecord)
	{  
		// 扩展数据需要链表头
		pTemp = acutNewRb(AcDb::kDxfRegAppName);
		acutNewString(pszApp,pTemp->resval.rstring);
		pRb = pTemp;
	}
	
	AcDbObjectId id;
	ads_name adsName;
	struct resbuf* pTempNext = NULL;
	typedef std::map<CString,TXData>::const_iterator IT;
	// 遍历map
	for(IT iter = m_xData.begin(); iter != m_xData.end(); iter++)
	{
		pTempNext = acutNewRb(AcDb::kDxfXdAsciiString);
		acutNewString(iter->first, pTempNext->resval.rstring);
		if (pRb == NULL)
		{
			pRb = pTempNext;
		}
		else
		{
			pTemp->rbnext = pTempNext;			
		}

		pTemp = pTempNext;
		pTempNext = NULL;
		switch (iter->second.nVt)
		{
		case VT_I4:										// 整型
			pTempNext = acutNewRb(AcDb::kDxfXdInteger32);
			pTempNext->resval.rlong = (long)iter->second.nVal;
			pTemp->rbnext = pTempNext;
			break;
		/*---------------------------------------------------------------------------------------
		Extended data (xdata) is created by applications written with ObjectARX? or AutoLISP?
		and can be added to any object. Xdata consists of a linked list of resbufs 
		used by the application. (AutoCAD maintains the information but doesn't use it.)
		The data is associated with a DXF group code in the range of 1000 to 1071.
		*/
		/*
		so someguy want save id to an entity xdata ,must save as kDxfXdHandle
		kDxfXdHandle is same as string;
		*/
		case VT_UI4:									//s id not support xdata
			id.setFromOldId(iter->second.nVal);
			acdbGetAdsName(adsName,id);
			if(bXRecord)
				pTempNext = acutBuildList(AcDb::kDxfSoftPointerId, adsName, 0);
			else
			{
				pTempNext =  acutNewRb(AcDb::kDxfXdHandle);
				TCHAR szHandleStr[19];
				memset(szHandleStr,0,sizeof(szHandleStr) );
				id.handle().getIntoAsciiBuffer(szHandleStr);
#if ADS < 17
				acutNewString(szHandleStr, pTempNext->resval.rstring);
#else
				acutNewString(pTempNext->resval.rstring, (int)(_tcslen(szHandleStr) + 1));
				_tcscpy(pTempNext->resval.rstring,szHandleStr);
#endif
			}
			pTemp->rbnext = pTempNext;
			break;
		case VT_UI8:									//h id not support xdata
			id.setFromOldId(iter->second.nVal);
			acdbGetAdsName(adsName,id);
			if(bXRecord)
				pTempNext = acutBuildList(AcDb::kDxfHardPointerId, adsName, 0);
			else
			{
				pTempNext =  acutNewRb(AcDb::kDxfXdHandle);
				TCHAR szHandleStr[19];
				memset(szHandleStr,0,sizeof(szHandleStr) );
				id.handle().getIntoAsciiBuffer(szHandleStr);
#if ADS < 17
				acutNewString(szHandleStr, pTempNext->resval.rstring);
#else
				acutNewString(pTempNext->resval.rstring, (int)(_tcslen(szHandleStr) + 1));
				_tcscpy(pTempNext->resval.rstring,szHandleStr);
#endif
			}
			pTemp->rbnext = pTempNext;
			//---------------------------------------------------------------------------------
			break;
		case VT_BSTR:									// 字符串
			pTempNext = acutNewRb(AcDb::kDxfXdAsciiString);
			acutNewString(iter->second.pszVal, pTempNext->resval.rstring);
			pTemp->rbnext = pTempNext;
			break;
		case VT_R8:										// 浮点型
			pTempNext = acutNewRb(AcDb::kDxfXdReal);
			pTempNext->resval.rreal = iter->second.dVal[0];
			pTemp->rbnext = pTempNext;
			break;
		case (VT_BYREF | VT_R8):						// 点
			pTempNext = acutNewRb(AcDb::kDxfXdXCoord);
			pTempNext->resval.rpoint[0] = iter->second.dVal[0];
			pTempNext->resval.rpoint[1] = iter->second.dVal[1];
			pTempNext->resval.rpoint[2] = iter->second.dVal[2];
			pTemp->rbnext = pTempNext;
			break;
		case (VT_BYREF | VT_R8 + 1):					// 随cad实体变化的点
			pTempNext = acutNewRb(AcDb::kDxfXdWorldXCoord);
			pTempNext->resval.rpoint[0] = iter->second.dVal[0];
			pTempNext->resval.rpoint[1] = iter->second.dVal[1];
			pTempNext->resval.rpoint[2] = iter->second.dVal[2];
			pTemp->rbnext = pTempNext;
			break;
		case (VT_BYREF | VT_R8 + 2):					// 向量
			pTempNext = acutNewRb(AcDb::kDxfXdXCoord);
			pTempNext->resval.rpoint[0] = iter->second.dVal[0];
			pTempNext->resval.rpoint[1] = iter->second.dVal[1];
			pTempNext->resval.rpoint[2] = iter->second.dVal[2];
			pTemp->rbnext = pTempNext;
			break;
		case (VT_BYREF | VT_R8 + 3):					// 随cad实体变化的向量
			pTempNext = acutNewRb(AcDb::kDxfXdWorldXDir);
			pTempNext->resval.rpoint[0] = iter->second.dVal[0];
			pTempNext->resval.rpoint[1] = iter->second.dVal[1];
			pTempNext->resval.rpoint[2] = iter->second.dVal[2];
			pTemp->rbnext = pTempNext;
			break;
		case (VT_BYREF | VT_R8 + 4):					// 矩阵
			pTempNext = acutNewRb(AcDb::kDxfXdAsciiString);
			acutNewString(iter->second.pszVal, pTempNext->resval.rstring);
			pTemp->rbnext = pTempNext;
			break;
		default:
			break;
		}
		pTemp = pTempNext;
		pTempNext = NULL;
	}
	return (pRb != NULL);
}

// bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::Resbuf2XDMap(struct resbuf* pRb,BOOL bXRecord,AcDbDatabase* pDb)
{
	if(pRb == NULL) return FALSE;
	m_xData.clear();

	struct resbuf* pTemp = pRb;

	// 跳过扩展数据头 扩展数据
	if (!bXRecord)
	{
		pTemp = pRb->rbnext;
	}

	AcDbObjectId id;
	int nMapUnitIndex = 1;
	TXData xData;
	CString sTemp;
	while (pTemp != NULL)
	{
		if (nMapUnitIndex == 1)
		{
			// skey键值
			if (pTemp->restype == AcDb::kDxfXdAsciiString)
			{
				sTemp = pTemp->resval.rstring;
				nMapUnitIndex++;
			}
		}
		else
		{
			// value
			switch (pTemp->restype)
			{
			case AcDb::kDxfXdAsciiString:								// 字符串		
				xData.nVt = VT_BSTR;
				xData.npszLen = _tcslen(pTemp->resval.rstring) + 1;
				xData.pszVal = new TCHAR[xData.npszLen];
				_tcscpy(xData.pszVal,pTemp->resval.rstring);
				nMapUnitIndex++;
				break;
			case AcDb::kDxfXdInteger32:									// 整型
				xData.nVt = VT_I4;
				xData.nVal = pTemp->resval.rlong;
				nMapUnitIndex++;
				break;
			/*---------------------------------------------------------------------------------------
			Extended data (xdata) is created by applications written with ObjectARX? or AutoLISP?
			and can be added to any object. Xdata consists of a linked list of resbufs 
			used by the application. (AutoCAD maintains the information but doesn't use it.)
			The data is associated with a DXF group code in the range of 1000 to 1071.
			*/
			case AcDb::kDxfSoftPointerId:								//s id not support xdata
				acdbGetObjectId(id, pTemp->resval.rlname);
				xData.nVt = VT_UI4;
				xData.nVal = id.asOldId();
				nMapUnitIndex++;
				break;
			case AcDb::kDxfHardPointerId:								//h id not support xdata
				acdbGetObjectId(id, pTemp->resval.rlname);
				xData.nVt = VT_UI8;
				xData.nVal = id.asOldId();
				nMapUnitIndex++;
				break;
			//--------------------------------------------------------------------------------------
			case AcDb::kDxfXdHandle:									//handle for xdata
				{
					AcDbHandle handle(pTemp->resval.rstring);
					if (pDb == NULL)
						pDb = acdbCurDwg();
					if (pDb != NULL)
					{
						if ( Acad::eOk == pDb->getAcDbObjectId(id,false,handle) )
						{
							xData.nVt = VT_UI4;
							xData.nVal = id.asOldId();
							nMapUnitIndex++;
						}
					}
				}
				break;
			case AcDb::kDxfXdReal:										// 浮点型
				xData.nVt = VT_R8;
				xData.dVal[0] = pTemp->resval.rreal;
				nMapUnitIndex++;
				break;
			case AcDb::kDxfXdXCoord:									// 点 向量
				xData.nVt = (VT_BYREF | VT_R8);
				xData.dVal[0] = pTemp->resval.rpoint[0];
				xData.dVal[1] = pTemp->resval.rpoint[1];
				xData.dVal[2] = pTemp->resval.rpoint[2];
				nMapUnitIndex++;

				if(sTemp.Find(DIF_VT_PT) >= 0)
				{
					// 向量
					xData.nVt = (VT_BYREF | VT_R8 + 2);
				}
				break;
			case AcDb::kDxfXdWorldXCoord:								// 随cad实体变化的点
				xData.nVt = (VT_BYREF | VT_R8 + 1);
				xData.dVal[0] = pTemp->resval.rpoint[0];
				xData.dVal[1] = pTemp->resval.rpoint[1];
				xData.dVal[2] = pTemp->resval.rpoint[2];
				nMapUnitIndex++;
				break;
			case AcDb::kDxfXdWorldXDir:									// 随cad实体变化的向量
				xData.nVt = (VT_BYREF | VT_R8 + 3);
				xData.dVal[0] = pTemp->resval.rpoint[0];
				xData.dVal[1] = pTemp->resval.rpoint[1];
				xData.dVal[2] = pTemp->resval.rpoint[2];
				nMapUnitIndex++;
				break;
			default:
				break;
			}
		}
		
		if(nMapUnitIndex > 2)
		{
			// 插入一套 skey value
			std::pair<CString,TXData> pa(sTemp,xData);
			m_xData.insert(pa);
			nMapUnitIndex = 1;
		}
		pTemp = pTemp->rbnext;
	}
	return !m_xData.empty();
}

//支持扩展数据的4个方法
// 根据实体指针插入链表 bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::Write(AcDbObject* pEnt, LPCTSTR pszApp, BOOL bXRecord)
{
	if (pEnt == NULL || pszApp == NULL) return FALSE;

	// 根据map生成链表
	struct resbuf* pRb = NULL;
	if (!XDMap2Resbuf(pszApp ,pRb ,bXRecord)) return FALSE;
	Acad::ErrorStatus eStat = Acad::eOutOfMemory;

	if (!bXRecord)
	{
		// 扩展数据
		struct resbuf* pTmpRb = pEnt->xData(pszApp);
		if (pTmpRb != NULL)
		{
			// 存在清空
			struct resbuf* pTmp = acutNewRb(AcDb::kDxfRegAppName);
			pEnt->setXData(pTmp);
			acutRelRb(pTmpRb);
			acutRelRb(pTmp);
		}

		// 注册扩展数据链表
		acdbRegApp(pszApp);	
		eStat = pEnt->setXData(pRb);
		acutRelRb(pRb);
		return (eStat == Acad::eOk);
	}

	// 扩展词典
	AcDbObjectId dictObjId, xrecObjId;
	pEnt->createExtensionDictionary();
	dictObjId = pEnt->extensionDictionary();

	// 打开扩展词典指针
	AcDbDictionary* pDict = NULL;
	if (Acad::eOk != acdbOpenObject(pDict, dictObjId, AcDb::kForWrite))
	{
		if (pRb != NULL) acutRelRb(pRb);
		return FALSE;
	}
	
	AcDbXrecord* pXrec = NULL;
	if (pDict->has(pszApp))
	{
		// 存在此扩展词典 获取扩展词典指针
		AcDbObject* pObj = NULL;
		pDict->getAt(pszApp,pObj,AcDb::kForWrite);
		if(pObj != NULL)
		{
			pXrec = AcDbXrecord::cast(pObj);
			if(pXrec != NULL)
			{
				// 重新设置扩展词典
				pXrec->setFromRbChain(*pRb);
			}
			pObj->close();
		}
		pDict->close();
	}
	else
	{
		// 不存在此扩展词典	
		pXrec = new AcDbXrecord;
		eStat = pXrec->setFromRbChain(*pRb);
		pDict->setAt(pszApp,pXrec,xrecObjId);
		pXrec->close();
		pDict->close();
	}

	acutRelRb(pRb);
	return (eStat == Acad::eOk);
}

// 根据实体id插入链表 bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::Write(const AcDbObjectId& id,LPCTSTR pszApp,BOOL bXRecord)
{
	if(pszApp == NULL) return FALSE;

	AcDbEntity * pEnt = NULL;
	BOOL bWriteIdXData = FALSE;
	if(Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
	{
		// 根据实体指针设置链表
		bWriteIdXData = Write(pEnt,pszApp,bXRecord);

		pEnt->close();
	}
	return bWriteIdXData;
}

// bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::Read(AcDbObject* pEnt,LPCTSTR pszApp,BOOL bXRecord)
{
	if(pEnt == NULL || pszApp == NULL) return FALSE;
	struct resbuf* pRb = NULL;
	BOOL bResbuf2XDmap = FALSE;

	if (!bXRecord)
	{
		// 扩展数据
		pRb = pEnt->xData(pszApp);
		if(pRb == NULL) return FALSE;
		bResbuf2XDmap = Resbuf2XDMap(pRb,bXRecord,pEnt->database());

		acutRelRb(pRb);
		return bResbuf2XDmap;
	}

	// 获取扩展数据(词典)id
	AcDbObjectId dictObjId, xrecObjId;
	dictObjId = pEnt->extensionDictionary();
	if (dictObjId.isNull())
	{
		// 没有扩展数据
		return FALSE;
	}

	// 打开扩展词典实体
	AcDbDictionary* pDict = NULL;
	if (Acad::eOk != acdbOpenObject(pDict, dictObjId, AcDb::kForRead))
	{
		return FALSE;
	}

	AcDbXrecord *pXrec = NULL;	
	AcDbObject* pObj = NULL;
	// 获取扩展数据链表
	if (Acad::eOk == pDict->getAt(pszApp,pObj,AcDb::kForRead))
	{
		pXrec = AcDbXrecord::cast(pObj);
		if (pXrec != NULL)
		{
			pXrec->rbChain(&pRb);
			if (pRb != NULL)
			{
				bResbuf2XDmap = Resbuf2XDMap(pRb,bXRecord,pEnt->database());
				acutRelRb(pRb);
			}
		}
		pObj->close();
	}
	else
	{
		// 获取链表失败
		pDict->close();
		return FALSE;
	}
	pDict->close();

	return bResbuf2XDmap;
}

// bXRecord = fase 操作扩展数据 bXRecord = true 操作扩展词典
BOOL TDbXDataMap::Read(const AcDbObjectId& id,LPCTSTR pszApp,BOOL bXRecord)
{
	AcDbEntity * pEnt = NULL;
	BOOL bReadIdXData = FALSE;
	if(Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
	{
		bReadIdXData = Read(pEnt,pszApp,bXRecord);
		pEnt->close();
	}
	return bReadIdXData;
}