unibus.h

一个多线程

	CAsynWorker * m_pWorker;
	CAsynWorker * m_pApply;
	DWORD m_dwTitleId;
	WorkerLock(CAsynWorker * pWorker,CAsynWorker * pApply,DWORD dwTitleId){
		m_pThis=this;
		m_pWorker=pWorker;
		m_pApply=pApply;
		m_dwTitleId=dwTitleId;
	};
	~WorkerLock(){m_pThis=NULL;};
	VALIDATE(WorkerLock);
};

struct MODIDDEF{
	WORD m_wModId;
	WORD m_wMaskId;
};

struct MODSDEF{
	BYTE m_btLoClientId,
		m_btHiClientId:4,
		m_btSerId:4;
	WORD m_wMaskId;
};

typedef void (APIENTRY * FLOWCALLBACK)(DWORD dwHandle,int id,void *  Buffer,int iBufferLen);
typedef BOOL (APIENTRY * FLOWInitInterface)(int id,LPSTR szOwnIdent);
typedef BOOL (APIENTRY * FLOWEnableGetIn)(FLOWCALLBACK pfn,DWORD dwhandle,LPSTR szIdentString,int port,int iactid);
typedef BOOL (APIENTRY * FLOWStartConnect)(FLOWCALLBACK pfn,DWORD dwhandle,LPSTR szIdentString,int port,int iactid);
typedef void (APIENTRY * FLOWDisconnected)(DWORD dwConnectHandle);
typedef void (APIENTRY * FLOWDisableGetIn)(DWORD dwConnectHandle);
typedef void (APIENTRY * FLOWWriteData)(DWORD dwConnectHandle,void * buffer,int ilen);
typedef void (APIENTRY * FLOWClose)();

class ComInterface{
public:
	ComInterface(LPSTR szLibName,int id,LPSTR szOwnIdent);
	~ComInterface();
	int m_iCommId;
	CString m_csOwnIdent;
	int m_iCountId;
	HMODULE m_hLib;
	CString m_csLibName;
	FLOWInitInterface	m_pInitInterface;
	FLOWEnableGetIn		m_pEnableGetIn;
	FLOWStartConnect	m_pStartConnect;
	FLOWDisconnected	m_pDisconnected;
	FLOWDisableGetIn	m_pDisableGetIn;
	FLOWWriteData		m_pWriteData;
	FLOWClose			m_pClose;
};

union MODUNION{
	MODIDDEF	modm;
	MODSDEF		mods;
	DWORD		dwModId;
};

struct RELATEROUTOR{
	MODUNION m_dwFirstModId,m_dwSecondModId;
};

struct LinkParam{
	short m_iFlagRelationType;
	short m_ServerorClient;
	int m_iPort;
	CString m_csAddress;
	DWORD dwModId;
	int istatus;
};

class CDataBuffer{
public:
	CDataBuffer * m_pThis;
	VALIDATE(CDataBuffer);
	char * m_szBuffer;
	int m_iGoodBufLen,m_iMaxBufLen,m_CurBufLen,m_iDeltaLen;
	int m_iReadPos,m_iWritePos;
	int m_iErrorFlag;
	int m_iChangFlag;
	CDataBuffer(int iGoodBufLen,int iMaxBufLen,int iDeltaLen);
	~CDataBuffer();
	void PutData(char * pBuf,int len);
	void GrowBuffer(int DeletLen);
	int GetData(char * pBuf,int len);
	int FindData(char * pBuf,int len);
	void MovePointer(int Len);
	int CopyData(char * pBuf,int offset,int len);
	int GetSize();
};

struct LinkerStation{
	LinkParam * pLink;
	DWORD dwModId;
	HANDLE hSock;
	int iDllid;//0,1,2,3
	short int iflag;//0:server,1:solid station
	short int iInsure;//for 0xfff
	CString m_csLinkKeyName;
	CDataBuffer * pBuffer;
};

