publicclass.cpp

电力故障信息采集,主要是针对南自的保护装置,这个程序用在Linux操作系统下

#include "publicclass.h"
#include "xml.h"

CDeviceNode :: CDeviceNode()
{
    memset(&m_deviceinfo,0x00,sizeof(st_deviceinfo));
    m_ModuleState=0;m_Level=0;
    return;
};

CDeviceNode :: ~CDeviceNode()
{
    return;
};

void CDeviceNode::ResetXunJianFlag()
{
	DeviceInfoListType::iterator it;
    for (int i=0; i<(int)m_ChildDevList.count(); i++)
    {
		it = m_ChildDevList.at(i);
		(*it).m_PlFlag = 0;
    }
}

int CDeviceNode::FindDeviceByEquipNo(int iEquipNo)
{
    DeviceInfoListType::iterator it;
    for (int i=0; i<(int)m_ChildDevList.count(); i++)
    {
		it = m_ChildDevList.at(i);
		if (iEquipNo == (int)(*it).m_MachineNo) return i;
    }
    return -1;
}

long CDeviceNode::FindDeviceWildByEquipNo(int iEquipNo)
{
    DeviceInfoListType::iterator it;
    for (int i=0; i<(int)m_ChildDevList.count(); i++)
    {
		it = m_ChildDevList.at(i);
		if (iEquipNo == (int)(*it).m_MachineNo) return (*it).m_Wild;
    }
    return 0;
}


int CDeviceNode::FindDeviceByFlag(int iFlag)
{
	DeviceInfoListType::iterator it;
    for (int i=0; i<(int)m_ChildDevList.count(); i++)
    {
		it = m_ChildDevList.at(i);
		if (iFlag == (*it).m_PlFlag) return i;
    }
    return -1;
}

long CDeviceNode::FindDeviceWildByFlag(int iFlag,int & iDevIndex)
{
    DeviceInfoListType::iterator it;
    for (int i=0; i<(int)m_ChildDevList.count(); i++)
    {
		it = m_ChildDevList.at(i);
		if (iFlag == (*it).m_PlFlag)
		{
		    iDevIndex=i;
		    return (*it).m_Wild;
		}
    }
    return 0;
}

CDataNode :: CDataNode()
{
    memset(&m_nodeinfo,0x00,sizeof(st_nodeinfo));
    m_init=0;
    return;
};

CDataNode :: CDataNode(CDataNode* pNode)
{
    char* buff=NULL;
    if(pNode)
    {
	if(pNode->m_nodeinfo.m_iSize>0&&pNode->m_nodeinfo.m_SegmentPid>0)
	{
	    buff=new char[pNode->m_nodeinfo.m_iSize];
	    memcpy(buff,(char*)pNode->m_nodeinfo.m_SegmentPid,pNode->m_nodeinfo.m_iSize);
	}
	memcpy(&m_nodeinfo,&pNode->m_nodeinfo,sizeof(st_nodeinfo));
	m_nodeinfo.m_SegmentPid=(long)buff;
    }
    else
    {
	memset(&m_nodeinfo,0x00,sizeof(st_nodeinfo));
    }
    return;
};

CDataNode :: ~CDataNode()
{
    return;
};


CMessageQueue :: CMessageQueue()
	: CBMessageQueue()
{

}

CMessageQueue :: ~CMessageQueue()
{

}

int CMessageQueue :: CheckMessage(int *qid,long type)
{
    for(int i=0;i<MESSAGEQUEUES;i++)
    {
	if(Peek_Message(qid[i],type)) return i;
    }
    return -1;
}

bool CMessageQueue :: SendMessage(int qid,long DestPid,long DestThread,unsigned int DataType,
				 void* qbuf,int iSize)
{
    st_nodeinfo st;CSegment cs;
    memset(&st,0x00,sizeof(st_nodeinfo));
    if(DestPid==0) return 0;
    st.mtype=DestPid;st.requestid=getpid();st.m_CurrentThread=DestThread;st.m_DataType=DataType;
    if(qbuf&&iSize>0)
    {
	st.m_SegmentPid=cs.WriteSegment(qbuf,iSize,true);
	st.m_iSize=iSize;
	if(st.m_SegmentPid<=0) //如果共享内存失败
	    return 0;
    }
    if(Send_Message(qid,&st,sizeof(st_nodeinfo))<0) return 0;
    return 1;
}

