#ifndef __QLObjPtr
#define __QLObjPtr

template <class T>
class AFX_EXT_CLASS _NoAddRefReleaseOnCQLObjPtr : public T
{
	private:
		long AddRef();
		long Release();
};

/////////////////////////////////////////////
// CQLObjPtr
// 
// ÖÇÄÜÖ¸Õ룬×Ô¶¯AddRefÓëRelease
// _NoAddRefReleaseOnCOIObjPtr
// ÖÇÄÜÖ¸Õë·ÀÖ¹µ÷ÓÃAddRefÓëRelease
// Ptr>Release(); Ó¦¸ÃΪPtr.Release();ÓÉÕâ¸öÀàÀ´±£Ö¤²»»á³öÏÖ
/////////////////////////////////////////////
template <class T>
class AFX_EXT_CLASS CQLObjPtr
{
public:
	typedef T _PtrClass;
	CQLObjPtr()
	{
		p = NULL;
	}
	CQLObjPtr(T* lp)
	{
		if ((p = lp) != NULL)
			p->AddRef();
	}
	CQLObjPtr(const CQLObjPtr<T>& lp)
	{
		if ((p = lp.p) != NULL)
			p->AddRef();
	}
	~CQLObjPtr()
	{
		if (p)
			p->Release();
	}
	long Release()
	{
		T* pTemp = p;
		if (pTemp)
		{
			p = NULL;
			return pTemp->Release();
		}

		return 0;
	}
	operator T*() const
	{
		return (T*)p;
	}
	T& operator*() const
	{
		ATLASSERT(p!=NULL);
		return *p;
	}
	//The assert on operator& usually indicates a bug.  If this is really
	//what is needed, however, take the address of the p member explicitly.
//	T** operator&()
//	{
//		ATLASSERT(p==NULL);
//		return &p;
//	}
	_NoAddRefReleaseOnCQLObjPtr<T>* operator->() const
	{
		ATLASSERT(p!=NULL);
		return (_NoAddRefReleaseOnCQLObjPtr<T>*)p;
	}
	T* operator=(T* lp)
	{
		if (lp != NULL)
			lp->AddRef();
		if (p)
			p->Release();
		p = lp;
		return lp;
	}
	T* operator=(const CQLObjPtr<T>& lp)
	{
		if (lp != NULL)
			lp.p->AddRef();
		if (p)
			p->Release();
		p = lp;
		return lp;
	}
	bool operator!() const
	{
		return (p == NULL);
	}
	bool operator<(T* pT) const
	{
		return p < pT;
	}
	bool operator==(T* pT) const
	{
		return p == pT;
	}
	// Compare two objects for equivalence
	bool IsEqualObject(T* pOther)
	{
		if ( p == pOther )
			return true;

		return false;
	}
	void Attach(T* p2)
	{
		if (p)
			p->Release();
		p = p2;
	}
	T* Detach()
	{
		T* pt = p;
		p = NULL;
		return pt;
	}
	T* p;
};

#endif // __QLObjPtr