📄 unibus.cpp

📁 一个多线程
💻 CPP
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
	if(m_RegisterObject.Lookup((void *)idx,(void * &)po))return FALSE;
	m_RegisterObject.SetAt((void *)idx,(void * )pObject);
	return TRUE;
};

void CDataBus::UnRegister(CAsynWorker * pObject)
{
	int idx;
	CAsynWorker * po;
	POSITION pos = m_RegisterObject.GetStartPosition();
	while(pos)
	{
		m_RegisterObject.GetNextAssoc(pos,(void * &)idx,(void * &)po);
		if(!po->IsValid()||po==pObject){
			m_RegisterObject.RemoveKey((void *)idx);
			if(po==pObject)break;
		}
	}
}

DWORD CDataBus::SynDistributorTask(UniVar & unObj,UniVar & uvId,DWORD dwType,DWORD dwModId,DWORD dwCmd)
{
	CResDistrabutor * pDbs=NULL;
	if(unObj.IsString()){
		pDbs=(CResDistrabutor * )m_pOdbc->GetOdbc((LPCTSTR)unObj);
	}
	else{
		pDbs=(CResDistrabutor * )(int)unObj;
	}
	if(pDbs->IsValid()){
		CSynWorker sw(this);
		CUniMsg um;
		um.m_dwReceiveMode=dwModId;
		um.m_pReceivor=pDbs;
		if(dwCmd==0){
			um.m_dwCommand=CMD_APPLY_RES;
			um.Add(0);
			um.Add(0);
			um.Add(dwType);
			um.Add(uvId);
			um.Add(0);
		}
		else{
			if(dwCmd==1)
				um.m_dwCommand=CMD_LOCK_RES;
			else
				um.m_dwCommand=CMD_FREE_RES;
			um.Add((int)pDbs);
		}
		CUniMsg * pMsg=sw.SendSynMsg(&um,5000,TRUE);
		if(pMsg){
			if(!pMsg->m_ierror&&pMsg->GetSize()>=1){
				return (DWORD)pMsg->m_pTV[0];
			}
		}
	}
	return 0;
}

int CDataBus::SynExcuteOdbc(LPCTSTR lpSql,DWORD dwMode,CString & szError,int & iline,int & iCol,CUniMsg * pParamResult,UniVar uvAlis,DWORD dwModId,DWORD dwTimeOut)
{
	CHopeKingDatabase * pDbs=NULL;
	if((int)uvAlis==-1){
		pDbs=m_pOdbc->GetDefault();
	}
	else{
		if(uvAlis.IsString()){
			pDbs=(CHopeKingDatabase * )m_pOdbc->GetOdbc((LPCTSTR)uvAlis);
		}
		else{
			pDbs=(CHopeKingDatabase * )(int)uvAlis;
		}
	}
	if(pDbs->IsValid()){
		CSynWorker sw(this);
		CUniMsg um;
		um.m_dwReceiveMode=dwModId;
		um.m_pReceivor=pDbs;
		um.m_dwCommand=CMD_TASK_RUNTASK;
		um.Add(uvAlis);
		um.Add(lpSql);
		um.Add(dwMode);
		if(pParamResult){
			for(int i=0;i<pParamResult->GetSize();i++){
				um.Add(pParamResult->m_pTV[i]);
			}
		}
		CUniMsg * pMsg=sw.SendSynMsg(&um,dwTimeOut,TRUE);
		if(pMsg){
			if(!pMsg->m_ierror&&pMsg->GetSize()>=2){
				if(pMsg->m_pTV[1].IsString()){
					szError=(LPCTSTR)pMsg->m_pTV[1];
				}
				if(pMsg->GetSize()>=5){
					iline=(int)(int)pMsg->m_pTV[4];
					iCol=(int)(int)pMsg->m_pTV[3];
					if(pParamResult){
						for(int i=0;i<pParamResult->GetSize()&&i<pMsg->GetSize()-5;i++){
							pParamResult->m_pTV[i]=pMsg->m_pTV[i+5];
						}
						for(i=pParamResult->GetSize();i<pMsg->GetSize()-5;i++){
							pParamResult->Add(pMsg->m_pTV[i+5]);
						}
					}
				}
				return (int)pMsg->m_pTV[0];
			}
		}
		szError="未知错误";
		return -25100;
	}
	szError="数据原错误";
	return -25010;
}

CAsynWorker * CDataBus::GetRegisterObject(int idx,DWORD dwModId)
{
	if(dwModId==0||dwModId==GetModId()){
		CAsynWorker * po;
		if(m_RegisterObject.Lookup((void *)idx,(void * &)po))return po;
		else return NULL;
	}
	else{
		CSynWorker sw(this);
		CUniMsg um;
		um.m_dwReceiveMode=dwModId;
		um.m_dwCommand=EVT_GETOBJ_REMOTE;
		um.Add(idx);
		CUniMsg * pMsg=sw.SendSynMsg(&um);
		if(pMsg){
			if(!pMsg->m_ierror&&pMsg->GetSize()==1){
				CAsynWorker * po=(CAsynWorker *)(int)pMsg->GetAt(0);
				return po;
			}
		}
		return NULL;
	}
}