bool CMessageQueue :: SendMessageEx(int qid,long DestPid,long DestThread,unsigned int DataType,
				  void* qbuf,int iSize,
				  unsigned int DataFrom,int iResult,int DisplayFlag,
				  int Level,long TransThread)
{
    st_nodeinfo st;CSegment cs;
    memset(&st,0x00,sizeof(st_nodeinfo));
    if(DestPid==0) return 0;
    st.mtype=DestPid;st.requestid=getpid();st.m_CurrentThread=DestThread;st.m_DataType=DataType;
    st.m_DataFrom=DataFrom;st.m_iResult=iResult;st.m_DisplayFlag=DisplayFlag;
    st.m_Level=Level;st.m_TransThread=TransThread;
    if(qbuf&&iSize>0)
    {
	st.m_SegmentPid=cs.WriteSegment(qbuf,iSize,true);
	if(st.m_SegmentPid<=0) //如果共享内存失败
	    return 0;
    }
    if(Send_Message(qid,&st,sizeof(st_nodeinfo))<0) return 0;
    return 1;
}

bool CMessageQueue :: SendMessage(int qid,void* ppNode)
{
    st_nodeinfo st;CSegment cs;
    memset(&st,0x00,sizeof(st_nodeinfo));
    CDataNode* pNode=(CDataNode*)ppNode;
    if(!pNode) return 0;
    memcpy(&st,&pNode->m_nodeinfo,sizeof(st_nodeinfo));
    if(st.mtype==0) return 0;
    char* buff=NULL;
    if(st.m_SegmentPid>0&&st.m_iSize>0)
    {
	buff=new char[st.m_iSize];memset(buff,0x00,st.m_iSize);
	memcpy(buff,(void*)st.m_SegmentPid,st.m_iSize);
	st.m_SegmentPid=cs.WriteSegment(buff,st.m_iSize,true);
	if(st.m_SegmentPid<=0)
	{
	    delete[] buff;st.m_SegmentPid=0;return 0;
	}
	delete[] buff;buff=NULL;st.m_SegmentPid=0;
    }
    if(Send_Message(qid,&st,sizeof(st_nodeinfo))<0) return 0;
    return 1;
}

bool CMessageQueue :: SendMessage(int *qid,void* ppNode)
{
    st_nodeinfo st;CSegment cs;
    memset(&st,0x00,sizeof(st_nodeinfo));
    CDataNode* pNode=(CDataNode*)ppNode;
    if(!pNode) return 0;
    memcpy(&st,&pNode->m_nodeinfo,sizeof(st_nodeinfo));
    if(st.mtype==0) return 0;
    char* buff=NULL;
    if(st.m_SegmentPid>0&&st.m_iSize>0)
    {
	buff=new char[st.m_iSize];memset(buff,0x00,st.m_iSize);
	memcpy(buff,(void*)st.m_SegmentPid,st.m_iSize);
	st.m_SegmentPid=cs.WriteSegment(buff,st.m_iSize,true);
	if(st.m_SegmentPid<=0)
	{
	    delete[] buff;buff=NULL;st.m_SegmentPid=0;return 0;
	}
	delete[] buff;st.m_SegmentPid=0;
    }
    for(int j=0;j<MESSAGEQUEUES;j++)
    {
	if(Send_Message(qid[j],&st,sizeof(st_nodeinfo))>=0) return 1;
    }
    //发送失败,删除共享内存
    cs.Remove_Segment(st.m_SegmentPid);
    return 0;
}

