lgrHlaSimManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef lgrHlaSimManager_H_
#define lgrHlaSimManager_H_

#if DtHLA

#include <lgrSim/lgrSim.h>
#include "lgrBaseSimManager.h"
#include <lgrSim/lgrHlaConfigData.h>
#include <lgrUtil/virtualConstructor.h>
#include "subscriptionListFile.h"

#if DtHLA_1516
#if DtHLA_1516_EVOLVED
#include <RTI/time/HLAfloat64Time.h>
#include <RTI/time/HLAfloat64Interval.h>
#else
#include <RTI/logicalTimeImpl.h>
#include <RTI/logicalTimeIntervalImpl.h>
#endif
#else
#include <fedtime.hh>
#endif

#include <vl/rtiNamespace.h>
#include <vl/geodeticRegion.h>

#include <set>
#include <vector>

class DtObjectPublisher;
class DtExerciseConnInitializer;
class DtExerciseConn;
class DtHlaObjectFactory;
class DtHlaObject;
class DtStateRepository;
class DtInteraction;
class DtHlaTAFilter;

namespace MAKTrafficClientServerExConn
{
   class DtServerExerciseConnection;
}

namespace MAKLogger
{
   class DtLogger;
   class DtLgrOnlineFomDesc;
   class DtLgrClock;
   class DtMessageBuffer;
   class DtLgrHlaMessageState;
   class DtLgrHlaSimOutput;
   class DtLgrHlaSimInput;
   class DtLgrHlaTimeProvider;
   class DtLgrHlaSimDriver;
   class DtLgrFomWithRegions;

   enum DtPlaybackRegionMode
   {
      DtPlaybackRegionNotEnabled,
      DtPlaybackRegionsUseData,
      DtPlaybackRegionsUseConveyedExtents
   };

   enum DtSubscribeRegionMode
   {
      DtSubscribeRegionNotEnabled,
      DtSubscribeRegionsAreSpecified,
      DtSubscribeRegionsAreGlobal
   };

   class DT_DLL_LGRSIM DtLgrHlaSimulationManager : public DtLgrBaseSimManager
   {
   public:


      DT_VIRTUAL_CTR(DtLgrHlaSimulationManager,(DtLogger& logger,
         DtLgrHlaSimDriver* simDriverPtr))
      virtual ~DtLgrHlaSimulationManager();

      virtual void setExerciseConn(DtExerciseConn* exconn);

      virtual void tick();

      virtual bool isConnected() const;

      virtual bool isConnectionOk() const;

      virtual void setSubscriptionListToAll();

      virtual void setObjectSubscriptionList(const std::vector<DtString>& objectClasses);

      virtual void setInteractionSubscriptionList(const std::vector<DtString>& interactionClasses);

      virtual void setSubscriptionList(const DtSubscriptionListFile& list);

      virtual const DtSubscriptionListFile& subscriptionList() const;

      virtual std::vector<DtString> objectSubscriptionList() const;

      virtual std::vector<DtString> interactionSubscriptionList() const;

      virtual void subscribeToData();

      virtual void unsubscribeToData();

      virtual void addTrafficAnalyzerFilter(DtHlaTAFilter* taFilter);

      virtual void removeTrafficAnalyzerFilter(DtHlaTAFilter* taFilter);

      virtual bool evaluateTrafficAnalyzerFilters(
         const DtStateRepository& stateRep, const DtHlaObject& obj);

      virtual bool evaluateTrafficAnalyzerFilters(const DtInteraction& interaction);

      virtual const DtLgrSimInput* input() const;
      virtual DtLgrSimInput* input();

      virtual const DtLgrSimOutput* output() const;
      virtual DtLgrSimOutput* output();

      virtual const DtMessageState* state() const;
      virtual DtMessageState* state();

      virtual DtLgrFileInput* openFileForInput(const DtString& filename) const;


      virtual DtLgrFileOutput* openFileForCopying(const DtString& filename,
         const DtLgrFileInput* input) const;

      virtual DtLgrFileOutput* openFileForOutput(const DtString& filename,
         const DtString& description) const;

