//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TEntityField 类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TEntityField 定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TEntityField.h"
#include "TEntityFields.h"
#include "dbcfilrs.h"
#include "TchGlobalDef.h"
#include "TchGlobalFunc.h"
#include "TchPrivateGlobalFunc.h"

TEntityField::TEntityField(const TCHAR *sName,DataType type)
	: m_sName(sName),m_nType(type),m_pData(NULL)
{
	Init();
}

TEntityField::TEntityField(const TEntityField&ef)
	: m_nType(kUnknown),m_pData(NULL)
{
	(*this) = ef;
}

TEntityField::~TEntityField()
{
	Clear();
}

void TEntityField::Init()
{
	m_pData = NULL;
	switch (m_nType)
	{
	case kGroup:
		{
			m_pData = new TEntityFields;
		}
		break;
	case kString:
		{
			m_pData = tstrnew(_T(""));
		}
		break;
	case kDouble:
		{
			m_pData = new double;
		}
		break;
	case kAcGePoint2d:
		{
			m_pData = new AcGePoint2d;
		}
		break;
	case kAcGePoint3d:
		{
			m_pData = new AcGePoint3d;
		}
		break;
	case kAcGeVector2d:
		{
			m_pData = new AcGeVector2d;
		}
		break;
	case kAcGeVector3d:
		{
			m_pData = new AcGeVector3d;
		}
		break;
	case kAcGeScale3d:
		{
			m_pData = new AcGeScale3d;
		}
		break;
	case kAcDbHardOwnershipId:
		{
			m_pData = new AcDbHardOwnershipId;
		}
		break;
	case kAcDbSoftOwnershipId:
		{
			m_pData = new AcDbSoftOwnershipId;
		}
		break;
	case kAcDbHardPointerId:
		{
			m_pData = new AcDbHardPointerId;
		}
		break;
	case kAcDbSoftPointerId:
		{
			m_pData = new AcDbSoftPointerId;
		}
		break;
	case kAcDbHandle:
		{
			m_pData = new AcDbHandle;
		}
		break;
	}
}

void TEntityField::Clear()
{
	switch (m_nType)
	{
	case kGroup:
		{
			TEntityFields *pVal = (TEntityFields *)m_pData;
			delete pVal;
		}
		break;
	case kString:
		{
			TCHAR *pVal = (TCHAR *)m_pData;
			delete[] pVal;
		}
		break;
	case kDouble:
		{
			double *pVal = (double*)m_pData;
			delete pVal;
		}
		break;
	case kAcGePoint2d:
		{
			AcGePoint2d* pVal = (AcGePoint2d*)m_pData;
			delete pVal;
		}
		break;
	case kAcGePoint3d:
		{
			AcGePoint3d* pVal = (AcGePoint3d*)m_pData;
			delete pVal;
		}
		break;
	case kAcGeVector2d:
		{
			AcGeVector2d* pVal = (AcGeVector2d*)m_pData;
			delete pVal;
		}
		break;
	case kAcGeVector3d:
		{
			AcGeVector3d* pVal = (AcGeVector3d*)m_pData;
			delete pVal;
		}
		break;
	case kAcGeScale3d:
		{
			AcGeScale3d* pVal = (AcGeScale3d*)m_pData;
			delete pVal;
		}
		break;
	case kAcDbHardOwnershipId:
		{
			AcDbHardOwnershipId* pVal = (AcDbHardOwnershipId*)m_pData;
			delete pVal;
		}
		break;
	case kAcDbSoftOwnershipId:
		{
			AcDbSoftOwnershipId* pVal = (AcDbSoftOwnershipId*)m_pData;
			delete pVal;
		}
		break;
	case kAcDbHardPointerId:
		{
			AcDbHardPointerId* pVal = (AcDbHardPointerId*)m_pData;
			delete pVal;
		}
		break;
	case kAcDbSoftPointerId:
		{
			AcDbSoftPointerId* pVal = (AcDbSoftPointerId*)m_pData;
			delete pVal;
		}
		break;
	case kAcDbHandle:
		{
			AcDbHandle *pVal = (AcDbHandle*)m_pData;
			delete pVal;
		}
		break;
	}

	m_pData = NULL;
	m_sName = _T("");
	m_nType = kUnknown;
}