bool CMessageQueue :: ReadMessage(int qid,int pid,st_nodeinfo* msgbuf)
{
    CSegment cs;
    memset(msgbuf,0x00,sizeof(st_nodeinfo));
    if(!Peek_Message(qid,pid)) return false;
    if(Read_Message(qid,pid,msgbuf,sizeof(st_nodeinfo))<0) return false;
    char* buff=NULL;
    if(msgbuf->m_iSize>0&&msgbuf->m_SegmentPid>0)
    {
	buff=new char[msgbuf->m_iSize];   //此处不删除,在数据处理线程中删除
	memset(buff,0x00,msgbuf->m_iSize);
	cs.ReadSegment(msgbuf->m_SegmentPid,buff,msgbuf->m_iSize);
	msgbuf->m_SegmentPid=(long)buff;
    }
    return true;
}
/////////////////////////////清除队列中有关某个进程的消息队列///////////////////////////////
void CMessageQueue :: ClearMessage(int qid,int pid)
{
    st_nodeinfo st;
    while(1)
    {
	if(!ReadMessage(qid,pid,&st)) break;
	//有消息,则删除伴随数据
	char* buff=NULL;
	if(st.m_SegmentPid>0)
	{
	    buff=(char*)st.m_SegmentPid;
	    if(buff)
	    {
		delete [] buff;buff=NULL;st.m_SegmentPid=0;
	    }
	}
    }
}

CNodeManage :: CNodeManage()
{
    m_SendNode.setAutoDelete (true);
    m_RecvNode.setAutoDelete (true);
    return;
};

CNodeManage :: ~CNodeManage()
{
    m_SendNode.clear();
    m_RecvNode.clear();
    m_DeviceNode.clear();
    m_DispNode.clear();
    return;
};

CDeviceNode* CNodeManage ::FindDevicebyEquipNo(int EquipNo,int Level,int & index)
{
    CDeviceNode* pNode=NULL;
    index=-1;
    DeviceInfoListType::iterator it;
    for(int i=0;i<(int)m_DeviceNode.count();i++)
    {
	pNode=m_DeviceNode.at(i);
	if(Level==0)
	{
	    if((int)pNode->m_deviceinfo.m_MachineNo==EquipNo) return pNode;
	}
	else if(Level==1)	   //查找二级接点
	{
	    for(int j=0;j<(int)pNode->m_ChildDevList.count();j++)
	    {
		it=pNode->m_ChildDevList.at(j);
		if((int)(*it).m_MachineNo==EquipNo)
		{
		    index=j;return pNode;
		}
	    }
	}
	else
	{
	    if((int)pNode->m_deviceinfo.m_MachineNo==EquipNo) return pNode;
	    for(int j=0;j<(int)pNode->m_ChildDevList.count();j++)
	    {
		it=pNode->m_ChildDevList.at(j);
		if((int)(*it).m_MachineNo==EquipNo)
		{
		    index=j;return pNode;
		}
	    }
	}
    }
    return NULL;
}

CDataNode* CNodeManage::FindCmdFromRDN(int EquipNo)
{
    int iSize = m_RecvNode.count();
    if (iSize == 0) return NULL;
    CDataNode* pDataNode = NULL;
    for (int i=0; i<iSize; i++)
    {
	pDataNode = m_RecvNode.at(i);
	if (pDataNode->m_nodeinfo.m_CurrentThread != 0)
	{
	    if (pDataNode->m_nodeinfo.m_MachineNo == EquipNo)
	    {
		return pDataNode;
	    }
	}
    }
    return NULL;
}

CDataNode* CNodeManage::FindCmdFromRDN(long threadid, int EquipNo /* = 0 */)
{
    int iSize = m_RecvNode.count();
    if (iSize == 0) return NULL;
    CDataNode* pDataNode = NULL;
    for (int i=0; i<iSize; i++)
    {
	pDataNode = m_RecvNode.at(i);
	if (pDataNode->m_nodeinfo.m_CurrentThread == threadid)
	{
	    if (EquipNo != 0)
	    {
		if (pDataNode->m_nodeinfo.m_MachineNo == EquipNo)
		{
		    return pDataNode;
		}
	    }
	    else return pDataNode;
	}
    }
    return NULL;
}

