#if !defined(__KTOBJSMARTPTR_H__)
#define __KTOBJSMARTPTR_H__

// Description:
// 类 CKTObjSmartPtr 是AcDbObject派生的类的智能指针类，使用它可以管理类对象的
// 打开、创建、关闭、删除、比较等操作。
// 使用时，对于常用类由于做了宏定义只需在类名后跟上Ptr作为新类名声明对象使用
// 对于新类则按照模板类声明方式声明对象使用
// 如：AcDbLinePtr pLine;	// 常用类时只需AcDbLine+Ptr作为类名声明对象
//     CKTObjSmartPtr<CMyCustomObject> pMyObject;	// 新类声明对象
//	   KT_OBJ_SMARTPTR_TYPEDEF(CMyObject);			// 在派生类CMyObject的.h末尾加
//													其他地方就可直接使用
// Company: Kingtouch Software Corporation. Copyright 2002-2005
// Author: WangYongguang
// Date: 2002.05.01

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "KTCadDebug.h"

template <typename T> class CKTObjSmartPtr
{
public:
	// 默认构造函数
	CKTObjSmartPtr(BOOL bAutoRelease = TRUE)	// 是否设为退出自动关闭/删除
	{
		m_bAutoRelease = bAutoRelease;
		m_pObj = NULL;
	}

	// 构造函数
	CKTObjSmartPtr(AcDbObject* pObj,			// 管理的对象, 对象必须是所声明的管理类
				BOOL bAutoRelease = TRUE)		// 是否设为退出自动关闭/删除
	{
		KTASSERT(pObj != NULL);

		m_bAutoRelease = bAutoRelease;
		m_pObj = T::cast(pObj);

		KTASSERT(m_pObj != NULL);
	}

	// 构造函数
	CKTObjSmartPtr(AcDbObjectId idObj,			// 管理对象ID, 对象必须是所声明的管理类
					AcDb::OpenMode mode,		// 打开对象方式
					BOOL bOpenErased = FALSE,	// 是否打开删除了的对象
					BOOL bAutoRelease = TRUE)	// 是否设为退出自动关闭/删除
	{
		m_bAutoRelease = bAutoRelease;
		m_pObj = NULL;

		Open(idObj, mode, bOpenErased);
	}

	// 构造函数
	CKTObjSmartPtr(ads_name adsName,			// 管理对象ads name, 对象必须是所声明的管理类
					AcDb::OpenMode mode,		// 打开对象方式
					BOOL bOpenErased = FALSE,	// 是否打开删除了的对象
					BOOL bAutoRelease = TRUE)	// 是否设为退出自动关闭/删除
	{
		m_bAutoRelease = bAutoRelease;
		m_pObj = NULL;

		Open(adsName, mode, bOpenErased);
	}

	// 析构函数
	virtual ~CKTObjSmartPtr()
	{
		if (m_bAutoRelease)
			Release();
	}

	// 打开管理对象
	Acad::ErrorStatus Open(AcDbObjectId idObj,			// 管理对象ID, 对象必须是所声明的管理类
							AcDb::OpenMode mode,		// 打开对象方式
							BOOL bOpenErased = FALSE)	// 是否打开删除了的对象
	{
		KTASSERT(idObj.isValid());

		if (m_bAutoRelease)
			Release();
		else
			Detach();

		AcDbObject* pObj = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pObj, idObj, mode, (bOpenErased == TRUE));
		if (es != Acad::eOk)
			return es;

		m_pObj = T::cast(pObj);
		KTASSERT(m_pObj != NULL);

		if (m_pObj == NULL)
		{
			es = Acad::eNotThatKindOfClass;
			if (pObj->close() != Acad::eOk)
				acrx_abort(_T("Failed AcDbObject::close()"));
		}

		return es;
	}

	// 打开管理对象
	Acad::ErrorStatus Open(ads_name adsName,			// 管理对象ID, 对象必须是所声明的管理类
							AcDb::OpenMode mode,		// 打开对象方式
							BOOL bOpenErased = FALSE)	// 是否打开删除了的对象
	{
		AcDbObjectId idObj;
		Acad::ErrorStatus es = acdbGetObjectId(idObj, adsName);
		if (Acad::eOk == es)
		{
			es = Open(idObj, mode, bOpenErased);
		}
		return es;
	}

	// 关闭管理对象
	Acad::ErrorStatus Close()
	{
		if (m_pObj == NULL)
			return Acad::eNullObjectPointer;

		if (!m_pObj->objectId().isValid())
			return Acad::eNotInDatabase;

		Acad::ErrorStatus es = m_pObj->close();
		KTASSERT(es == Acad::eOk);

		m_pObj = NULL;

		return es;
	}

	// 复制对象, 是否加入数据库状态和原对象一致
	T* Clone()
	{
		if (m_pObj == NULL)
			return NULL;

		T* pObj = NULL;
		if (m_pObj->objectId().isValid())
			CKTCadUtility::DeepCloneObject((AcDbObject*&)pObj, m_pObj);
		else
			CKTCadUtility::CloneObject((AcDbObject*&)pObj, m_pObj);

		return pObj;
	}

	// 创建新管理对象
	Acad::ErrorStatus CreateObject()
	{
		if (m_bAutoRelease)
			Release();
		else
			Detach();

		m_pObj = new T;
		KTCHECK(m_pObj != NULL);

		return Acad::eOk;
	}

	// 删除管理对象
	Acad::ErrorStatus DeleteObject()
	{
		if (m_pObj == NULL)
			return Acad::eNullObjectPointer;

		if (m_pObj->objectId().isValid())
			return Acad::eAlreadyInDb;

		delete m_pObj;
		m_pObj = NULL;

		return Acad::eOk;
	}

	// 清除管理对象
	Acad::ErrorStatus Release()
	{
		if (m_pObj == NULL)
			return Acad::eOk;

		if (m_pObj->objectId().isValid())
			m_pObj->close();
		else
			delete m_pObj;

		m_pObj = NULL;

		return Acad::eOk;
	}

	// 关联管理对象
	Acad::ErrorStatus Attach(AcDbObject* pObj,		// 管理的对象, 对象必须是所声明的管理类
						BOOL bAutoRelease = TRUE)	// 是否设为退出自动关闭/删除
	{
		KTASSERT(pObj != NULL);

		if (m_bAutoRelease)
			Release();
		else
			Detach();

		m_bAutoRelease = bAutoRelease;
		m_pObj = T::cast(pObj);
		KTASSERT(m_pObj != NULL);

		return ((m_pObj != NULL) ? Acad::eOk : Acad::eNotThatKindOfClass);
	}

	// 取消关联管理对象
	T* Detach()
	{
		T* pObj = m_pObj;
		m_pObj = NULL;
		return pObj;
	}

	// 取得管理对象
	T* GetObject()
	{
		return m_pObj;
	}

	// 管理对象是否有效
	BOOL IsValid()
	{
		return (m_pObj != NULL);
	}

	// 取得创建标志
	BOOL IsCreated()
	{
		return (m_pObj != NULL && !m_pObj->objectId().isValid());
	}

	// 取得自动关闭标志
	BOOL IsAutoRelease()
	{
		return m_bAutoRelease;
	}

	// 设置自动关闭标志
	void SetAutoRelease(BOOL bEnable)
	{
		m_bAutoRelease = bEnable;
	}

	// 加入块表记录
	Acad::ErrorStatus AddToBlockTableRecord(AcDbBlockTableRecord* pRec)	// 块表记录
	{
		KTASSERT(pRec != NULL);

		if (m_pObj == NULL)
			return Acad::eNullObjectPointer;

		if (m_pObj->objectId().isValid())
			return Acad::eAlreadyInDb;

		if (!m_pObj->isKindOf(AcDbEntity::desc()))
			return Acad::eNotThatKindOfClass;

		return pRec->appendAcDbEntity((AcDbEntity*)m_pObj);
	}

	// 加入块表记录
	Acad::ErrorStatus AddToBlockTableRecord(LPCTSTR pszBlock = NULL,	// 块名, 默认为模型空间
											AcDbDatabase* pDb = NULL)	// 数据库名, 默认为当前数据库
	{
		if (m_pObj == NULL)
			return Acad::eNullObjectPointer;

		if (m_pObj->objectId().isValid())
			return Acad::eAlreadyInDb;

		if (!m_pObj->isKindOf(AcDbEntity::desc()))
			return Acad::eNotThatKindOfClass;

		return CKTCadUtility::AddToBlockTableRecord(m_pObj, pszBlock, pDb);
	}

	// 加入词典
	Acad::ErrorStatus AddToDictionary(LPCTSTR pszKey,		// 键值
									AcDbDictionary* pDict)	// 词典
	{
		KTASSERT(pDict != NULL);

		if (m_pObj == NULL)
			return Acad::eNullObjectPointer;

		if (m_pObj->objectId().isValid())
			return Acad::eAlreadyInDb;

		AcDbObjectId idObj;
		return pDict->setAt(pszKey, m_pObj, idObj);
	}

	// 设置管理对象, 管理对象默认将自动关闭
	template <typename K> CKTObjSmartPtr& operator=(K* pObj)
	{
		KTASSERT(pObj != NULL);

		if (m_bAutoRelease)
			Release();
		else
			Detach();

		m_pObj = T::cast(pObj);
		KTASSERT(m_pObj != NULL);

		return (*this);
	}

	// 管理对象设空
	CKTObjSmartPtr& operator=(int iNull)
	{
		KTASSERT(iNull == NULL);

		if (m_bAutoRelease)
			Release();
		else
			Detach();

		return (*this);
	}

	// 操作符T*
	operator T*() const
	{
		return m_pObj;
	}

	// 操作符T*&
	operator T*&()
	{
		return m_pObj;
	}

	// 操作符AcDbObject*&
	operator AcDbObject*&() const
	{
		return (AcDbObject*&)m_pObj;
	}

	// 操作符AcDbEntity*&
	operator AcDbEntity*&() const
	{
		KTASSERT(T::desc() != NULL);
		KTASSERT(T::desc()->isDerivedFrom(AcDbEntity::desc()));
		return (AcDbEntity*&)m_pObj;
	}

	// 操作符&
	T* operator&() const
	{
		return m_pObj;
	}

	// 操作符&
	T*& operator&()
	{
		return m_pObj;
	}

	// 操作符->
	T* operator->()
	{
		KTASSERT(m_pObj != NULL);
		return m_pObj;
	}

	// 操作符bool
	operator bool()
	{ 
		return (m_pObj != NULL);
	}

	// 操作符==
	bool operator==(T* pObj)
	{
		return (m_pObj == pObj);
	}

	// 操作符==
	bool operator==(const CKTObjSmartPtr& pObj)
	{
		return (m_pObj == pObj.m_pObj);
	}

	// 操作符==, 必须和NULL比较
	bool operator==(int iNull)
	{
		KTASSERT(iNull == NULL);
		return (m_pObj == NULL);
	}

	// 操作符!=
	bool operator!=(T* pObj)
	{
		return !(operator==(pObj));
	}

	// 操作符!=
	bool operator!=(const CKTObjSmartPtr& pObj)
	{
		return !(operator==(pObj));
	}

	// 操作符!=, 必须和NULL比较
	bool operator!=(int iNull)
	{
		return !(operator==(iNull));
	}