char * CDataBus::GetErrorMsg(int id)
{
	int i=0;
	if(m_ErrMap.Lookup((void *)id,(void * &)i)){
		return (char *)m_ErrorList[i].errMsg;
	}
	return NULL;
}

void CDataBus::AddErrorMsg(int id,char * Msg)
{
	void * p=0;
	if(!m_ErrMap.Lookup((void *)id,p)){
		ErrorMsg em;
		m_ErrorList.Add(em);
		int i=m_ErrorList.GetSize();
		m_ErrorList[i-1].errid=id;
		m_ErrorList[i-1].errMsg=Msg;
		i--;
		m_ErrMap.SetAt((void *)id,(void *)i);
	};
};

CUniMsg::CUniMsg(CUniMsg * pMsg)
{
	try{
		memcpy(this,pMsg,sizeof(CUniMsg));
		if(m_pTV){
			m_pTV=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
			memset(m_pTV,0,sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
			for(int i=0;i<m_iNumOfTV;i++){
				m_pTV[i]=pMsg->m_pTV[i];
			}
		}
	}
	catch(...){
	}
};

void CUniMsg::SetMessage(DWORD dwSendMode,DWORD dwReceiveMode,CAsynWorker * pSender,CAsynWorker * pReceivor,DWORD dwCommand,BYTE btMsgType,UniVar uvi,...)
{
	Clear();
	va_list varl;
	va_start(varl,btMsgType);
	m_dwSendMode=dwSendMode;
	m_dwReceiveMode=dwReceiveMode;
	m_pSender=pSender;
	m_pReceivor=pReceivor;
	m_dwCommand=dwCommand;
	m_btMsgType=btMsgType;
	UniVar uv;
	while(1){
		uv=va_arg(varl,UniVar);
		if(UniVar::ValidVar(&uv))
			Add(uv);
		else break;
	};
	va_end(varl);
};

void CUniMsg::SetMessage(CAsynWorker * pSender,CAsynWorker * pReceivor,DWORD dwCommand,BYTE btMsgType,UniVar uvi,...)
{
	Clear();
	va_list varl;
	va_start(varl,btMsgType);
	m_dwSendMode=0;
	m_dwReceiveMode=0;
	m_pSender=pSender;
	m_pReceivor=pReceivor;
	m_dwCommand=dwCommand;
	m_btMsgType=btMsgType;
	UniVar uv;
	while(1){
		uv=va_arg(varl,UniVar);
		if(UniVar::ValidVar(&uv))
			Add(uv);
		else break;
	};
	va_end(varl);
}

const CUniMsg & CUniMsg:: operator=(const CUniMsg & Msg)
{
	clearptv();
	memcpy(this,&Msg,sizeof(CUniMsg));
	if(m_pTV){
		m_pTV=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		memset(m_pTV,0,sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		for(int i=0;i<m_iNumOfTV;i++){
			m_pTV[i]=Msg.m_pTV[i];
		}
	}
	return *this;
}

int CUniMsg::Add(UniVar tv)
{
	ASSERT(m_btEmptySlotNum<MAXNUMOFEMPTYSLOT);
	if(!m_btEmptySlotNum){
		m_btEmptySlotNum=MAXNUMOFEMPTYSLOT;
		UniVar * pTV=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		memset(pTV,0,sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		ASSERT(pTV);
		if(m_iNumOfTV){
				for(int i=0;i<m_iNumOfTV;i++)pTV[i]=m_pTV[i];
		}
		clearptv();
		m_pTV=pTV;
	}
	m_pTV[m_iNumOfTV++]=tv;
	m_btEmptySlotNum--;
	return m_iNumOfTV-1;
};

int CUniMsg::InsertAt(UniVar tv,int iPos)
{
	ASSERT(m_btEmptySlotNum < MAXNUMOFEMPTYSLOT);
	if(iPos<0||iPos>=m_iNumOfTV)return -1;
	if(!m_btEmptySlotNum){
		m_btEmptySlotNum=MAXNUMOFEMPTYSLOT;
		UniVar * pTV=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		memset(pTV,0,sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
		ASSERT(pTV);
		if(m_iNumOfTV){
				for(int i=0;i<m_iNumOfTV;i++)pTV[i]=m_pTV[i];
		}
		clearptv();
		m_pTV=pTV;
	}

	memmove(m_pTV+iPos+1,m_pTV+iPos,(m_iNumOfTV-iPos)*sizeof(UniVar));
	m_iNumOfTV++;
	m_pTV[iPos].SetDataLength(0);
	m_pTV[iPos]=tv;
	m_btEmptySlotNum--;
	return iPos;
};

int CUniMsg::RemoveAt(UniVar & tv,int iPos)
{
	ASSERT(m_btEmptySlotNum < MAXNUMOFEMPTYSLOT);
	if(iPos<0||iPos>=m_iNumOfTV)return -1;
	ASSERT(m_iNumOfTV>=0);
	tv=m_pTV[iPos];
	UniVar tv1=m_pTV[m_iNumOfTV-1];
	m_pTV[m_iNumOfTV-1]=0;
	m_pTV[iPos]=0;
	m_btEmptySlotNum++;
	if(m_btEmptySlotNum == MAXNUMOFEMPTYSLOT){
		m_btEmptySlotNum=0;
		UniVar * pTV=NULL;
		if(m_iNumOfTV!=1){
			UniVar * pTV=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
			memset(pTV,0,sizeof(UniVar)*(m_iNumOfTV+m_btEmptySlotNum));
			ASSERT(pTV);
			if(m_iNumOfTV){
				for(int i=0;i<m_iNumOfTV;i++)pTV[i]=m_pTV[i];
			}
		}
		clearptv();
		m_pTV=pTV;
		if(!m_pTV){
			m_iNumOfTV=0;
			m_btEmptySlotNum=0;
			return 0;
		}
	}
	if(m_iNumOfTV!=iPos+1)
		memmove(m_pTV+iPos,m_pTV+iPos+1,(m_iNumOfTV-iPos-1)*sizeof(UniVar));
	m_iNumOfTV--;
	m_pTV[m_iNumOfTV-1]=tv1;
	return iPos;
}

BusRoad::BusRoad(int iRoad,MSGLISTDATA * pD,CAsynWorker * pO)
{
	m_pThis=this;
	m_iRoad=iRoad;
	m_iError=0;
	if(pD){
		m_bCreateData=FALSE;
		m_pData=pD;
	}
	else{
		m_bCreateData=TRUE;
		m_pData=new MSGLISTDATA;
		m_pData->m_hMutex=CreateMutex(NULL,FALSE,NULL);
		m_pData->m_hSemaphore=CreateSemaphore(NULL,0,MAX_BUS_SENDER+1,NULL);
		m_pData->m_iGetOnNum=0;
		m_pData->m_iGetOffNum=0;
		m_pData->m_iRejectNum=0;
		m_pData->m_ListMsg.RemoveAll();
		m_pData->pTimer=NULL;
		m_pData->m_pOwner=pO;
		m_pData->m_bExit=FALSE;
	}
	m_pOwnMsg=NULL;
	m_pCurMsg=NULL;
	m_hFlowMutex=NULL;
	m_iStatus=0;
	m_pThread=AfxBeginThread(BusRoad::Drive,(LPVOID)this);
};

BusRoad::~BusRoad()
{
//	TRACE("road exit start\n");
	m_pData->m_btExitThread=m_iRoad;
	m_pData->m_bExit=true;
	ReleaseSemaphore(m_pData->m_hSemaphore,2,NULL);
	if(WaitForSingleObject(m_pThread->m_hThread,5000)==WAIT_TIMEOUT){
		DWORD dwExit=0;
		GetExitCodeThread(m_pThread->m_hThread,&dwExit);
		TerminateThread(m_pThread->m_hThread,dwExit);
	}
	if(m_bCreateData){
		CloseHandle(m_pData->m_hMutex);
		CloseHandle(m_pData->m_hSemaphore);
		POSITION pos=m_pData->m_ListMsg.GetHeadPosition();
		while(pos){
			CUniMsg *pMsg=m_pData->m_ListMsg.RemoveHead();
			delete pMsg;
			pos=m_pData->m_ListMsg.GetHeadPosition();
		}
		if(m_pData->pTimer)
			delete m_pData->pTimer;
		if(m_pData)
			delete m_pData;
		m_pData=NULL;
		m_bCreateData=FALSE;
	}
	if(m_pOwnMsg){
		for(int i=0;i<m_pOwnMsg->GetSize();i++){
			delete m_pOwnMsg->GetAt(i);
		}
		delete m_pOwnMsg;
	}
	if(m_pCurMsg)delete m_pCurMsg;
//	TRACE("road exit End\n");
	if(m_hFlowMutex)CloseHandle(m_hFlowMutex);
	m_pThis=NULL;
};

DWORD BusRoad::SendMessage(CUniMsg * pMsg,BOOL bFromHead)
{
	if(m_pData->m_ListMsg.GetCount()>=MAX_BUS_SENDER){
		m_pData->m_iRejectNum++;
		return 0;//INVALID_IDENT;
	}
	WaitForSingleObject(m_pData->m_hMutex,INFINITE);
	CUniMsg * ptMsg=new CUniMsg(pMsg);
	if(bFromHead)
		m_pData->m_ListMsg.AddHead(ptMsg);
	else 
		m_pData->m_ListMsg.AddTail(ptMsg);
	ReleaseSemaphore(m_pData->m_hSemaphore,1,NULL);
	m_pData->m_iGetOnNum++;
	ReleaseMutex(m_pData->m_hMutex);
	return 1;//ptMsg->m_dwIdent;
};

bool BusRoad::CancelCmd(CUniMsg * pMsg)
{
	bool bret=false;
	if(m_pData->m_ListMsg.GetCount()>=0){
		WaitForSingleObject(m_pData->m_hMutex,INFINITE);
		POSITION pos,pos1;
		pos1=pos=m_pData->m_ListMsg.GetHeadPosition();
		while(pos){
			CUniMsg * ptMsg=m_pData->m_ListMsg.GetNext(pos);
			if(
				ptMsg->m_dwIdent==pMsg->m_dwIdent
				){
				WaitForSingleObject(m_pData->m_hSemaphore,INFINITE);
				m_pData->m_ListMsg.RemoveAt(pos1);
				bret=true;
				break;
			}
			pos1=pos;
		};
		m_pData->m_iGetOffNum++;
		ReleaseMutex(m_pData->m_hMutex);
	}
	return bret;
};

DWORD CAsynWorker::GetModId()
{
	if(!m_pBus)return 0;
	return m_pBus->GetModId();
}

ComInterface::ComInterface(LPSTR szLibName,int id,LPSTR szOwnIdent)
{
	m_iCommId=id;
	m_csOwnIdent=szOwnIdent;
	m_csLibName=szLibName;
	m_hLib=AfxLoadLibrary(szLibName);
	m_iCountId=0;
	if(m_hLib){
		m_pInitInterface=(FLOWInitInterface)GetProcAddress(m_hLib,"InitInterface");
		m_pEnableGetIn=(FLOWEnableGetIn)GetProcAddress(m_hLib,"EnableGetIn");
		m_pStartConnect=(FLOWStartConnect)GetProcAddress(m_hLib,"StartConnect");
		m_pDisconnected=(FLOWDisconnected)GetProcAddress(m_hLib,"Disconnected");
		m_pDisableGetIn=(FLOWDisableGetIn)GetProcAddress(m_hLib,"DisableGetIn");
		m_pWriteData=(FLOWWriteData)GetProcAddress(m_hLib,"WriteData");
		m_pClose=(FLOWClose)GetProcAddress(m_hLib,"Close");
		if(m_pInitInterface)m_pInitInterface(id,szOwnIdent);
	}
	else{
		m_pInitInterface=NULL;
		m_pEnableGetIn=NULL;
		m_pStartConnect=NULL;
		m_pDisconnected=NULL;
		m_pDisableGetIn=NULL;
		m_pWriteData=NULL;
		m_pClose=NULL;
	}
}

ComInterface::~ComInterface()
{
	if(m_hLib){
		if(m_pClose)m_pClose();
		AfxFreeLibrary(m_hLib);
		m_hLib=NULL;
		m_pInitInterface=NULL;
		m_pEnableGetIn=NULL;
		m_pStartConnect=NULL;
		m_pDisconnected=NULL;
		m_pDisableGetIn=NULL;
		m_pWriteData=NULL;
		m_pClose=NULL;
	}
}

BusConfigSet::BusConfigSet()
{
	m_hBufferMutex=CreateMutex(NULL,FALSE,NULL);
	m_iNeedInSure=0;
	char szDir[400];
	GetCurrentDirectory(400,szDir);
	strcat(szDir,"\\station.ini");
	m_StringStation.RemoveAll();
	m_unMod.dwModId=0;
	int iNum,i;
	char szBuffer[400];
	GetPrivateProfileString("StationSetup","Station","0x0000",szBuffer,300,szDir);
	sscanf(szBuffer,"%lx",&m_unMod.dwModId);
	GetPrivateProfileString("StationSetup","StationName","",szBuffer,300,szDir);
	m_csName=szBuffer;
	if(gDllGlobalManager.m_pGlobalApi&&!gDllGlobalManager.m_pGlobalApi->m_UserName.IsEmpty())
		m_csName=gDllGlobalManager.m_pGlobalApi->m_UserName;
	if(!m_csName.IsEmpty()){
		if((m_unMod.dwModId&0xfff)!=0xfff){
			AddStationName(m_unMod.dwModId,szBuffer);
		}
	}
//////////////////////////////////////////////////////////////////////////////////////////
上一页 1 2 3 45
💿 文件大小 147 K
👤 上传用户 guigui2008q
📂 所属分类编译器/解释器
🏷️ 相关标签

#多线程
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -