template.h

SQLBig5BugTool 宽字符操作问题

// **********************************************************************
//
// Copyright (c) 2004
// All Rights Reserved
//
// Author: Wu yongmin
// Created:	2004/11/03   0:19
//
// **********************************************************************

#ifndef _TQ_TEMPLATE_H_
#define _TQ_TEMPLATE_H_


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

#include <vector>
#include <map>
//#include "BaseCode.h"


//////////////////////////////////////////////////////////////////////
// 自动指针模板
//////////////////////////////////////////////////////////////////////
template <class T> struct policy_delete
{
	void destroy(T*& p) { SAFE_DELETE (p); }
};

template <class T> struct policy_release
{
	void destroy(T*& p) { SAFE_RELEASE (p); }
};


template < class T, class DestroyPolicy = policy_delete<T> >
class CMyAutoPtr : DestroyPolicy
{
public:
	typedef T element_type;
	explicit CMyAutoPtr(T* P = 0)
		: m_bOwns(P != 0), m_ptr(P) {}

	CMyAutoPtr(const CMyAutoPtr<T, DestroyPolicy>& Y)
		: m_bOwns(Y.m_bOwns), m_ptr(Y.release()) {}

	CMyAutoPtr<T, DestroyPolicy>& operator=(const CMyAutoPtr<T, DestroyPolicy>& Y)
	{
		if (this != &Y)
		{
			if (m_ptr != Y.get())
			{
				if (m_bOwns)
					this->destroy(m_ptr);

				m_bOwns = Y.m_bOwns; 
			}
			else if (Y.m_bOwns)
				m_bOwns = true;

			m_ptr = Y.release(); 
		}

		return (*this); 
	}

	CMyAutoPtr<T, DestroyPolicy>& operator=(T* P)
	{
		if (P != m_ptr)
		{
			if (m_bOwns)
				this->destroy(m_ptr);

			m_bOwns = true;
			m_ptr	= P;
		}

		return (*this); 
	}

	~CMyAutoPtr()	{ if (m_bOwns) this->destroy(m_ptr); }

	T& operator*() const	{ return (*get()); }
	T* operator->() const	{ return (get()); }
	operator T*() const		{ return (m_ptr); }
	T* get() const			{ return (m_ptr); }
	T* release() const		{ ((CMyAutoPtr<T, DestroyPolicy> *)this)->m_bOwns = false; return (m_ptr); }
	
private:
	bool	m_bOwns;
	T*		m_ptr;
};


//////////////////////////////////////////////////////////////////////
// 智能指针模板
//////////////////////////////////////////////////////////////////////
typedef std::map<void*, unsigned long> MAP_POINTER;

template <class T> 
class CMySmartPtr {
public:
    CMySmartPtr(T* p_=0) 
		: p(p_) { this->AddRef(p); }

    CMySmartPtr(const CMySmartPtr<T>& p_)  
		: p((T*)p_)	{ this->AddRef(p); }

    ~CMySmartPtr(void) 
		{ this->Release(p); }

	operator ==(T* p_) const { return (p == p_); }
	operator ==(CMySmartPtr<T>& p_) const { return (p == (T*)p_); }

	operator !=(T* p_) const { return (p != p_); }
	operator !=(CMySmartPtr<T>& p_) const { return (p != (T*)p_); }
	
    operator T*(void) const
		{ return p; }

    T& operator *(void)	const
		{ return *p; }
    T* operator ->(void) const
		{ return p; }

    CMySmartPtr& operator =(CMySmartPtr<T>& p_)
		{ return operator =((T *) p_); }
    CMySmartPtr& operator =(T* p_) 
		{ if (p != p_) { if (p) Release(p); p = p_; if (p) AddRef(p); } return *this; }

private:
    T* p;

private:
	static void	AddRef(void* p_)
	{
		if (!p_) 
			return;
		
		MAP_POINTER::iterator iter = s_setPointer.find(p_);
		if (iter == s_setPointer.end())
			s_setPointer[p_] = 1;
		else
			s_setPointer[p_] = (*iter).second+1;
	}

	static void	Release(void* p_)
	{
		if (!p_)
			return;

		MAP_POINTER::iterator iter = s_setPointer.find(p_);
		IF_NOT (iter != s_setPointer.end())
		{
			unsigned long ref = (*iter).second;
			IF_OK (ref >= 1)
			{
				ref--;
				s_setPointer[p_] = ref;

				if (ref <= 0)
				{
					s_setPointer.erase(iter);
					SAFE_DELETE (p_);
				}				
			}
		}
	}

	static MAP_POINTER	s_setPointer;
};

template <class T>
MAP_POINTER	CMySmartPtr<T>::s_setPointer;


//////////////////////////////////////////////////////////////////////
struct DESTROY_DELETE {};
struct DESTROY_RELEASE {};
struct OWNER_TRUE {};
struct OWNER_FALSE {};


//////////////////////////////////////////////////////////////////////
// 单类型对象集, KEY 为 OBJID 类型
//////////////////////////////////////////////////////////////////////

