monitor.h

一个多线程

#ifndef __monitor_h__
#define __monitor_h__
#include "UniVar.h"
#include "afxtempl.h"
class CMonitorObjectGroup;

class AFX_EXT_CLASS CMonitorObject{
	CMonitorObjectGroup * pGroup;
	int m_iStatusKeyNum;
	BOOL * m_pbChanged;
	BOOL m_bChanged;
	friend class CMonitorObjectGroup;

	public:
	void RegisterMonitor();
	CMonitorObject();
	~CMonitorObject();
	virtual void GetObjectClassName(UniVar & uv){uv="未知";};
	virtual void GetObjectName(UniVar & uv){uv="未命名";};
	virtual int GetFeatureorStatusNum(){return 0;};
	virtual void GetFeatureorStatusNameFromIdx(UniVar & uv,int idx=0){uv="类型";};
	virtual void GetFeatureorStatusValueFromIdx(UniVar & uv,int idx=0){uv="未知";};
	void SetFeatureorStatusChanged(int idx=0);
	BOOL GetFeatureorStatusChanged(int idx=0);
};

#define PRENUMBEROFOBJECT 10

class AFX_EXT_CLASS CMonitorObjectGroup
{
	CMonitorObjectGroup * m_pThis;
	int m_iNumOfObject;
	HANDLE m_hMutex;
	UniVar * m_pColumList;
	int m_iNumOfColum;
	BOOL m_bUpDateAll,m_bUpdateS;
	int m_MaxNumOfObject;
	friend class CMonitorObject;
public:
	UniVar m_uvGroupName;
	CMonitorObject * * m_pCMonitorObjectList;
	CMonitorObjectGroup(UniVar & szName){
		m_pThis=this;
		m_uvGroupName=szName;
		m_pCMonitorObjectList=NULL;
		m_iNumOfObject=0;
		m_iNumOfColum=0;
		m_pColumList=NULL;
		m_hMutex=CreateMutex(NULL,FALSE,NULL);
		m_bUpDateAll=TRUE;
		m_bUpdateS=FALSE;
		ASSERT(m_hMutex);
		m_MaxNumOfObject=PRENUMBEROFOBJECT;
		m_pCMonitorObjectList=new CMonitorObject* [m_MaxNumOfObject];
	};
	BOOL GetSUpDate(){
		if(m_bUpdateS){
			m_bUpdateS=FALSE;
			return TRUE;
		}
		return FALSE;
	}
	BOOL GetUpDate(){
		if(m_bUpDateAll){
			m_bUpDateAll=FALSE;
			m_bUpdateS=FALSE;
			return TRUE;
		}
		return FALSE;
	};
	~CMonitorObjectGroup(){
		m_pThis=NULL;
		if(m_pCMonitorObjectList)delete [] m_pCMonitorObjectList;
		if(m_pColumList)delete [] m_pColumList;
		CloseHandle(m_hMutex);
	};
	VALIDATE(CMonitorObjectGroup);
	int GetSize(){return m_iNumOfObject;};
	int GetColumNum(){return m_iNumOfColum;};
	void GetColumName(UniVar & uv,int idx){uv=m_pColumList[idx];};
	inline BOOL GetRight(DWORD dwSec=INFINITE){return (WaitForSingleObject(m_hMutex,dwSec)==WAIT_OBJECT_0);};
	inline void ReleaseRight(){ReleaseMutex(m_hMutex);};
	CMonitorObject * GetObject(int idx){return m_pCMonitorObjectList[idx];};
	void AddObject(CMonitorObject * pOb);
	void RemoveObject(CMonitorObject *pOb);
};