      virtual DtLgrFileInput* openPartialFileForCopying(
         const DtLgrFileOutput* output, DtFilePosition firstPacket,
         DtFilePosition lastPacket) const;

      virtual void initPlayback(DtLgrFileInput& input);


      virtual DtMessageState* createState() const;

      virtual bool connect(DtExerciseConnInitializer& initializer, DtString& failureReason);

      virtual void connectShared(DtExerciseConn* exConn);

      virtual void disconnect();

      typedef DtObjectPublisher* (DtPublisherCreator)();

      virtual bool ignoreAdvisories() const;

      virtual void setDrainInputMaxTime(double maxTime);

      virtual void setDrainInputMinTime(double minTime);

      virtual double drainInputMaxTime() const;

      virtual double drainInputMinTime() const;

      virtual void setPassiveSubscription(bool ignore);

      virtual bool passiveSubscription() const;

      virtual void setDdmEnabled( bool enableDdm );

      virtual bool ddmEnabled() const;

      virtual void setTrafficAnalyzerEnabled( bool enableTrafficAnalyzer );

      virtual bool trafficAnalyzerEnabled() const;

      virtual void setSendOnlyUpdatedValues(bool updatesOnly);
      virtual bool sendOnlyUpdatedValues() const;

      virtual const DtLgrOnlineFomDesc* fomDescription() const;

      virtual DtHlaObjectFactory* defaultObjectFactory();

      virtual void setTimeManagementSettings(bool constrainOnRecord,
         bool constrainOnPlayback,bool regulateOnRecord,bool regulateOnPlayback,
         double lookAheadTime);

      virtual bool isTimeManagementEnabled() const;

      virtual bool enableTimeConstrained();

      virtual bool testTimeManagement();

      virtual bool disableTimeConstrained();

      virtual bool isTimeConstrained() const;

      virtual bool enableTimeRegulating(double lookAheadInterval);

      virtual bool disableTimeRegulating();

      virtual bool isTimeRegulating() const;

      virtual void registerTimeAdvanceGrant();

      virtual void unregisterTimeAdvanceGrant();

      virtual double requestTimeAdvance();

      virtual double requestAdvanceToNextEvent();

      virtual bool isTimeAdvanceGrantRegistered() const;

      virtual double lookAheadTime() const;

      virtual double workingLookAheadTime() const;

      virtual bool constrainOnRecord() const;

      virtual bool constrainOnPlayback() const;

      virtual bool regulateOnRecord() const;

      virtual bool regulateOnPlayback() const;

      virtual void setInitialTime(DtAbsoluteTime initialTime);

      virtual double fedTime() const;

      virtual double requestedTime() const;

      virtual double initialFedTime() const;
      
      virtual double timeAdvanced() const;

      virtual bool isTimeAdvancing() const;

      virtual bool isRequestingNextEvent() const;

      virtual bool isRequestingTimeAdvance() const;

      virtual void setDisableTimeManagementTest(bool disableTest);

      virtual bool isValidTime(const DtAbsoluteTime&  packetTime) const;

      virtual void setAllowUnsubscribes(bool allowUnsubscribe);

      virtual bool allowUnsubscribes() const;

      //virtual bool subscribeInteractionWithRegion(

      virtual const DtString& dynamicNamePrefix() const;

      virtual void setDynamicNamePrefix(const DtString& dynamicNamePrefix);

      virtual DtLgrHlaSimDriver* simDriver();

      virtual const DtLgrHlaSimDriver* simDriver() const;


      virtual bool testDdm() const;

      virtual bool addPlaybackRegionSetForObjectName(const DtString& objectName, const DtString& regionSetName);

      virtual void removePlaybackRegionSetForObjectName(const DtString& objectName);

      virtual unsigned int getPlaybackRegionSetForObjectName(DtString objectName,
         DtDDMRegionSet& regionSet, bool cacheRegions=true);

      virtual bool addPlaybackRegionSetForInteractionClass(const DtString& className, const DtString& regionSetName);

      virtual void removePlaybackRegionSetForInteractionClass(const DtString& className);

      virtual unsigned int getPlaybackRegionSetForInteractionClass(DtString className,
         DtDDMRegionSet& regionSet, bool cacheRegions=true);

