federate.cpp

一个用HLA编写的聊天程序

//Federate.cpp: the implementation of the CFederate class
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Global.h"
#include "Federate.h"

#include "Resource.h"
#include "ChatView.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

extern RTI::RTIambassador   RtiAmb;
extern RTI::Boolean TimeAdvGrant;
extern RTIfedTime  GrantTime;
CFederateAmbassador         FedAmb;
extern CChatView* pView;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CFederate::CFederate()
{
	ms_Lookahead = 0.100000;
	ms_TimeStamp = 0.0;

	m_ConstrainedEnabled = RTI::RTI_TRUE;
	m_RegulationEnabled = RTI::RTI_TRUE;

	m_TimeStep = 0.100000;
	m_CurrentTime = ms_TimeStamp;
	m_PrevTime = ms_TimeStamp;
	m_NextTime = ms_TimeStamp;
	m_InitTime = 58478.000000;
	m_SimTime = m_InitTime;

	m_FedHandle = 0;
	m_FederationName = "";
	m_FederateName = "";
	m_FedFileName = "chat.fed";
}

CFederate::~CFederate()
{
	m_Pub_Persons.DeleteAllObjInst();
	m_Sub_Persons.DeleteAllObjInst();
}

void CFederate::SetLookahead(RTIfedTime &theTime)
{
	ms_Lookahead = theTime;
}

RTIfedTime CFederate::GetLookahead()
{
	return ms_Lookahead;
}

void CFederate::SetTimeStamp(RTIfedTime theTime)
{
	ms_TimeStamp = theTime;
}

RTIfedTime CFederate::GetTimeStamp()
{
	return ms_TimeStamp;
}

void CFederate::SetRegulationFlag(RTI::Boolean theFlag)
{
	m_RegulationEnabled = theFlag;
}

RTI::Boolean CFederate::GetRegulationFlag()
{
	return m_RegulationEnabled;
}

void CFederate::SetConstrainedFlag(RTI::Boolean theFlag)
{
	m_ConstrainedEnabled = theFlag;
}

RTI::Boolean CFederate::GetConstrainedFlag()
{
	return m_ConstrainedEnabled;
}

RTI::FederateHandle CFederate::GetFederateHandle()
{
	return m_FedHandle;
}

CString& CFederate::GetFederationName()
{
	return m_FederationName;
}

CString& CFederate::GetFederateName()
{
	return m_FederateName;
}

CString& CFederate::GetFedFileName()
{
	return m_FedFileName;
}