class AFX_EXT_CLASS CMonitorGroupManager
{
public:
	CArray<CMonitorObjectGroup *,CMonitorObjectGroup *> m_pGroupArray;
	HANDLE m_hMutex;
	UniVar m_uvManagerName;
	CMonitorGroupManager(UniVar & szManager){
		m_hMutex=CreateMutex(NULL,FALSE,NULL);
		ASSERT(m_hMutex);
		m_uvManagerName=szManager;
	};
	~CMonitorGroupManager(){
		for(int i=0;i<m_pGroupArray.GetSize();i++){
			delete m_pGroupArray[i];
		}
		CloseHandle(m_hMutex);
	};
	int GetGroupCount(){
		return m_pGroupArray.GetSize();
	};
	CMonitorObjectGroup * GetGroupFromIdx(int idx){
		CMonitorObjectGroup * pO=NULL;
		WaitForSingleObject(m_hMutex,INFINITE);
		if(idx<m_pGroupArray.GetSize())
			pO=m_pGroupArray[idx];
		ReleaseMutex(m_hMutex);
		return pO;
	}
	CMonitorObjectGroup * AddObject(CMonitorObject *pOb);
};

class AFX_EXT_CLASS CMonitorManager 
{
public:
	CArray<CMonitorGroupManager *,CMonitorGroupManager *> m_pGroupArray;
	HANDLE m_hMutex;
	BOOL m_bUpDate;
	CMapStringToPtr m_MonitorStr;
	BOOL m_bSetMonitor;
	CMonitorManager(){
		m_hMutex=CreateMutex(NULL,FALSE,NULL);
		ASSERT(m_hMutex);
		m_bUpDate=TRUE;
		m_MonitorStr.RemoveAll();
		m_bSetMonitor=false;
	};
	~CMonitorManager(){
		for(int i=0;i<m_pGroupArray.GetSize();i++){
			delete m_pGroupArray[i];
		}
		CloseHandle(m_hMutex);
	};

	int GetManagerCount(){
		return m_pGroupArray.GetSize();
	}
	CMonitorGroupManager * GetManagerFromIdx(int idx){
		CMonitorGroupManager * pO=NULL;
		WaitForSingleObject(m_hMutex,INFINITE);
		if(idx<m_pGroupArray.GetSize())
			pO=m_pGroupArray[idx];
		ReleaseMutex(m_hMutex);
		return pO;
	};
	CMonitorObjectGroup * AddObject(CMonitorObject *pOb){
		CMonitorObjectGroup * pG=NULL;;
		UniVar p;
		UniVar sp;
		CMonitorGroupManager * pO=NULL;
		try{
			pOb->GetObjectClassName(p);
			pOb->GetObjectName(sp);
			sp=sp+p;
			if(m_MonitorStr.Lookup((LPSTR)sp,(void * &)pG)){
				pG->AddObject(pOb);
				return pG;
			}
		}
		catch(...){
			return NULL;
		}
		WaitForSingleObject(m_hMutex,INFINITE);
		try{
			for(int i=0;i<m_pGroupArray.GetSize();i++){
				if(p.IsSame(m_pGroupArray[i]->m_uvManagerName)){
					pO=m_pGroupArray[i];
					break;
				}
			}
			m_bUpDate=TRUE;
		}
		catch(...){
		}
		ReleaseMutex(m_hMutex);
		if(!pO){
			WaitForSingleObject(m_hMutex,INFINITE);
			try{
				pO=new CMonitorGroupManager(p);
				m_pGroupArray.Add(pO);
			}
			catch(...){
			}
			ReleaseMutex(m_hMutex);
		}
		pG=pO->AddObject(pOb);
		m_MonitorStr.SetAt((LPSTR)sp,(void * &)pG);
		return pG;
	};

	void SetGroupChanged()
	{
		m_bUpDate=TRUE;
	}
	
	BOOL GetGroupChanged()
	{
		if(m_bUpDate){
			m_bUpDate=FALSE;
			return TRUE;
		}
		return FALSE;
	}

	CMonitorObjectGroup * GetGroupFromIndex(int mgidx,int grpidx){
		CMonitorGroupManager * pO=GetManagerFromIdx(mgidx);
		CMonitorObjectGroup * pG=NULL;;
		if(pO)pG=pO->GetGroupFromIdx(grpidx);
		return pG;
	}
};

extern AFX_EXT_DATA CMonitorManager gbMonitorManager;

class AFX_EXT_CLASS CCallMonitor:public CMonitorObject
{
public:
	CCallMonitor(){
	};
	~CCallMonitor(){};
	virtual void GetObjectClassName(UniVar & uv){uv="呼叫控制";};
};
/*
class CDeviceMonitor:public CMonitorObject
{
public:
	CDeviceMonitor(){};
	~CDeviceMonitor(){};
	virtual void GetObjectClassName(UniVar & uv){uv="设备";};
};
*/
struct UserMoGrp{
	int iNum;
	UniVar uvName;
	UniVar * pFName;
};