      virtual void subscribeToList(const DtSubscriptionListFile& sublist);

      virtual void setPublicationList(const DtSubscriptionListFile& publist);

      virtual const DtSubscriptionListFile& publicationList() const;

      virtual void setConfigurationFileName(const DtString& filename);

      virtual DtLgrFomWithRegions *fomWithRegions();

      virtual MAKLogger::DtPlaybackRegionMode playbackRegionMode() const;

      virtual void setPlaybackRegionMode(MAKLogger::DtPlaybackRegionMode val);

      virtual MAKLogger::DtSubscribeRegionMode subscribeRegionMode() const;

      virtual void setSubscribeRegionMode(MAKLogger::DtSubscribeRegionMode val);

      virtual bool playbackRegionDynamicAssociationEnabled() const;

      virtual void setPlaybackRegionDynamicAssociationEnabled(bool val);

      virtual bool playbackRegionDynamicExtentsEnabled() const;

      virtual void setPlaybackRegionDynamicExtentsEnabled(bool val);

      virtual bool recordConveyedRegionsEnabled() const;

      virtual void setRecordConveyedRegionsEnabled(bool val);

      virtual bool requestUpdatesEnabled() const;

      virtual void setRequestUpdatesEnabled(bool val);

      virtual bool subscribeUnspecifiedAttributesEnabled() const;

      virtual void setSubscribeUnspecifiedAttributesEnabled(bool val);

      virtual bool playbackWithoutRegionsEnabled() const;

      virtual void setPlaybackWithoutRegionsEnabled(bool val);

      virtual bool subscribeToAllClassesEnabled() const;

      virtual void setSubscribeToAllClassesEnabled(bool val);


   protected:

      virtual const DtLgrHlaConfigData& configData() const;

      virtual bool getSubscribeRegionSetForObjectClass(const DtString& classname, DtDDMRegionSet& regionSet) const;

      virtual bool getSubscribeRegionSetForInteractionClass(const DtString& classname, DtDDMRegionSet& regionSet) const;

      virtual bool getGlobalObjectRegionSet(const DtString& className, DtDDMRegionSet& regionSet);

      virtual bool getGlobalInteractionRegionSet(const DtString& className, DtDDMRegionSet& regionSet);


      virtual int drainInput();
      virtual int drainInput(DtTime maxTime, DtTime minTime);

#if DtHLA_1516_EVOLVED
      typedef RTI::LogicalTime RtiTime;
      typedef RTI::LogicalTimeInterval RtiTimeInterval;
      typedef HLAfloat64Time RtiTimeImpl;
      typedef HLAfloat64Interval RtiTimeIntervalImpl;
#elif DtHLA_1516
      typedef RTI::LogicalTime RtiTime;
      typedef RTI::LogicalTimeInterval RtiTimeInterval;
      typedef LogicalTimeImpl RtiTimeImpl;
      typedef LogicalTimeIntervalImpl RtiTimeIntervalImpl;
#else
      typedef RTI::FedTime RtiTime;
      typedef RTI::FedTime RtiTimeInterval;
      typedef RTIfedTime RtiTimeImpl;
      typedef RTIfedTime RtiTimeIntervalImpl;
#endif

      virtual void timeAdvanceGrant( const RtiTime&);
      virtual void timeConstrainedEnable( const RtiTime&);
      virtual void timeRegulationEnable( const RtiTime&);
      virtual bool invokeEnableTimeConstrained(bool checkLongOperation, bool postWarnings);
      virtual bool invokeFlushQueue(RtiTimeImpl& newTime);
      virtual bool invokeQueryMinNextEventTime(RtiTimeImpl& nextTime);
      virtual bool invokeNextMessageRequest(RtiTimeImpl& nextTime, bool available);
      virtual bool invokeTimeAdvanceRequest(RtiTimeImpl& nextTime, bool available);
      virtual void initializeFederationTime();
      virtual bool invokeChangeLookAheadTime(double time);
      virtual bool invokeQueryLogicalTime(RtiTimeImpl&);