//{{FW_FEDERATE_MANAGEMENT_SERVICE_DEFINE_BEGIN}} <<----- Don't delete it!>>
void CFederate::CreateFederation()
{
	try{
#ifdef	KD_RTI
		RtiAmb.createFederationExecution(m_FederationName,m_FedFileName);
#else
#ifdef pRTI
		RtiAmb.createFederationExecution(m_FederationName,"file:" + m_FedFileName);
#else
		RtiAmb.createFederationExecution(m_FederationName,m_FedFileName);
#endif
#endif
	}
	catch (RTI::FederationExecutionAlreadyExists&)
	{
		// Caught and ignored -- effectively allowing this condition.
		int YesorNo=AfxMessageBox("FED:联邦"+m_FederationName+"已经创建。\n是否加入该联邦？" , MB_YESNO|MB_ICONQUESTION);
		if(YesorNo==IDNO) {
			CString errInfo = "";

			throw errInfo;
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::JoinFederation()
{
	// Attempt to join the federation.
	for(int timer = MAX_JOIN_TRIES;timer;)
	{
		try{
			m_FedHandle = RtiAmb.joinFederationExecution(
				m_FederateName, m_FederationName,
				&FedAmb);
			// If no exceptions encountered, abandon loop.
			timer = 0;
		}
		catch(RTI::FederationExecutionDoesNotExist& e)
		{
			if(--timer == 0)
			{
				AfxMessageBox("FED:加入联邦执行失败!"+CString(e._reason),MB_OK|MB_ICONSTOP);
				return;
			}
			else
			{
				RtiAmb.tick(0.0001,0.1);
			}
		}
		catch(RTI::Exception& e)
		{
			CString errInfo;

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

void CFederate::ResignFederationExecution()
{
	try{
		RtiAmb.resignFederationExecution(RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES );
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::DestroyFederationExecution()
{
	try{
		RtiAmb.destroyFederationExecution(m_FederationName);
	}
	catch(RTI::FederatesCurrentlyJoined&)
	{
		AfxMessageBox("联邦中仍有其它成员，不能撤销联邦!");
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

RTI::FederateHandleSet* CFederate::BuildFederateSet(RTI::FederateHandle theHandlesList[], int nFedHandle)
{
	ASSERT(nFedHandle > 0);
	RTI::FederateHandleSet *theFedHandles = NULL;

	if(nFedHandle == 0)
	  return theFedHandles;
	theFedHandles = RTI::FederateHandleSetFactory::create(nFedHandle);
	for (int i = 0; i < nFedHandle; i++) {
		theFedHandles->add(theHandlesList[i]);
	}

	return theFedHandles;
}

void CFederate::RegisterSyncPiont(char *theLabel, char *theTag, RTI::FederateHandleSet *theFedHandles)
{
	//加入同步点集
	CSyncPiont synpoint(theLabel, theTag);
	synpoint.setRegister(true);
	m_SynPoints.Add(synpoint);

	try{
		if (theFedHandles != NULL)
		{
			RtiAmb.registerFederationSynchronizationPoint(theLabel, theTag,*theFedHandles);
			delete theFedHandles;
		}
		else 
			RtiAmb.registerFederationSynchronizationPoint(theLabel, theTag);
    }
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: RegisterSyncPiont(char*, char*, RTI::FederateHandleSet*)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::SyncPointAchived(const char *theLabel)
{
	try{	
		RtiAmb.synchronizationPointAchieved(theLabel);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

		errInfo = "error located: SyncPointAchived(const char*)\n";
		errInfo += "error message:";
		errInfo += CString(e._reason);
		errInfo += "\n";
		TRACE0(errInfo);
		throw errInfo;
	}
}

void CFederate::FederateSaveComplete()
{
	try{	
		RtiAmb.federateSaveComplete();
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:联邦存储已完成!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::FederateSaveBegun()
{
	try{
		RtiAmb.federateSaveBegun();
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:联邦存储开始!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::FederateSaveNotComplete()
{
	try{
		RtiAmb.federateSaveNotComplete();
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:联邦存储未完成!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::RequestFederationSave(const char *theLable, const RTIfedTime  &theTime)
{
	try{
		RtiAmb.requestFederationSave(theLable,theTime);
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:请求联邦保存!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::RequestFederationSave(const char *theLable)
{
	try{
		RtiAmb.requestFederationSave(theLable);
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:请求联邦保存!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::FederateRestoreComplete()
{
	try{
		RtiAmb.federateRestoreComplete();
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:联邦重演完成!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::FederateRestoreNotComplete()
{
	try{
		RtiAmb.federateRestoreNotComplete();
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:联邦重演没有完成!:"+CString(e._reason),MB_OK);
		return;	
	}
}

void CFederate::RequestFederationRestore(const char *theLabel)
{
	try{
		RtiAmb.requestFederationRestore(theLabel);
	}
	catch(RTI::Exception& e)
	{
		AfxMessageBox("FED:请求联邦重演!:"+CString(e._reason),MB_OK);
		return;	
	}
}
//{{FW_FEDERATE_MANAGEMENT_SERVICE_DEFINE_END}} <<----- Don't delete it!>>

//{{FW_DECLARATIONE_MANAGEMENT_SERVICE_DEFINE_BEGIN}} <<----- Don't delete it!>>
void CFederate::InitRTI()
{
	CFWBaseClass::SetRtiAmb(RtiAmb);
	CPub_Person::Init();
	CSub_Person::Init();

	Communication_inter::SetRtiAmb(RtiAmb);
	Communication_inter::Init();

}

void CFederate::PublishAndSubscribe()
{
	CPub_Person::Publishing();

	CSub_Person::Subscribing();

	Communication_inter::Publishing();

	Communication_inter::Subscribing();
}

void CFederate::UnpublishObjectClass(RTI::ObjectClassHandle theClass)
{
	try{
		RtiAmb.unpublishObjectClass(theClass);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::UnsubscribeObjectClass(RTI::ObjectClassHandle theClass)
{
	try{
		RtiAmb.unsubscribeObjectClass(theClass);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::UnpublishInteractionClass(RTI::InteractionClassHandle theClass)
{
	try{
		RtiAmb.unpublishInteractionClass(theClass);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::UnsubscribeInteractionClass(RTI::InteractionClassHandle theClass)
{
	try{
		RtiAmb.unsubscribeInteractionClass(theClass);
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

//{{FW_OBJECT_MANAGEMENT_SERVICE_DEFINE_BEGIN}} <<----- Don't delete it!>>
void CFederate::Register()
{
	try{
		int size = 0, i = 0;

		size = m_Pub_Persons.GetSize();
		for(i = 0; i < size; i++)
		{
			m_Pub_Persons.GetAt(i)->RegisterObject();
		}

	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::DeleteObjInst()
{
	int i = 0;

	for(i = 0; i < m_Pub_Persons.GetSize(); i++) {
		if( OBJNOHANDLE != m_Pub_Persons[i]->GetInstID() &&
			ATTRNOHANDLE != m_Pub_Persons[i]->ms_PrivilegeToDeleteId) {
			DeletePubObjectInstance(m_Pub_Persons[i]->GetInstID());
		}
	}
	m_Pub_Persons.DeleteAllObjInst();

	m_Sub_Persons.DeleteAllObjInst();
}

void CFederate::DeletePubObjectInstance(RTI::ObjectHandle theObject)
{
	try{
		if(m_RegulationEnabled) {
			RtiAmb.deleteObjectInstance(theObject,GetTimeStamp(), NULL);
		} else {
			RtiAmb.deleteObjectInstance(theObject,NULL);
		}
	}
	catch(RTI::Exception& e)
	{
		CString errInfo;

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

void CFederate::LocalDeleteObjectInstance(RTI::ObjectHandle theObject)
{
	BOOL delFlag = FALSE;
	
	if( m_Sub_Persons.FindObjInst(theObject) && !delFlag) {
		m_Sub_Persons.RemoveObjInst(theObject);