protected:
	// 自动关闭/删除标志
	BOOL	m_bAutoRelease;
	// 管理对象
	T*		m_pObj;
};

// 操作符==
template <typename T> bool operator==(T* pObj, CKTObjSmartPtr<T>& pObjPtr)
{
	return (pObjPtr == pObj);
}

// 操作符==, 必须和NULL比较
template <typename T> bool operator==(int iNull, CKTObjSmartPtr<T>& pObj)
{
	return (pObj == NULL);
}

// 操作符!=
template <typename T> bool operator!=(T* pObj, CKTObjSmartPtr<T>& pObjPtr)
{
	return (pObjPtr != pObj);
}

// 操作符!=, 必须和NULL比较
template <typename T> bool operator!=(int iNull, CKTObjSmartPtr<T>& pObj)
{
	return (pObj != NULL);
}

#define KT_OBJ_SMARTPTR_TYPEDEF(OBJTYPE) typedef CKTObjSmartPtr<OBJTYPE> OBJTYPE##Ptr

KT_OBJ_SMARTPTR_TYPEDEF(AcDbObject);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbDictionary);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbGroup);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbProxyObject);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbXrecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLayout);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPlotSettings);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbSymbolTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbViewTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbViewportTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBlockTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbDimStyleTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLayerTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLinetypeTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRegAppTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbTextStyleTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbUCSTable);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbSymbolTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbViewportTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbViewTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBlockTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbDimStyleTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLayerTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLinetypeTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRegAppTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbTextStyleTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbUCSTableRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbEntity);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBlockReference);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbMInsertBlock);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbFace);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbFaceRecord);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbFcf);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbFrame);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbHatch);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbImage);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbMline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbMText);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPoint);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPolyFaceMesh);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPolygonMesh);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbProxyEntity);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbShape);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbSolid);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbText);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbAttribute);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbAttributeDefinition);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbViewport);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbVertex);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb2dVertex);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb3dPolylineVertex);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPolyFaceMeshVertex);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPolygonMeshVertex);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBlockBegin);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBlockEnd);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbSequenceEnd);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb3dSolid);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbBody);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRegion);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbCurve);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb2dPolyline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb3dPolyline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbArc);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbCircle);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbEllipse);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLeader);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbLine);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbPolyline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRay);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbSpline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbXline);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb2LineAngularDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDb3PointAngularDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbAlignedDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbDiametricDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbOrdinateDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRadialDimension);
KT_OBJ_SMARTPTR_TYPEDEF(AcDbRotatedDimension);

#endif // !defined(__KTOBJSMARTPTR_H__)