void TEntityField::ChangeType(DataType type)
{
	Clear();
	m_nType = type;
	Init();
}

bool TEntityField::operator >(const TEntityField&ent)const
{
	return _tcsicmp(GetName(),ent.GetName()) > 0;
}

bool TEntityField::operator ==(const TEntityField&ent)const
{
	return _tcsicmp(GetName(),ent.GetName()) == 0;
}

void TEntityField::SetData(const Adesk::Boolean& val)
{
	if (m_nType != kBoolean)
	{
		ChangeType(kBoolean);
	}

	Adesk::Boolean&data = (Adesk::Boolean&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::Int8& val)
{
	if (m_nType != kInt8)
	{
		ChangeType(kInt8);
	}

	Adesk::Int8&data = (Adesk::Int8&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::UInt8& val)
{
	if (m_nType != kUInt8)
	{
		ChangeType(kUInt8);
	}

	Adesk::UInt8&data = (Adesk::UInt8&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::Int16& val)
{
	if (m_nType != kInt16)
	{
		ChangeType(kInt16);
	}

	Adesk::Int16&data = (Adesk::Int16&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::UInt16& val)
{
	if (m_nType != kUInt16)
	{
		ChangeType(kUInt16);
	}

	Adesk::UInt16&data = (Adesk::UInt16&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::Int32& val)
{
	if (m_nType != kInt32)
	{
		ChangeType(kInt32);
	}

	Adesk::Int32&data = (Adesk::Int32&)m_pData;
	data = val;
}

void TEntityField::SetData(const Adesk::UInt32& val)
{
	if (m_nType != kUInt32)
	{
		ChangeType(kUInt32);
	}

	Adesk::UInt32&data = (Adesk::UInt32&)m_pData;
	data = val;
}

void TEntityField::SetData(TEntityFields *pVal)
{
	if (m_nType != kGroup)
	{
		ChangeType(kGroup);
	}

	if (m_pData != NULL)
	{
		TEntityFields *pVal = (TEntityFields *)m_pData;
		delete pVal;
	}

	m_pData = pVal;
}

void TEntityField::SetData(const TEntityFields &val)
{
	SetData(new TEntityFields(val));
}

void TEntityField::SetData(const TCHAR* val)
{
	if (m_nType != kString)
	{
		ChangeType(kString);
	}

	if (m_pData != NULL)
	{
		TCHAR *pVal = (TCHAR *)m_pData;
		delete[] pVal;
	}

	m_pData = tstrnew(val);
}

void TEntityField::SetData(const double& val)
{
	if (m_nType != kDouble)
	{
		ChangeType(kDouble);
	}

	double*pData = (double*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcGePoint2d& val)
{
	if (m_nType != kAcGePoint2d)
	{
		ChangeType(kAcGePoint2d);
	}

	AcGePoint2d*pData = (AcGePoint2d*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcGePoint3d& val)
{
	if (m_nType != kAcGePoint3d)
	{
		ChangeType(kAcGePoint3d);
	}

	AcGePoint3d*pData = (AcGePoint3d*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcGeVector2d& val)
{
	if (m_nType != kAcGeVector2d)
	{
		ChangeType(kAcGeVector2d);
	}

	AcGeVector2d*pData = (AcGeVector2d*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcGeVector3d& val)
{
	if (m_nType != kAcGeVector3d)
	{
		ChangeType(kAcGeVector3d);
	}

	AcGeVector3d*pData = (AcGeVector3d*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcGeScale3d& val)
{
	if (m_nType != kAcGeScale3d)
	{
		ChangeType(kAcGeScale3d);
	}

	AcGeScale3d*pData = (AcGeScale3d*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcDbHardOwnershipId& val)
{
	if (m_nType != kAcDbHardOwnershipId)
	{
		ChangeType(kAcDbHardOwnershipId);
	}

	AcDbHardOwnershipId*pData = (AcDbHardOwnershipId*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcDbSoftOwnershipId& val)
{
	if (m_nType != kAcDbSoftOwnershipId)
	{
		ChangeType(kAcDbSoftOwnershipId);
	}

	AcDbSoftOwnershipId*pData = (AcDbSoftOwnershipId*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcDbHardPointerId& val)
{
	if (m_nType != kAcDbHardPointerId)
	{
		ChangeType(kAcDbHardPointerId);
	}

	AcDbHardPointerId*pData = (AcDbHardPointerId*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcDbSoftPointerId& val)
{
	if (m_nType != kAcDbSoftPointerId)
	{
		ChangeType(kAcDbSoftPointerId);
	}

	AcDbSoftPointerId*pData = (AcDbSoftPointerId*)m_pData;
	*pData = val;
}

void TEntityField::SetData(const AcDbHandle& val)
{
	if (m_nType != kAcDbHandle)
	{
		ChangeType(kAcDbHandle);
	}

	AcDbHandle*pData = (AcDbHandle*)m_pData;
	*pData = val;
}

bool TEntityField::GetData(Adesk::Boolean& val)const
{
	if (m_nType != kBoolean)
	{
		return false;
	}

	val = (Adesk::Boolean&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::Int8& val)const
{
	if (m_nType != kInt8)
	{
		return false;
	}

	val = (Adesk::Int8&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::UInt8& val)const
{
	if (m_nType != kUInt8)
	{
		return false;
	}

	val = (Adesk::UInt8&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::Int16& val)const
{
	if (m_nType != kInt16)
	{
		return false;
	}

	val = (Adesk::Int16&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::UInt16& val)const
{
	if (m_nType != kUInt16)
	{
		return false;
	}

	val = (Adesk::UInt16&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::Int32& val)const
{
	if (m_nType != kInt32)
	{
		return false;
	}

	val = (Adesk::Int32&)m_pData;
	return true;
}

bool TEntityField::GetData(Adesk::UInt32& val)const
{
	if (m_nType != kUInt32)
	{
		return false;
	}

	val = (Adesk::UInt32&)m_pData;
	return true;
}

bool TEntityField::GetData(TEntityFields *&pVal)const
{
	if (m_nType != kGroup)
	{
		return false;
	}

	pVal = (TEntityFields*)m_pData;
	return true;
}

bool TEntityField::GetData(TEntityFields& val)const
{
	if (m_nType != kGroup)
	{
		return false;
	}

	val = *((TEntityFields*)m_pData);
	return true;
}

bool TEntityField::GetData(CString &val)const
{
	if (m_nType != kString)
	{
		return false;
	}

	val = (const TCHAR*)m_pData;
	return true;
}

bool TEntityField::GetData(double& val)const
{
	if (m_nType != kDouble)
	{
		return false;
	}

	double* pData = (double*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcGePoint2d& val)const
{
	if (m_nType != kAcGePoint2d)
	{
		return false;
	}

	AcGePoint2d* pData = (AcGePoint2d*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcGePoint3d& val)const
{
	if (m_nType != kAcGePoint3d)
	{
		return false;
	}

	AcGePoint3d* pData = (AcGePoint3d*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcGeVector2d& val)const
{
	if (m_nType != kAcGeVector2d)
	{
		return false;
	}

	AcGeVector2d* pData = (AcGeVector2d*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcGeVector3d& val)const
{
	if (m_nType != kAcGeVector3d)
	{
		return false;
	}

	AcGeVector3d* pData = (AcGeVector3d*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcGeScale3d& val)const
{
	if (m_nType != kAcGeScale3d)
	{
		return false;
	}

	AcGeScale3d* pData = (AcGeScale3d*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcDbHardOwnershipId& val)const
{
	if (m_nType != kAcDbHardOwnershipId)
	{
		return false;
	}

	AcDbHardOwnershipId* pData = (AcDbHardOwnershipId*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcDbSoftOwnershipId& val)const
{
	if (m_nType != kAcDbSoftOwnershipId)
	{
		return false;
	}

	AcDbSoftOwnershipId* pData = (AcDbSoftOwnershipId*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcDbHardPointerId& val)const
{
	if (m_nType != kAcDbHardPointerId)
	{
		return false;
	}

	AcDbHardPointerId* pData = (AcDbHardPointerId*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcDbSoftPointerId& val)const
{
	if (m_nType != kAcDbSoftPointerId)
	{
		return false;
	}

	AcDbSoftPointerId* pData = (AcDbSoftPointerId*)m_pData;
	val = *pData;
	return true;
}

bool TEntityField::GetData(AcDbHandle& val)const
{
	if (m_nType != kAcDbHandle)
	{
		return false;
	}

	AcDbHandle* pData = (AcDbHandle*)m_pData;
	val = *pData;
	return true;
}

void TEntityField::DwgIn (AcDbDwgFiler* pFiler)
{
	Clear();

	ReadString(pFiler,m_sName);

	Adesk::Int16 type;
	pFiler->readItem(&type);
	m_nType = (DataType)type;

	Init();

	switch (m_nType)
	{
	case kBoolean:
		{
			Adesk::Boolean val;
			pFiler->readBoolean(&val);
			SetData(val);
		}
		break;
	case kChar:
	case kInt8:
		{
			Adesk::Int8 val;
			pFiler->readItem(&val);
			SetData(val);
		}
		break;
	case kUInt8:
		{
			Adesk::UInt8 val;
			pFiler->readUInt8(&val);
			SetData(val);
		}
		break;
	case kInt16:
		{
			Adesk::Int16 val;
			pFiler->readInt16(&val);
			SetData(val);
		}
		break;
	case kUInt16:
		{
			Adesk::UInt16 val;
			pFiler->readUInt16(&val);
			SetData(val);
		}
		break;
	case kInt32:
		{
			Adesk::Int32 val;
			pFiler->readInt32(&val);
			SetData(val);
		}
		break;
	case kUInt32:
		{
			Adesk::UInt32 val;
			pFiler->readUInt32(&val);
			SetData(val);
		}
		break;
	case kGroup:
		{
			TEntityFields *pVal = new TEntityFields;
			pVal->DwgIn(pFiler);
			SetData(pVal);
		}
		break;
	case kString:
		{
			TCHAR *pBuffer = NULL;
			pFiler->readString(&pBuffer);
			if (pBuffer != NULL)
			{
				SetData(pBuffer);
				acdbFree(pBuffer);
			}
		}
		break;
	case kDouble:
		{
			double val;
			pFiler->readDouble(&val);
			SetData(val);
		}
		break;
	case kAcGePoint2d:
		{
			AcGePoint2d val;
			pFiler->readPoint2d(&val);
			SetData(val);
		}
		break;
	case kAcGePoint3d:
		{
			AcGePoint3d val;
			pFiler->readPoint3d(&val);
			SetData(val);
		}
		break;
	case kAcGeVector2d:
		{
			AcGeVector2d val;
			pFiler->readVector2d(&val);
			SetData(val);
		}
		break;
	case kAcGeVector3d:
		{
			AcGeVector3d val;
			pFiler->readVector3d(&val);
			SetData(val);
		}
		break;
	case kAcGeScale3d:
		{
			AcGeScale3d val;
			pFiler->readScale3d(&val);
			SetData(val);
		}
		break;
	case kAcDbHardOwnershipId:
		{
			AcDbHardOwnershipId val;
			pFiler->readHardOwnershipId(&val);
			SetData(val);
		}
		break;
	case kAcDbSoftOwnershipId:
		{
			AcDbSoftOwnershipId val;
			pFiler->readSoftOwnershipId(&val);
			SetData(val);
		}
		break;
	case kAcDbHardPointerId:
		{
			AcDbHardPointerId val;
			pFiler->readHardPointerId(&val);
			SetData(val);
		}
		break;
	case kAcDbSoftPointerId:
		{
			AcDbSoftPointerId val;
			pFiler->readSoftPointerId(&val);
			SetData(val);
		}
		break;
	case kAcDbHandle:
		{
			AcDbHandle val;
			pFiler->readAcDbHandle(&val);
			SetData(val);
		}
		break;
	}
}

void TEntityField::DwgOut(AcDbDwgFiler* pFiler) const
{
	pFiler->writeString(m_sName);
	
	Adesk::Int16 type = (Adesk::Int16)m_nType;
	pFiler->writeItem(type);

	switch (m_nType)
	{
	case kBoolean:
		{
			Adesk::Boolean val;
			GetData(val);
			pFiler->writeBoolean(val);
		}
		break;
	case kChar:
	case kInt8:
		{
			Adesk::Int8 val;
			GetData(val);
			pFiler->writeItem(val);
		}
		break;
	case kUInt8:
		{
			Adesk::UInt8 val;
			GetData(val);
			pFiler->writeUInt8(val);
		}
		break;
	case kInt16:
		{
			Adesk::Int16 val;
			GetData(val);
			pFiler->writeInt16(val);
		}
		break;
	case kUInt16:
		{
			Adesk::UInt16 val;
			GetData(val);
			pFiler->writeUInt16(val);
		}
		break;
	case kInt32:
		{
			Adesk::Int32 val;
			GetData(val);
			pFiler->writeInt32(val);
		}
		break;
	case kUInt32:
		{
			Adesk::UInt32 val;
			GetData(val);
			pFiler->writeUInt32(val);
		}
		break;
	case kGroup:
		{
			TEntityFields *pVal;
			GetData(pVal);
			pVal->DwgOut(pFiler);
		}
		break;
	case kString:
		{
			CString val;
			GetData(val);
			pFiler->writeString((const TCHAR*)val);
		}
		break;
	case kDouble:
		{
			double val;
			GetData(val);
			pFiler->writeDouble(val);
		}
		break;
	case kAcGePoint2d:
		{
			AcGePoint2d val;
			GetData(val);
			pFiler->writePoint2d(val);
		}
		break;
	case kAcGePoint3d:
		{
			AcGePoint3d val;
			GetData(val);
			pFiler->writePoint3d(val);
		}
		break;
	case kAcGeVector2d:
		{
			AcGeVector2d val;
			GetData(val);
			pFiler->writeVector2d(val);
		}
		break;
	case kAcGeVector3d:
		{
			AcGeVector3d val;
			GetData(val);
			pFiler->writeVector3d(val);
		}
		break;
	case kAcGeScale3d:
		{
			AcGeScale3d val;
			GetData(val);
			pFiler->writeScale3d(val);
		}
		break;
	case kAcDbHardOwnershipId:
		{
			AcDbHardOwnershipId val;
			GetData(val);
			pFiler->writeHardOwnershipId(val);
		}
		break;
	case kAcDbSoftOwnershipId:
		{
			AcDbSoftOwnershipId val;
			GetData(val);
			pFiler->writeSoftOwnershipId(val);
		}
		break;
	case kAcDbHardPointerId:
		{
			AcDbHardPointerId val;
			GetData(val);
			pFiler->writeHardPointerId(val);
		}
		break;
	case kAcDbSoftPointerId:
		{
			AcDbSoftPointerId val;
			GetData(val);
			pFiler->writeSoftPointerId(val);
		}
		break;
	case kAcDbHandle:
		{
			AcDbHandle val;
			GetData(val);
			pFiler->writeAcDbHandle(val);
		}
		break;
	}
}

TEntityField& TEntityField::operator = (const TEntityField&ef)
{
    AcDbDeepCloneFiler filer;
	ef.DwgOut(&filer);
    filer.seek(0L,0);
	DwgIn(&filer);

    return *this;
}

void TEntityField::DxfIn (AcDbDxfFiler* pFiler)
{
	Clear();
}

void TEntityField::DxfOut(AcDbDxfFiler* pFiler) const
{

}

const TCHAR* TEntityField::GetName()const
{
	return m_sName;
}

void TEntityField::SetName(const TCHAR* sName)
{
	m_sName = sName;
}

TEntityField::DataType TEntityField::GetDataType()const
{
	return m_nType;
}

bool TEntityField::operator< (const TEntityField&ent)const
{
	return ent > (*this);
}

bool TEntityField::operator != (const TEntityField&ent)const
{
	return !((*this) == ent);
}