class CUserMonitor;

class AFX_EXT_CLASS CUserMonitorManager {
public:
	CArray<UserMoGrp *,UserMoGrp *> m_GrpList;
	CArray<CUserMonitor *,CUserMonitor *> m_UserList;
	HANDLE m_hMutex;
	CMapStringToPtr m_MonitorStr;

	CUserMonitorManager();
	~CUserMonitorManager();

	inline BOOL GetRight(DWORD dwSec=INFINITE){return (WaitForSingleObject(m_hMutex,dwSec)==WAIT_OBJECT_0);};
	inline void ReleaseRight(){ReleaseMutex(m_hMutex);};
	CUserMonitor * CreateUserMonitorObject(UniVar uvGName,UniVar uvOName,int iNum,UniVar * puvFName,BOOL bShare);
};

class AFX_EXT_CLASS CUserMonitor:public CMonitorObject
{
public:
	CUserMonitor * m_pThis;
	CUserMonitor(UniVar uvName,
		UserMoGrp * pGrp,
		CUserMonitorManager * pMage,
		BOOL bShare){
		m_pThis=this;
		m_uvName=uvName;
		m_pGrp=pGrp;
		m_pFValue=new UniVar[pGrp->iNum];
		for(int i=0;i<pGrp->iNum;i++)
			m_pFValue[i]="";
		m_pRValue=new UniVar[pGrp->iNum];
		m_pMage=pMage;
		m_bShare=bShare;
	};
	UserMoGrp * m_pGrp;
	~CUserMonitor(){
		m_pThis=NULL;
		if(m_pRValue)delete [] m_pRValue;
		if(m_pFValue)delete [] m_pFValue;
	};
	
	VALIDATE(CUserMonitor);
	
	BOOL m_bShare;
	CUserMonitorManager * m_pMage;
	UniVar * m_pFValue,* m_pRValue;
	UniVar m_uvName;
	virtual void GetObjectClassName(UniVar & uv){uv="用户自定义";};
	virtual void GetObjectName(UniVar & uv){uv=m_pGrp->uvName;};
	virtual int GetFeatureorStatusNum(){return m_pGrp->iNum+1;};
	virtual void GetFeatureorStatusNameFromIdx(UniVar & uv,int idx=0){
		if(idx>0&&idx<=m_pGrp->iNum)
			uv=m_pGrp->pFName[idx-1];
		else if(idx==0)
			uv="对象名称";
	};

	virtual void GetFeatureorStatusValueFromIdx(UniVar & uv,int idx=0){
		if(idx>0&&idx<=m_pGrp->iNum)
			uv=m_pFValue[idx-1];
		else if(idx==0)
			uv=m_uvName;
	};

	void SetRelationVar(int idx,UniVar & uv){
		if(idx>=0&&idx<m_pGrp->iNum){
			Get();
			try{
				m_pRValue[idx]=uv;
			}
			catch(...){
			}
			Release();
		}
	};

	void GetRelationVar(int idx,UniVar & uv){
		if(idx>=0&&idx<m_pGrp->iNum)
			uv=m_pRValue[idx];
	};

	void GetFValueVar(int idx,UniVar & uv){
		if(idx>=0&&idx<m_pGrp->iNum)
			uv=m_pFValue[idx];
	};

	void SetFValueVar(int idx,UniVar & uv){
		if(idx>=0&&idx<m_pGrp->iNum)
		{
			if(!uv.IsSame(m_pFValue[idx])){
				Get();
				try{
					m_pFValue[idx]=uv;
					SetFeatureorStatusChanged(idx+1);
				}
				catch(...){
				}
				Release();
			}
		}
	};

	inline void Get()
	{
		if(m_bShare)m_pMage->GetRight();
	};
	inline void Release()
	{
		if(m_bShare)m_pMage->ReleaseRight();
	};
};

extern AFX_EXT_DATA CUserMonitorManager gUserMonitorManager;

#endif