template<class T>
class CMultiTypeObjSet
{
public:
	CMultiTypeObjSet() {}
	virtual ~CMultiTypeObjSet() { this->DelAll(); }

public:	
	void	BeginEnum	(void)	{  }
	T*		EnumObj		(void)	{ 
			return NULL;
	}

	int	GetAmount	(void) const	{ return 0; }

	T* GetObj	(OBJID idObj, int nType) const
	{

		return NULL;
	}

	void AddObj	(T* pObj)
	{	
	}

	void DelObj	(OBJID idObj, int nType) {  }	
	void DelAll	(void) {  }

	void RemoveObj	(OBJID idObj, int nType)	
	{ 
	}

	void RemoveAll	(void)	{ }

protected:

};

/*
//////////////////////////////////////////////////////////////////////
// 标准数据模板类，注意做key的字段必须是无符号整形数, T 为表字段枚举定义
template < typename T >
class CMyDbData
{
public:
	CMyDbData(IMyDatabase& db, const char* pszTable, const char* pszKey) 
		: m_db(db), m_pszTable(pszTable), m_pszKey(pszKey), m_pRecord(NULL) {}
	virtual ~CMyDbData() { SAFE_RELEASE(m_pRecord); }
	
	bool CreateRecord	(OBJID id)
	{
		CMyString strSQL("SELECT * FROM %s WHERE %s=%u LIMIT 1", 
			m_pszTable, m_pszKey, id);
		m_pRecord = m_db.CreateRecord(strSQL);
		IF_NOT (m_pRecord)
			return false;
		return true;
	}
	
	bool CreateRecord	(IMyRecordset& res)
	{
		m_pRecord = res.CreateRecord();
		IF_NOT (m_pRecord)
			return false;
		return true;
	}
	
	bool MakeRecord	(OBJID id = 0)
	{
		m_pRecord = m_db.MakeRecord(m_pszTable, id);
		IF_NOT (m_pRecord)
			return false;
		return true;
	}
	
	void SaveRecord		(bool bAsyn = true) { IF_OK (m_pRecord) m_pRecord->Update(bAsyn); }
	void DeleteRecord	(void) 
	{
		IF_NOT (m_pRecord)
			return;
		
		CMyString strSQL("DELETE FROM %s WHERE %s=%u LIMIT 1", 
			m_pszTable, m_pszKey, (unsigned)m_pRecord->Key());
		m_db.ExecuteAsyncSQL(strSQL);
	}
	
	IMyData& Data(T idx) { ASSERT(m_pRecord); return m_pRecord->Field((int)idx); }
	
private:
	IMyDatabase&	m_db;
	IMyRecord*	m_pRecord;
	
	const char* m_pszTable;
	const char* m_pszKey;
};


//////////////////////////////////////////////////////////////////////
// 数据库记录集模板, IMyRecordSet的浅封装，用于只读的数据库记录集, T 为表的字段枚举
// 支持多线程读取, 注意KEY字段必须是DWORD类型
template < typename T >
class CConstDbDataSet
{
public:
	CConstDbDataSet() : m_dwLastKey(0) {}
	virtual ~CConstDbDataSet() {}

	BOOL Create	(const char* pszSQL, IMyDatabase& rDb)
	{
		IF_NOT (pszSQL)
			return FALSE;

		m_pRcdSet = rDb.CreateRecordset(pszSQL);
		if (!m_pRcdSet)
			return FALSE;

		for (DWORD i = 0; i < m_pRcdSet->RecordCount(); ++i)
		{
			DWORD dwKey = m_pRcdSet->Key();
			m_setIdx[dwKey] = i;
		}

		return TRUE;
	}

	int	GetDataAmount (void) const { return m_pRcdSet ? m_pRcdSet->RecordCount() : 0; }
	const IMyData& GetDataByIndex (int idxRcd, T idxField) 
	{
		CMySingleLock lock(m_cs);

		m_pRcdSet->Move(idxRcd);
		m_dwLastKey = m_pRcdSet->Key();
		return m_pRcdSet->Field((int)idxField);
	}

	const IMyData& GetData (OBJID id, T idxField) 
	{
		CMySingleLock lock(m_cs);
		
		if (m_dwLastKey == id)
			return m_pRcdSet->Field((int)idxField);
		else
		{
			std::map< DWORD, int >::const_iterator iter = m_setIdx.find(id);
			IF_NOT (iter != m_setIdx.end())
				iter = m_setIdx.begin();
			
			m_pRcdSet->Move((*iter).second);
			m_dwLastKey = m_pRcdSet->Key();
			return m_pRcdSet->Field((int)idxField);
		}
	}

private:
	CMyAutoPtr< IMyRecordset, policy_release< IMyRecordset > > m_pRcdSet;
	std::map< DWORD, int >	m_setIdx;
	DWORD m_dwLastKey;
	CMyCriticalSection m_cs;
};
*/



#endif // _TQ_TEMPLATE_H_