class AFX_EXT_CLASS BusConfigSet{
public:
	BusConfigSet();
	~BusConfigSet();
	HANDLE m_hBufferMutex;
	inline BOOL GetBufferRight(DWORD dwSec=INFINITE){	return (WaitForSingleObject(m_hBufferMutex,dwSec)==WAIT_OBJECT_0);};
	inline void ReleaseBufferRight(){ReleaseMutex(m_hBufferMutex);};
	MODUNION m_unMod;
	CString m_csName;
	int m_iNeedInSure;
	CArray <CDataBuffer * ,CDataBuffer *> m_DataBuffer;//
	CArray<ComInterface*,ComInterface*>m_Interface;//config
	CArray<LinkParam *,LinkParam *>m_ListenF;//config
	CArray<LinkParam *,LinkParam *>m_ConnectT;//count
	CArray<LinkParam *,LinkParam *>m_OtherCom;//count
	CArray<LinkerStation *,LinkerStation *>m_LinkStation;
	CArray<RELATEROUTOR,RELATEROUTOR&> m_LineArray;
	CMapStringToPtr m_StringStation;
	CMapPtrToPtr m_LineMap,m_LinkerModMap,m_LinkerSockMap;
	void AddStationName(DWORD dwModId,LPSTR szName);
	DWORD GetStationModId(LPSTR szName);
	void AddRouter(DWORD dwClientMod,DWORD dwNServerMod);
	void AddConnectTo(int iType,int iPort,LPSTR szAddress,DWORD dwModId);
	void AddListenFor(int iType,int iPort,LPSTR szAddress,DWORD dwModId);
	void BuildRoad();
	DWORD FindRoad(DWORD dwMod);
	void SetRoad(DWORD dwMod1,DWORD dwMod2);
	LinkerStation * AddLinker(LinkParam *,HANDLE hSock,int iDllid,int iflag);
	CDataBuffer * GetLinkerBuffer(HANDLE hSock);
	LinkerStation * FindLinker(HANDLE hSock);
	LinkerStation * FindLinker(DWORD dwModId);
	void ChangeModId(HANDLE hSock,DWORD & dwModId,LPSTR czLinkKeyName);
	void RemoveLinker(HANDLE hSock);
	BOOL IsMyServer(DWORD dwMod);
	LinkParam * FindServer();
	LinkParam * FindLinkParam(DWORD dwModId,BOOL bListen);
	BOOL IsSameModId(DWORD dwMod1,DWORD dwMod2);
	CDataBuffer * CreateBuffer(int iGoodBufLen,int iMaxBufLen,int iDeltaLen);
	void DeleteBuffer(CDataBuffer * pBuf);
	LinkParam * AddLinkParam(int iType,int iPort,LPSTR szAddress,BOOL bServerorClient);
	void RemoveLinkParam(LinkParam *);
	void LinkAll(FLOWCALLBACK pfn,DWORD dwhandle);
	void CheckClientMod(DWORD & dwClientId);
	void ClearCommInterface();
	LinkerStation * FindClient(DWORD dwClientId);
};

class AFX_EXT_CLASS CSynWorker:public CAsynWorker
{
public :
	CSynWorker(CDataBus * pBus=NULL);
	~CSynWorker();
	HANDLE m_hEvent;
	CSynWorker * m_pCorrect;
	BOOL IsSynWorker();
	CUniMsg * SendSynMsg(CUniMsg * pSend,DWORD dwTimeOut=20000,BOOL bRemoteAsyn=FALSE);
	inline void ResetTask(){ResetEvent(m_hEvent);};
	inline void SetTaskOver(){SetEvent(m_hEvent);};
	inline BOOL WaitTaskOver(DWORD dwTimeOut){return (WaitForSingleObject(m_hEvent,dwTimeOut)==WAIT_OBJECT_0);};
};

#include "funcall.h"

#define APIINT 0
#define APILPINT 1
#define APIUSEINT 2
#define APILONG 3
#define APILPLONG 4
#define APIUSELONG 5
#define APIFLOAT 6
#define APILPFLOAT 7
#define APIUSEFLOAT 8
#define APIDWORD 9
#define APILPDWORD 10
#define APIUSEDWORD 11
#define APILPSTR 12
#define APILPCTSTR 13
#define APIUSELPSTR 14
#define APILPVOID 15
#define APIVOID 16
#define APIUSEBLOCK 17
#define APIUSECSTRING 18
#define APIUSECBYTEARY 19
#define APIUSECHAR 20
#define APIUSESHORT 21
#define APIUSEDOUBLE 22
#define APIUSELPDOUBLE 23
#define APILPCBYTEARY 24
#define APILPCSTRING 25
#define APICHAR 26
#define APISHORT 27
#define APIDOUBLE 28
#define APIBLOCK 100

