federateInfo.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2011 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*******************************************************************************
** $RCSfile: federateStateInfo.h,v $ $Revision: 1.8 $ $State: Exp $
*******************************************************************************/

#ifndef federateInfo_H_
#define federateInfo_H_


#include <vlutil/vlSmartPointers.h>
#include <rtiMsConfig.h>
#include <assistantInfo.h>

class DT_DLL_ASSISTANT DtAssistantFederateInfo
{
public:

   DtAssistantFederateInfo() :
      myCompId(DtAssistantAnyId),
      myIsLocalComp(false),
      myConnId(0),
      myFederateType(),
      myFederateName(),
      myFederateHostName(),
      myFederateHandle(-1),
      myFederateHost(),
      myHlaVersion(DtHlaVersionUnknown),
      myTestEnabled(false),
      myTestInProgress(false),
      myContinuousTest(false),
      myNumInitiatedTests(0),
      myNumTestReports(0),
      myIsReconnecting(false),
      myIsDisconnected(false),
      myIsRegulating(false),
      myIsConstrained(false),
      myLbtsString(),
      myLookAheadString(),
      myTimeString(),
      myWebSpyAddr(),
      myWebSpyHttpPort(0),
      myWebSpyRtiPort(0),
      myWebSpyId(0),
      myHeartbeated(false),
      myAssistantInfo(),
      myFederationName(),
      myProcessName() {}

   ~DtAssistantFederateInfo() {}

   void setAssistantCompId(int val) { myCompId = val; }
   int assistantCompId() const { return myCompId; }

   void setAssistantInfo(const DtAssistantInfo& val) { myAssistantInfo = val; }
   const DtAssistantInfo& assistantInfo() const { return myAssistantInfo; }

   void setIsLocalComp(bool val) { myIsLocalComp = val; }
   bool isLocalComp() const { return myIsLocalComp; }

   void setConnId(unsigned long val) { myConnId = val; }
   int connId() const { return myConnId; }

   void setFederateType(const MAKRti::DtString& val) { myFederateType = val; }
   MAKRti::DtString federateType() const { return myFederateType; }

   void setFederateName(const MAKRti::DtString& val) { myFederateName = val; }
   MAKRti::DtString federateName() const { return myFederateName; }

   void setFederateHostName(const MAKRti::DtString& val) { myFederateHostName = val; }
   MAKRti::DtString federateHostName() const { return myFederateHostName; }

   void setFederateHostAddr(const MAKRti::DtInetAddr& val) { myFederateHost = val; }
   MAKRti::DtInetAddr federateHostAddr() const { return myFederateHost; }

   void setFederateHandle(int val) { myFederateHandle = val; }
   int federateHandle() const { return myFederateHandle; }

   void setWebSpyAddr(const MAKRti::DtInetAddr& addr) { myWebSpyAddr = addr; }
   MAKRti::DtInetAddr webSpyAddr() const { return myWebSpyAddr; }

   void setWebSpyHttpPort(int port) { myWebSpyHttpPort = port; }
   int webSpyHttpPort() const { return myWebSpyHttpPort; }

   void setWebSpyRtiPort(int port) { myWebSpyRtiPort = port; }
   int webSpyRtiPort() const { return myWebSpyRtiPort; }

   void setWebSpyId(int id) { myWebSpyId = id; }
   int webSpyId() const { return myWebSpyId; }

   void setHlaVersion(DtHlaVersionId val) { myHlaVersion = val; }
   DtHlaVersionId hlaVersion() const { return myHlaVersion; }

   void setTestEnabled(bool val) { myTestEnabled = val; }
   bool testEnabled() const { return myTestEnabled; }

   void setTestInProgress(bool val) { myTestInProgress = val; }
   bool testInProgress() const { return myTestInProgress; }

   void setContinuousTest(bool val) { myContinuousTest = val; }
   bool continuousTest() const { return myContinuousTest; }

   void setNumInitiatedTests(unsigned val) { myNumInitiatedTests = val; }
   unsigned numInitiatedTests() const { return myNumInitiatedTests; }

   void setNumTestReports(unsigned val) { myNumTestReports = val; }
   unsigned numTestReports() const { return myNumTestReports; }