      virtual void setObjectClassSubscriptionState(const DtString& name, const DtDDMRegionSet& regionset, bool subscribeToClass);

      virtual void setInteractionClassSubscriptionState(const DtString& name, const DtDDMRegionSet& regionset, bool subscribeToClass);

      virtual void subscribeObjectClasses(const std::set<DtString>& objectClasses,
         const DtSubscriptionListFile& sublist);

      virtual void subscribeInteractionClasses(const std::set<DtString>& interactionClasses, const DtSubscriptionListFile& sublist);

      virtual void rtiErrorCb(const char* label);

   protected:

      static void timeAdvanceGrantCb( const RtiTime&, void* simMan);
      static void timeConstrainedEnableCb( const RtiTime&, void* simMan);
      static void timeRegulationEnableCb( const RtiTime&, void* simMan);
      static void rtiErrorCb(const char* label, void* simMan);

   protected:

      DtLgrHlaSimDriver* mySimDriver;
      DtLgrHlaMessageState* myMessageState;
      DtLgrHlaSimInput* myInput;
      DtLgrHlaSimOutput* myOutput;

      DtHlaObjectFactory* myDefaultObjectFactory;

      DtLgrOnlineFomDesc* myFomDescription;
      bool myIgnoreAdvisories;
      bool myPassiveSubscription;
      bool myTimeAdvanceGrantRegisterFlag;
      bool myIsTimeConstrainedFlag;
      bool myIsTimeRegulatingFlag;
      DtSubscriptionListFile* mySubscriptionList;
      DtSubscriptionListFile* myPublicationList;
      bool mySubscribedFlag;
      DtLgrHlaTimeProvider* myHlaTimeProvider;

      std::set<DtHlaTAFilter*> myTrafficAnalyzerFilters;

      bool myIsDDMEnabled;

      bool myTrafficAnalyzerEnabled;

      DtPlaybackRegionMode myPlaybackRegionMode;

      DtSubscribeRegionMode mySubscribeRegionMode;

      bool myPlaybackRegionDynamicAssociationEnabled;

      bool myPlaybackRegionDynamicExtentsEnabled;

      bool myRecordConveyedRegionsEnabled;

      bool myRequestUpdatesEnabled;

      bool mySubscribeUnspecifiedAttributesEnabled;
      
      bool mySubscribeToAllClassesEnabled;

      bool myPlaybackWithoutRegionsEnabled;

      bool mySendOnlyUpdatedValues;


      MAKTrafficClientServerExConn::DtServerExerciseConnection* myServerExerciseConnForResign;
      bool myRtiError;

      DtString myRtiErrorMessage;

      bool myPreviousRtiError;

      RtiTimeImpl* myFederationTime;
      RtiTimeIntervalImpl* myTimeAdvanced;
      double myEpsilon;
      double myRequestedTime;
      double myInitialFedTime;
      bool myRequestingTimeAdvance;
      bool myRequestingNextEvent;

      bool myConstrainOnRecord;
      bool myConstrainOnPlayback;
      bool myRegulateOnRecord;
      bool myRegulateOnPlayback;
      bool myTimeManagementEnabledFlag;
      double myLookAheadTime;
      double myWorkingLookAhead;
      bool myDisableTimeManagementTesting;
      bool myAllowUnsubscribe;
      double myDrainInputMaxTime;
      double myDrainInputMinTime;

      DtString myDynamicNamePrefix;

      DtLgrHlaConfigData myConfigData;

      typedef std::map<DtString, DtDDMRegionSet> DtNameRegionMap;

      // Map name to global region.
      // For 1.3, the name is the routing space.
      // For 1516, the name is the concatenation of the dimension names used for the region.
      DtNameRegionMap myGlobalRegions;

      // Map the object region name to the region instance
      DtNameRegionMap myObjectRegions;

      // Map the interaction region name to the region instance
      DtNameRegionMap myInteractionRegions;

      DtLgrFomWithRegions *myFomWithRegions;
   };

   const DtString& DtPlaybackRegionModeString(DtPlaybackRegionMode mode);
   const DtString& DtSubscribeRegionModeString(DtSubscribeRegionMode mode);

}

#endif
#endif