federate.cpp

一个用HLA编写的聊天程序

		delFlag = TRUE;
	}
	if(!delFlag)
		return;
	
	try{
		RtiAmb.localDeleteObjectInstance(theObject);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::LocalDeleteObjectInstance(RTI::ObjectHandle )\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::RequestClassAttributeValueUpdate(RTI::ObjectClassHandle theClass,
	 const RTI::AttributeHandleSet &theAttrHandles)
{
	try{
		RtiAmb.requestClassAttributeValueUpdate(theClass, theAttrHandles);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::RequestClassAttributeValueUpdate(RTI::ObjectClassHandle, const RTI::AttributeHandleSet&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::RequestObjAttributeValueUpdate(RTI::ObjectHandle theObject,
	 const RTI::AttributeHandleSet &theAttrHandles)
{
	try{
		RtiAmb.requestObjectAttributeValueUpdate(theObject,theAttrHandles);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::RequestClassAttributeValueUpdate(RTI::ObjectHandle, const RTI::AttributeHandleSet&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::DisableClassRelevanceAdvisorySwitch()
{
	try{
		RtiAmb.disableClassRelevanceAdvisorySwitch();
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DisableClassRelevanceAdvisorySwitch()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::EnableAttributeRelevanceAdvisorySwitch()
{
	try{
		RtiAmb.enableAttributeRelevanceAdvisorySwitch();
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::EnableAttributeRelevanceAdvisorySwitch()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::ProcessReceiveInter(RTI::InteractionClassHandle theClass,
	 const RTI::ParameterHandleValuePairSet &theParameters, const char	*tag)
{
	//Add your code to process the received interaction
	//{{FW_EXAMPLE_CODE_BEGIN
		// if(theClass == INTERACTION::GetClassId()) {
		// 	 INTERACTION	theInter;
		//	 theInter.Receive(theParameters);
		//
		//	 //Add you code here
		// }	
	//}}FW_EXAMPLE_CODE_END

	//判断是否接收发言交互
	if(theClass == Communication_inter::GetClassId())
	{
		//接收交互
		Communication_inter ReceiveInter;
		ReceiveInter.Receive(theParameters);

		unsigned long numOfData = 0;
    	char* charbuffer = NULL;
		int n;
		CString Name,Message;
		//读取发言者名字
		numOfData = ReceiveInter.m_name.size();
	    charbuffer = new char[numOfData + 1];
	    memset(charbuffer, 0, numOfData + 1);
	    ReceiveInter.m_name.copy(charbuffer, numOfData);
		CString str;
		str = " 说：";
	    Name = charbuffer+str;
		//读取发言内容
		numOfData = ReceiveInter.m_message.size();
	    charbuffer = new char[numOfData + 1];
	    memset(charbuffer, 0, numOfData + 1);
	    ReceiveInter.m_message.copy(charbuffer, numOfData);
	    Message = charbuffer;
		//显示发言内容
		n = pView->m_MessageList.GetCount();
		pView->m_MessageList.InsertString(n,Name);
		pView->m_MessageList.InsertString(n+1,Message);

	}
}

void CFederate::ProcessReceiveInter(RTI::InteractionClassHandle theClass,
	 const RTI::ParameterHandleValuePairSet &theParameters, const RTI::FedTime &theFederateTime, const char	*tag)
{
	//Add your code to process the received interaction
	//{{FW_EXAMPLE_CODE_BEGIN
		// if(theClass == INTERACTION::GetClassId()) {
		// 	 INTERACTION	theInter;
		//	 theInter.Receive(theParameters);
		//
		//	 //Add you code here
		// }	
	//}}FW_EXAMPLE_CODE_END
	if(theClass == Communication_inter::GetClassId())
	{
		Communication_inter ReceiveInter;
		ReceiveInter.Receive(theParameters);
		unsigned long numOfData = 0;
    	char* charbuffer = NULL;
		CString Message;
		numOfData = ReceiveInter.m_message.size();
	    charbuffer = new char[numOfData + 1];
	    memset(charbuffer, 0, numOfData + 1);
	    ReceiveInter.m_message.copy(charbuffer, numOfData);
	    Message = charbuffer;
		

	}
}
//{{FW_OBJECT_MANAGEMENT_SERVICE_DEFINE_END}} <<----- Don't delete it!>>


//{{FW_DATA_DISTRIBUTION_MANAGEMENT_SERVICE_DEFINE_BEGIN}} <<----- Don't delete it!>>
//{{FW_DATA_DISTRIBUTION_MANAGEMENT_SERVICE_DEFINE_END}} <<----- Don't delete it!>>


//{{FW_TIME_MANAGEMENT_SERVICE_DEFINE_BEGIN}} <<----- Don't delete it!>>
void CFederate::DeclareTimeAdvanceConstrained()
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;
		RtiAmb.enableTimeConstrained();
		//-------------------------------
		// Tick the RTI until we get the timeConstrainedEnabled
		// callback with my current time.
		//---------------------------
		while ( !TimeAdvGrant )
		{
			RtiAmb.tick(0.0001, 0.1);
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DeclareTimeAdvanceConstrained()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::DeclareTimeAdvanceRegulation()
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;
		RtiAmb.enableTimeRegulation(GrantTime, ms_Lookahead);
		//-------------------------------
		// Tick the RTI until we get the timeConstrainedEnabled
		// callback with my current time.
		//---------------------------
		while ( !TimeAdvGrant )
		{
			RtiAmb.tick(0.0001, 0.1);
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DeclareTimeAdvanceRegulation()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::AdvanceTimeRequest(const RTIfedTime &theTime)
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;		
		if(m_RegulationEnabled || m_ConstrainedEnabled) {
			RtiAmb.timeAdvanceRequest(theTime);

			while( !TimeAdvGrant ) {
				RtiAmb.tick(0.0001, 0.1);
				Sleep(0);
			}
		} else {
			int nCount = 0;
			while( RtiAmb.tick(0.0001, 0.1) == RTI::RTI_TRUE && nCount++ <= 5) {
				Sleep(10);
			}
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::AdvanceTimeRequest(const RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::InitializeTimeManagement()
{
	if(!m_RegulationEnabled && !m_ConstrainedEnabled) {
		AfxMessageBox("This fedrate has neither been set into regulation \n nor been set into constrain!");
		return;
	} else if(m_RegulationEnabled && !m_ConstrainedEnabled) {
		DeclareTimeAdvanceRegulation();
	} else if(!m_RegulationEnabled && m_ConstrainedEnabled) {
		DeclareTimeAdvanceConstrained();
	} else {
		DeclareTimeAdvanceRegulation();
		DeclareTimeAdvanceConstrained();
	}
}

void CFederate::EnableAsynchronousDelivery()
{
	try{
		RtiAmb.enableAsynchronousDelivery();
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::EnableAsynchronousDelivery()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::DisableTimeConstrained()
{
	try{
		RtiAmb.disableTimeConstrained();
			
		m_ConstrainedEnabled = RTI::RTI_FALSE;
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DisableTimeConstrained()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::DisableTimeRegulation()
{
	try{
		RtiAmb.disableTimeRegulation();
			
		m_RegulationEnabled = RTI::RTI_FALSE;
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DisableTimeRegulation()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::AdvanceTimeRequestAvailable(const RTIfedTime &theTime)
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;		
		if(m_RegulationEnabled || m_ConstrainedEnabled) {
			RtiAmb.timeAdvanceRequestAvailable(theTime);

			while( !TimeAdvGrant ) {
				RtiAmb.tick(0.0001, 0.1);
				Sleep(0);
			}
		} else {
			int nCount = 0;
			while( RtiAmb.tick(0.0001, 0.1) == RTI::RTI_TRUE && nCount++ <= 5) {
				Sleep(10);
			}
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::AdvanceTimeRequestAvailable(const RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::AdvanceEventRequest(const RTIfedTime &theTime)
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;
		if(m_RegulationEnabled || m_ConstrainedEnabled) {
			RtiAmb.nextEventRequest(theTime);

			while( !TimeAdvGrant ) {
				RtiAmb.tick(0.0001, 0.1);
				Sleep(0);
			}
		} else {
			int nCount = 0;
			while( RtiAmb.tick(0.0001, 0.1) == RTI::RTI_TRUE && nCount++ <= 5) {
				Sleep(10);
			}
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::AdvanceEventRequest(const RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::AdvanceEventRequestAvailable(const RTIfedTime &theTime)
{
	try{
		TimeAdvGrant = RTI::RTI_FALSE;
		if(m_RegulationEnabled || m_ConstrainedEnabled) {
			RtiAmb.nextEventRequestAvailable(theTime);

			while( !TimeAdvGrant )
			{
				RtiAmb.tick(0.0001, 0.1);
			}
		} else {
			int nCount = 0;
			while( RtiAmb.tick(0.0001, 0.1) == RTI::RTI_TRUE && nCount++ <= 5) {
				Sleep(10);
			}
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::AdvanceEventRequestAvailable(const RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::FlushQueueRequest(const RTIfedTime &theTime)
{
	try{
		if(!m_RegulationEnabled && !m_ConstrainedEnabled) {
			return;
		}
		TimeAdvGrant = RTI::RTI_FALSE;
		RtiAmb.flushQueueRequest(theTime);

		while( !TimeAdvGrant )
		{
			RtiAmb.tick(0.0001, 0.1);
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::FlushQueueRequest(const RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::DisableAsynchronousDelivery()
{
	try{
		RtiAmb.disableAsynchronousDelivery();
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::DisableAsynchronousDelivery()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::QueryLBTS(RTIfedTime &theTime)
{
	try{
		RtiAmb.queryLBTS(theTime);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::QueryLBTS(RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::QueryFederateTime(RTIfedTime &theTime)
{
	try{
		RtiAmb.queryFederateTime(theTime);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::QueryFederateTime(RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::ModifyLookahead()
{
	try{
		RtiAmb.modifyLookahead(ms_Lookahead);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::ModifyLookahead()\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::QueryLookahead(RTIfedTime &theTime)
{
	try{
		RtiAmb.queryLookahead(theTime);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: CFederate::QueryLookahead(RTIfedTime&)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}
//{{FW_TIME_MANAGEMENT_SERVICE_DEFINE_END}} <<----- Don't delete it!>>
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////