federateStateRepository.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/


#ifndef federateStateRepository_H_
#define federateStateRepository_H_

#if DtHLA

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlString.h>
#include "variableDatumRecord.h"
#include <memory>
#include "rtiCompatibility.h"
#include "stateRepository.h"
#include "exerciseConnHLA.h"


class DT_DLL_VL DtFederateStateRepository : public DtStateRepository
{
public:
   enum DtFederateState
   {
      DtFedStateActiveFederate = 1,
      DtFedStateFederateSaveInProgress = 3,
      DtFedStateFederateRestoreInProgress = 5
   };

   enum DtTimeState
   {
      DtTimeStateTimeGranted = 0,
      DtTimeStateTimeAdvancing = 1
   };

public:
   DtFederateStateRepository();

   virtual ~DtFederateStateRepository();

   DtFederateStateRepository(const DtFederateStateRepository& orig);

   DtFederateStateRepository& operator=(const DtFederateStateRepository& orig);

   virtual DtStateRepository* clone(bool copy) const;

   static DtFederateStateRepository* create();

   virtual void printData() const;

   virtual void printDataToStream(std::ostream& stream) const;

   DtExerciseConn* exConn() const { return myExConn; }
   void setExConn(DtExerciseConn* val) { myExConn = val; }

   const RTI::FederateHandle& federateHandle() const;
   void setFederateHandle(const RTI::FederateHandle& val);

   const DtString& federateType() const;
   void setFederateType(const DtString& val);

#if DtHLA_1516

   bool conveyRegionDesignatorSets() const;
   void setConveyRegionDesignatorSets(bool val);
#endif

#if DtHLA_1516_EVOLVED

   const DtString& federateName() const;
   void setFederateName(const DtString& val);

   bool conveyProducingFederate() const;
   void setConveyProducingFederate(bool val);

   const std::vector<DtString>& fomModuleDesignatorList() const;
   void setFomModuleDesignatorList(const std::vector<DtString>& modules);


#endif

   const DtString& federateHost() const;
   void setFederateHost(const DtString& val);

   const DtString& rtiVersion() const;
   void setRtiVersion(const DtString& val);

   const DtString& fedId() const;
   void setFedId(const DtString& val);

   bool timeConstrained() const;
   void setTimeConstrained(bool val);

   bool timeRegulating() const;
   void setTimeRegulating(bool val);

   bool asynchronousDelivery() const;
   void setAsynchronousDelivery(bool val);

#if DtHLA_1516

   DtFederateState federateState() const;
   void setFederateState(DtFederateState val);

   DtTimeState timeManagerState() const;
   void setTimeManagerState(DtTimeState val);
#else

   const DtString& federateState() const;
   void setFederateState(const DtString& val);

   const DtString& timeManagerState() const;
   void setTimeManagerState(const DtString& val);
#endif

   const DtString& federateTime() const;
   void setFederateTime(const DtString& val);

   const DtString& lookahead() const;
   void setLookahead(const DtString& val);

   const DtString& lbts() const;
   void setLbts(const DtString& val);

   const DtString& minNextEventTime() const;
   void setMinNextEventTime(const DtString& val);

   int roLength() const;
   void setRoLength(int val);

   int tsoLength() const;
   void setTsoLength(int val);

   int reflectionsReceived() const;
   void setReflectionsReceived(int val);

   int updatesSent() const;
   void setUpdatesSent(int val);

   int interactionsReceived() const;
   void setInteractionsReceived(int val);

   int interactionsSent() const;
   void setInteractionsSent(int val);

   int objectsOwned() const;
   void setObjectsOwned(int val);

   int objectsUpdated() const;
   void setObjectsUpdated(int val);

   int objectsReflected() const;
   void setObjectsReflected(int val);

#if DtHLA_1516

   int objectsDeleted() const;
   void setObjectsDeleted(int val);

   int objectsRemoved() const;
   void setObjectsRemoved(int val);

   int objectsRegistered() const;
   void setObjectsRegistered(int val);

   int objectsDiscovered() const;
   void setObjectsDiscovered(int val);

   int timeGrantedTime() const;
   void setTimeGrantedTime(int val);

   int timeAdvancingTime() const;
   void setTimeAdvancingTime(int val);
#endif

protected:
   RTI::FederateHandle myFederateHandle;
   DtString myFederateType;
   DtString myFederateHost;
#if DtHLA_1516
   bool myConveyRegionDesignatorSets;
#endif
#if DtHLA_1516_EVOLVED
   DtString myFederateName;
   bool myConveyProducingFederate;
   std::vector<DtString> myFomModules;
#endif
   DtString myRtiVersion;
   DtString myFedId;
   bool     myTimeConstrained;
   bool     myTimeRegulating;
   bool     myAsynchronousDelivery;
#if DtHLA_1516
   DtFederateState myFederateState;
   DtTimeState myTimeManagerState;
#else
   DtString myFederateState;
   DtString myTimeManagerState;
#endif
   DtString myFederateTime;
   DtString myLookahead;
   DtString myLbts;
   DtString myMinNextEventTime;
   int      myRoLength;
   int      myTsoLength;
   int      myReflectionsReceived;
   int      myUpdatesSent;
   int      myInteractionsReceived;
   int      myInteractionsSent;
   int      myObjectsOwned;
   int      myObjectsUpdated;
   int      myObjectsReflected;
#if DtHLA_1516
   int      myObjectsDeleted;
   int      myObjectsRemoved;
   int      myObjectsRegistered;
   int      myObjectsDiscovered;
   int      myTimeGrantedTime;
   int      myTimeAdvancingTime;
#endif

   DtExerciseConn* myExConn;
};



#endif
#endif