class CEdauDllProxy:public CSynWorker{
public :
	CEdauDllProxy(CDataBus * pBus,int iNum);
	~CEdauDllProxy();
	virtual void OnSynMsg(CUniMsg * pCmdSend,CUniMsg * pCmdReceive);
	virtual void QueueMenuberTimeOut(CUniMsg *pMsg);
	virtual void OnMsgReceive(CUniMsg * pMsg);//通常情况下，不要重载这个函数
	CMapStringToPtr m_eFuncList;
	CArray < HMODULE , HMODULE > m_listLibrary;
	EDAUFUNCTION GetFuncTion(LPSTR szAlis,LPSTR szFunction);
	bool AddLibrary(LPSTR szLibrary,LPSTR szAlis);
	bool RemoveLibrary(LPSTR szLibrary,LPSTR szAlis);
	HANDLE m_hMutex;
	struct APILIB{
		HMODULE hlib;
		UniVar LibName;
	};

	CArray <APILIB,APILIB&>m_ApiLibList;
	CArray <APILIB *,APILIB *>m_TypeList;
	bool SetApiType(DWORD & dwInterface,UniVar * pType,int num);
	int SetApiParam(UniVar & uvret,void * pVa,long bttype,int pvalen=0);
	int GetApiParam(UniVar & uvret,void * pVa,long bttype,BOOL bret=FALSE,int pvalen=0);
	bool CallAPIFunction(DWORD dwlib,DWORD dwtyp,LPSTR szFunc,int & cret,UniVar & fret,UniVar * pVar,int num);
	bool CallAPIFunction(DWORD dwtyp,DWORD dwFunc,int & cret,UniVar & fret,UniVar * pVar,int num);
	bool LoadAPILibrary(char * pszLibrary,DWORD & dwInterface);
	int GetRetLen(int dwType);
	void GetBlockUnit(BYTE * btBuffer,int iBufferLen,DWORD dwtyp,UniVar * pVar,int iVarNum);
	void SetBlockUnit(BYTE * btBuffer,int iBufferLen,DWORD dwtyp,UniVar * pVar,int iVarNum);
};

class AFX_EXT_CLASS CFileTrans:public CSynWorker{
public:
	CFileTrans(){};
	~CFileTrans(){};
	bool CopyFile(DWORD dwMod,int Object,char * remotefile,char * localfile);
	bool DoDacs(DWORD dwMod,int Object,char * libname,PARAM* pParam,RESULT* pResult);
};

struct NEEDRPT{
	DWORD dwOnlineNoty,dwNeedNoty,dwSendTo;
	int iOldFlag;
};

#define MAXROADNUM 256

class COdbcMg;
class CDistrabutorMg;

class AFX_EXT_CLASS CDataBus:public BusConfigSet{
public:
	CDataBus * m_pThis;
	COdbcMg *m_pOdbc;
	CDistrabutorMg * m_pDistrMg;
	
	CEdauDllProxy * m_pEdauDllProxy;
	DWORD m_dwRemoteEdauMod,m_dwRemoteOdbcMod;
	CAsynWorker * pRemoteControl;
	CArray<NEEDRPT,NEEDRPT&> m_ListNeedRpt;
	long m_iTime;
	DWORD m_dwPudFlag;
	CMapPtrToPtr m_RegisterObject;
	CRITICAL_SECTION m_hTimeMutex;
	int m_iRoadNum;
	int m_iDefaultRoad;
	int m_iTimeRoad;
	int m_iFlowRoad;
	int m_iNumofFlowThread;
	BusRoad * m_pRoad[MAXROADNUM];
	CList<WORKERTIME,WORKERTIME&> m_TimeWorkList;
	CMapPtrToPtr m_TimePos;
	HANDLE m_hMutex;
	HANDLE m_hSemaphore;
	int m_iGetOnNum;
	int m_iGetOffNum;
	int m_iRejectNum;
	int m_iError;
	int m_iStatus;
	BOOL m_bExit;
	CWinThread * m_pThread,*m_pTimer;
	DWORD m_dwIdCount;
	CRITICAL_SECTION m_hNumMutex;
	CList <WorkerLock *,WorkerLock * > m_LockList;
	CList <CUniMsg * ,CUniMsg * > m_LockMsg;
	CMapPtrToPtr m_LockPos;
	CRITICAL_SECTION m_LockMutex;
	struct ErrorMsg{
	public:
		int errid;
		UniVar errMsg;
	};

	CArray <ErrorMsg,ErrorMsg&> m_ErrorList;
	CMapPtrToPtr m_ErrMap;
	void AddErrorMsg(int id,char * Msg);
	char * GetErrorMsg(int id);
	CAsynWorker * GetRegisterObject(int idx,DWORD dwModId=0);
	void UnRegister(CAsynWorker * pObject);
	BOOL Register(int idx,CAsynWorker * pObject);
	DWORD m_iBusTimer;
	CDataBus(
		char * lpstrfilename="buslog.txt",
		int imaxlevel=3,
		int iRoadNum=5,
		int iTimeRoad=4,
		int iDefaultRoad=0,
		int iBusTimer=TIME_ELEAPS);