CDataNode* CNodeManage :: FindRecvDataNode()
{
    if(m_RecvNode.count()>0)
	return m_RecvNode.at(0);
    return NULL;
}
//Modify	20063-16
CDataNode* CNodeManage :: FindRecvDataNodeEx(long ithreadid /* = -1 */)
{
    if (ithreadid == -1)
    {
	if (m_RecvNode.count() > 0)
	    return m_RecvNode.at(0);
	return NULL;
    }
    int iSize = m_RecvNode.count();
    if (iSize == 0) return NULL;
    CDataNode* pDataNode = NULL;
    for (int i=0; i<iSize; i++)
    {
	pDataNode = m_RecvNode.at(i);
	if (pDataNode->m_nodeinfo.m_TransThread == ithreadid)
	{
	    return pDataNode;
	}
    }
    return NULL;
}

CDataNode* CNodeManage :: FindRecvDataNode(long ithreadid /* = -1 */)
{
    if (ithreadid == -1)
    {
	if (m_RecvNode.count() > 0)
	    return m_RecvNode.at(0);
	return NULL;
    }
    int iSize = m_RecvNode.count();
    if (iSize == 0) return NULL;
    CDataNode* pDataNode = NULL;
    for (int i=0; i<iSize; i++)
    {
	pDataNode = m_RecvNode.at(i);
	if (pDataNode->m_nodeinfo.m_CurrentThread == ithreadid)
	{
	    return pDataNode;
	}
    }
    return NULL;
}

void CNodeManage :: DeleteRecvDataNode(CDataNode* pNode)
{
    if(!pNode) return;
    char* buff=NULL;
    if(pNode->m_nodeinfo.m_SegmentPid>0)
    {
	buff=(char*)pNode->m_nodeinfo.m_SegmentPid;
	if(buff)
	{
	    delete [] buff;buff=NULL;pNode->m_nodeinfo.m_SegmentPid=0;
	}
    }
    m_RecvNode.remove(pNode);
}

bool CNodeManage :: AddDispDataNode(void* ppNode)
{
    m_DispNode.append((CDataNode*)ppNode);
    return 1;
}

CDataNode* CNodeManage :: FindDispDataNode()
{
    if(m_DispNode.count()>0)
	return m_DispNode.at(0);
    return NULL;
}

void CNodeManage :: DeleteDispDataNode(CDataNode* pNode)
{
	if (!pNode) return;
    char* buff=NULL;
    if (pNode->m_nodeinfo.m_SegmentPid>0)
    {
		buff=(char*)pNode->m_nodeinfo.m_SegmentPid;
		delete [] buff;buff=NULL;pNode->m_nodeinfo.m_SegmentPid=0;
    }
    m_DispNode.remove(pNode);
}

//***************用于下发命令的函数***************************************
bool CNodeManage :: AddSendDataNode(long DestPid,long DestThread,unsigned int DataType,
				    int iMachineNo,char* UniqueCmd,int iResult,char* RecordFlag)
{
    st_nodeinfo st;
    memset(&st,0x00,sizeof(st_nodeinfo));
    if(DestPid==0) return 0;	//如果目标进程号为零不用发送
    st.mtype=DestPid;st.requestid=getpid();st.m_CurrentThread=DestThread;st.m_DataType=DataType;
    st.m_DataFrom=0;st.m_iResult=iResult;st.m_DisplayFlag=1;
    st.m_Level=0;st.m_TransThread=0;st.m_MachineNo=iMachineNo;
    if(UniqueCmd!=NULL)
	strcpy(st.m_UniqueCmd,UniqueCmd);
    if(RecordFlag!=NULL)
	strcpy(st.m_RecordFlag,RecordFlag);
    CDataNode* pNode=new CDataNode();
    memcpy(&pNode->m_nodeinfo,&st,sizeof(st_nodeinfo));
    m_SendNode.append(pNode);