   void setIsReconnecting(bool val) { myIsReconnecting = val; }
   bool isReconnecting() const { return myIsReconnecting; }

   void setIsDisconnected(bool val) { myIsDisconnected = val; }
   bool isDisconnected() const { return myIsDisconnected; }

   void setIsRegulating(bool val) { myIsRegulating = val; }
   bool isRegulating() const { return myIsRegulating; }

   void setIsConstrained(bool val) { myIsConstrained = val; }
   bool isConstrained() const { return myIsConstrained; }

   void setLbtsString(const MAKRti::DtString& val) { myLbtsString = val; }
   MAKRti::DtString lbtsString() const { return myLbtsString; }

   void setLookAheadString(const MAKRti::DtString& val) { myLookAheadString = val; }
   MAKRti::DtString lookAheadString() const { return myLookAheadString; }

   void setTimeString(const MAKRti::DtString& val) { myTimeString = val; }
   MAKRti::DtString timeString() const { return myTimeString; }

   void setFederationName(const MAKRti::DtString& val) { myFederationName = val; }
   MAKRti::DtString federationName() const { return myFederationName; }

   void setProcessName(const MAKRti::DtString& val) { myProcessName = val; }
   MAKRti::DtString processName() const { return myProcessName; }

   void setHeartbeated(bool val) { myHeartbeated = val; }
   bool heartbeated() const { return myHeartbeated; }

   bool operator==(const DtAssistantFederateInfo& rhs) const
   {
      return (
         connId() == rhs.connId() &&
         federateType() == rhs.federateType() &&
         federateName() == rhs.federateName() &&
         federateHostName() == rhs.federateHostName() && 
         federateHandle() == rhs.federateHandle() && 
         federateHostAddr() == rhs.federateHostAddr() && 
         hlaVersion() == rhs.hlaVersion() &&
         webSpyId() == rhs.webSpyId() &&
         webSpyAddr() == rhs.webSpyAddr() &&
         webSpyHttpPort() == rhs.webSpyHttpPort() &&
         webSpyRtiPort() == rhs.webSpyRtiPort() && 
         testEnabled() == rhs.testEnabled() &&
         testInProgress() == rhs.testInProgress() &&
         continuousTest() == rhs.continuousTest() &&
         numInitiatedTests() == rhs.numInitiatedTests() &&
         numTestReports() == rhs.numTestReports() &&
         isReconnecting() == rhs.isReconnecting() && 
         isDisconnected() == rhs.isDisconnected() && 
         isRegulating() == rhs.isRegulating() && 
         isConstrained() == rhs.isConstrained() &&
         lbtsString() == rhs.lbtsString() &&
         lookAheadString() == rhs.lookAheadString() &&
         timeString() == rhs.timeString() &&
         federationName() == rhs.federationName() &&
         processName() == rhs.processName() );
   }
   bool operator!=(const DtAssistantFederateInfo& rhs) const
   {
      return !(*this == rhs);
   }

protected:

   int myCompId;                    // the assistant assigned ID
   DtAssistantInfo myAssistantInfo; // the assistant managing this federate
   bool myIsLocalComp;    // is this component local to this assistant
   unsigned long myConnId;
   MAKRti::DtString myFederateType;
   MAKRti::DtString myFederateName;
   MAKRti::DtString myFederateHostName;
   int myFederateHandle;
   MAKRti::DtInetAddr myFederateHost;
   DtHlaVersionId myHlaVersion;
   MAKRti::DtString myFederationName;
   MAKRti::DtString myProcessName;

   bool myTestEnabled;
   bool myTestInProgress;
   bool myContinuousTest;
   unsigned myNumInitiatedTests;
   unsigned myNumTestReports;

   bool myIsReconnecting;
   bool myIsDisconnected;

   bool myIsRegulating;
   bool myIsConstrained;

   MAKRti::DtString myLbtsString;
   MAKRti::DtString myLookAheadString;
   MAKRti::DtString myTimeString;

   // Web server info
   MAKRti::DtInetAddr myWebSpyAddr;
   int myWebSpyHttpPort;
   int myWebSpyRtiPort;
   int myWebSpyId;

   bool myHeartbeated;
};

#endif