	inline DWORD GetModId(){return m_unMod.dwModId;};
	HANDLE LockWorker(CAsynWorker * pWorker,CAsynWorker * pApply,DWORD dwTId);
	void ApplyWorkerLock(CAsynWorker * pWorker,CAsynWorker * pApply,DWORD dwTId);
	BOOL IsLocked(CAsynWorker * pWorker);
	BOOL TestLock(CUniMsg * pMsg);
	void UnlockWorker(CAsynWorker * pWorker,HANDLE hKey,CAsynWorker * pApply=NULL,DWORD dwID=0);	
	~CDataBus();
	inline long GetTimeStamp(){return m_iTime;};
	inline void GetTime(CTime & tm){tm=CTime(m_iTime);};
	inline void ChangeLogLevel(int ilevel){m_imaxlevel=ilevel;};

	VALIDATE(CDataBus);
	void AddTime(CAsynWorker * pWorker,int iNumTimeflake,DWORD dwIdent=0,bool bDirectCall=false,bool bForeverCall=false,bool bCmdTimeOut=false,bool bTimeRoad=true);
	void ResetTime(CAsynWorker * pWorker,DWORD dwIdent=0);
	void CancelTime(CAsynWorker * pWorker,DWORD dwIdent=0,BOOL bCmdTimeOut=false);
	void OnTimer();
	DWORD SendMessage(CUniMsg * pMsg,HANDLE hKey=NULL,int timeout=0);
	DWORD SendMessage(CUniMsg * pMsg,int iRoad,HANDLE hKey=NULL,int timeout=0);
	DWORD SendMessage(DWORD & dwIdent,CUniMsg * pMsg,int iRoad,HANDLE hKey=NULL,int timeout=0);
	void CancelCmd(CUniMsg * pMsg);

	struct LOGST{
		LOGTYPE logtype;
		int icommand;
		int ilevel;
		UniVar uvdescripe;
		UniVar m_uvFile;
	};

	CArray <LOGST *,LOGST *> m_ListLog;
	int m_imaxlevel;
	char * m_szLogFile;
	inline void SetLogWriteLevel(int imax){m_imaxlevel=imax;};
	inline void CopyLog(LPSTR szDirName,LPSTR lpSourceFile){
		LogEvent(warningLog,COPYLOGILE,-1,szDirName,lpSourceFile);
	};
	void LogEvent(LOGTYPE logtype,int icommand,int ilevel,char * lpszdescripe,char * lpLogFileName=NULL);
	static UINT WriteLog(LPVOID lpVoid);
	static UINT Timer(LPVOID lpVoid);
	void OpenEdau(int iTimeOut=3,int iThreadNum=-1);
	BOOL AddEdauLib(char * szLib,char * szAlis);
	void SetCommDllStatus(DWORD dwHandle,int id,void *  Buffer,int iBufferLen);
	BOOL SynMsgProc(CUniMsg * pCmdSend,CUniMsg * pCmdReceive);
	void OnBusMsg(CUniMsg * pCmdSend);
	BOOL DistrabutWork(CUniMsg * pCmdSend);
	BOOL SetSynMsgReturn(DWORD dwModId,CAsynWorker * pAsWorker,DWORD dwCommand,UniVar uvi=InValidVar,...);
	BOOL SetSynMsgReturn(DWORD dwModId,CAsynWorker * pAsWorker,DWORD dwCommand,UniVar * pVar,int iNum);
	BYTE CreateRoad(CAsynWorker * ,int iNum,int iTimeOut);
	void RemoveRoad(CAsynWorker *,BYTE btPointRoad, BYTE btNumberOfRoad);
	void ProcSynMsg(CUniMsg * pMsg);
	void SetRptModule(DWORD dwNeed,DWORD dwModId);
	int SynExcuteOdbc(LPCTSTR lpSql,DWORD dwMode,CString & szError,int & iline,int & iCol,CUniMsg * pParamResult,UniVar uvAlis=UniVar(-1),DWORD dwModId=0,DWORD dwTimeOut=5000);
	DWORD SynDistributorTask(UniVar & unObj,UniVar & uvId=UniVar(0),DWORD dwType=0,DWORD dwModId=0,DWORD dwCmd=0);
};
#endif